CoCalc -- locale.cpp

GitHub Repository: wine-mirror/wine
Path: blob/master/libs/c++/src/locale.cpp
¹²³⁴⁶ views
1
//===------------------------- locale.cpp ---------------------------------===//
2
//
3
//                     The LLVM Compiler Infrastructure
4
//
5
// This file is dual licensed under the MIT and the University of Illinois Open
6
// Source Licenses. See LICENSE.TXT for details.
7
//
8
//===----------------------------------------------------------------------===//
9

10
// On Solaris, we need to define something to make the C99 parts of localeconv
11
// visible.
12
#ifdef __sun__
13
#define _LCONV_C99
14
#endif
15

16
#include "string"
17
#include "locale"
18
#include "codecvt"
19
#include "vector"
20
#include "algorithm"
21
#include "typeinfo"
22
#ifndef _LIBCPP_NO_EXCEPTIONS
23
#  include "type_traits"
24
#endif
25
#include "clocale"
26
#include "cstring"
27
#if defined(_LIBCPP_MSVCRT)
28
#define _CTYPE_DISABLE_MACROS
29
#endif
30
#include "cwctype"
31
#include "__sso_allocator"
32
#if defined(_LIBCPP_MSVCRT) || defined(__MINGW32__)
33
#include "support/win32/locale_win32.h"
34
#elif !defined(__BIONIC__)
35
#include <langinfo.h>
36
#endif
37
#include <stdlib.h>
38
#include <stdio.h>
39
#include "include/atomic_support.h"
40
#include "__undef_macros"
41

42
// On Linux, wint_t and wchar_t have different signed-ness, and this causes
43
// lots of noise in the build log, but no bugs that I know of.
44
#if defined(__clang__)
45
#pragma clang diagnostic ignored "-Wsign-conversion"
46
#endif
47

48
_LIBCPP_BEGIN_NAMESPACE_STD
49

50
struct __libcpp_unique_locale {
51
  __libcpp_unique_locale(const char* nm) : __loc_(newlocale(LC_ALL_MASK, nm, 0)) {}
52

53
  ~__libcpp_unique_locale() {
54
    if (__loc_)
55
      freelocale(__loc_);
56
  }
57

58
  explicit operator bool() const { return __loc_; }
59

60
  locale_t& get() { return __loc_; }
61

62
  locale_t __loc_;
63
private:
64
  __libcpp_unique_locale(__libcpp_unique_locale const&);
65
  __libcpp_unique_locale& operator=(__libcpp_unique_locale const&);
66
};
67

68
#ifdef __cloc_defined
69
locale_t __cloc() {
70
  // In theory this could create a race condition. In practice
71
  // the race condition is non-fatal since it will just create
72
  // a little resource leak. Better approach would be appreciated.
73
  static locale_t result = newlocale(LC_ALL_MASK, "C", 0);
74
  return result;
75
}
76
#endif // __cloc_defined
77

78
namespace {
79

80
struct release
81
{
82
    void operator()(locale::facet* p) {p->__release_shared();}
83
};
84

85
template <class T, class A0>
86
inline
87
T&
88
make(A0 a0)
89
{
90
    static typename aligned_storage<sizeof(T)>::type buf;
91
    auto *obj = ::new (&buf) T(a0);
92
    return *obj;
93
}
94

95
template <class T, class A0, class A1>
96
inline
97
T&
98
make(A0 a0, A1 a1)
99
{
100
    static typename aligned_storage<sizeof(T)>::type buf;
101
    ::new (&buf) T(a0, a1);
102
    return *reinterpret_cast<T*>(&buf);
103
}
104

105
template <class T, class A0, class A1, class A2>
106
inline
107
T&
108
make(A0 a0, A1 a1, A2 a2)
109
{
110
    static typename aligned_storage<sizeof(T)>::type buf;
111
    auto *obj = ::new (&buf) T(a0, a1, a2);
112
    return *obj;
113
}
114

115
template <typename T, size_t N>
116
inline
117
_LIBCPP_CONSTEXPR
118
size_t
119
countof(const T (&)[N])
120
{
121
    return N;
122
}
123

124
template <typename T>
125
inline
126
_LIBCPP_CONSTEXPR
127
size_t
128
countof(const T * const begin, const T * const end)
129
{
130
    return static_cast<size_t>(end - begin);
131
}
132

133
_LIBCPP_NORETURN static void __throw_runtime_error(const string &msg)
134
{
135
#ifndef _LIBCPP_NO_EXCEPTIONS
136
    throw runtime_error(msg);
137
#else
138
    (void)msg;
139
    _VSTD::abort();
140
#endif
141
}
142

143
}
144

145
#if defined(_AIX)
146
// Set priority to INT_MIN + 256 + 150
147
# pragma priority ( -2147483242 )
148
#endif
149

150
const locale::category locale::none;
151
const locale::category locale::collate;
152
const locale::category locale::ctype;
153
const locale::category locale::monetary;
154
const locale::category locale::numeric;
155
const locale::category locale::time;
156
const locale::category locale::messages;
157
const locale::category locale::all;
158

159
class _LIBCPP_HIDDEN locale::__imp
160
    : public facet
161
{
162
    enum {N = 28};
163
#if defined(_LIBCPP_COMPILER_MSVC)
164
// FIXME: MSVC doesn't support aligned parameters by value.
165
// I can't get the __sso_allocator to work here
166
// for MSVC I think for this reason.
167
    vector<facet*> facets_;
168
#else
169
    vector<facet*, __sso_allocator<facet*, N> > facets_;
170
#endif
171
    string         name_;
172
public:
173
    explicit __imp(size_t refs = 0);
174
    explicit __imp(const string& name, size_t refs = 0);
175
    __imp(const __imp&);
176
    __imp(const __imp&, const string&, locale::category c);
177
    __imp(const __imp& other, const __imp& one, locale::category c);
178
    __imp(const __imp&, facet* f, long id);
179
    ~__imp();
180

181
    const string& name() const {return name_;}
182
    bool has_facet(long id) const
183
        {return static_cast<size_t>(id) < facets_.size() && facets_[static_cast<size_t>(id)];}
184
    const locale::facet* use_facet(long id) const;
185

186
    static const locale& make_classic();
187
    static       locale& make_global();
188
private:
189
    void install(facet* f, long id);
190
    template <class F> void install(F* f) {install(f, f->id.__get());}
191
    template <class F> void install_from(const __imp& other);
192
};
193

194
locale::__imp::__imp(size_t refs)
195
    : facet(refs),
196
      facets_(N),
197
      name_("C")
198
{
199
    facets_.clear();
200
    install(&make<_VSTD::collate<char> >(1u));
201
    install(&make<_VSTD::collate<wchar_t> >(1u));
202
    install(&make<_VSTD::ctype<char> >(nullptr, false, 1u));
203
    install(&make<_VSTD::ctype<wchar_t> >(1u));
204
    install(&make<codecvt<char, char, mbstate_t> >(1u));
205
    install(&make<codecvt<wchar_t, char, mbstate_t> >(1u));
206
    install(&make<codecvt<char16_t, char, mbstate_t> >(1u));
207
    install(&make<codecvt<char32_t, char, mbstate_t> >(1u));
208
    install(&make<numpunct<char> >(1u));
209
    install(&make<numpunct<wchar_t> >(1u));
210
    install(&make<num_get<char> >(1u));
211
    install(&make<num_get<wchar_t> >(1u));
212
    install(&make<num_put<char> >(1u));
213
    install(&make<num_put<wchar_t> >(1u));
214
    install(&make<moneypunct<char, false> >(1u));
215
    install(&make<moneypunct<char, true> >(1u));
216
    install(&make<moneypunct<wchar_t, false> >(1u));
217
    install(&make<moneypunct<wchar_t, true> >(1u));
218
    install(&make<money_get<char> >(1u));
219
    install(&make<money_get<wchar_t> >(1u));
220
    install(&make<money_put<char> >(1u));
221
    install(&make<money_put<wchar_t> >(1u));
222
    install(&make<time_get<char> >(1u));
223
    install(&make<time_get<wchar_t> >(1u));
224
    install(&make<time_put<char> >(1u));
225
    install(&make<time_put<wchar_t> >(1u));
226
    install(&make<_VSTD::messages<char> >(1u));
227
    install(&make<_VSTD::messages<wchar_t> >(1u));
228
}
229

230
locale::__imp::__imp(const string& name, size_t refs)
231
    : facet(refs),
232
      facets_(N),
233
      name_(name)
234
{
235
#ifndef _LIBCPP_NO_EXCEPTIONS
236
    try
237
    {
238
#endif  // _LIBCPP_NO_EXCEPTIONS
239
        facets_ = locale::classic().__locale_->facets_;
240
        for (unsigned i = 0; i < facets_.size(); ++i)
241
            if (facets_[i])
242
                facets_[i]->__add_shared();
243
        install(new collate_byname<char>(name_));
244
        install(new collate_byname<wchar_t>(name_));
245
        install(new ctype_byname<char>(name_));
246
        install(new ctype_byname<wchar_t>(name_));
247
        install(new codecvt_byname<char, char, mbstate_t>(name_));
248
        install(new codecvt_byname<wchar_t, char, mbstate_t>(name_));
249
        install(new codecvt_byname<char16_t, char, mbstate_t>(name_));
250
        install(new codecvt_byname<char32_t, char, mbstate_t>(name_));
251
        install(new numpunct_byname<char>(name_));
252
        install(new numpunct_byname<wchar_t>(name_));
253
        install(new moneypunct_byname<char, false>(name_));
254
        install(new moneypunct_byname<char, true>(name_));
255
        install(new moneypunct_byname<wchar_t, false>(name_));
256
        install(new moneypunct_byname<wchar_t, true>(name_));
257
        install(new time_get_byname<char>(name_));
258
        install(new time_get_byname<wchar_t>(name_));
259
        install(new time_put_byname<char>(name_));
260
        install(new time_put_byname<wchar_t>(name_));
261
        install(new messages_byname<char>(name_));
262
        install(new messages_byname<wchar_t>(name_));
263
#ifndef _LIBCPP_NO_EXCEPTIONS
264
    }
265
    catch (...)
266
    {
267
        for (unsigned i = 0; i < facets_.size(); ++i)
268
            if (facets_[i])
269
                facets_[i]->__release_shared();
270
        throw;
271
    }
272
#endif  // _LIBCPP_NO_EXCEPTIONS
273
}
274

275
// NOTE avoid the `base class should be explicitly initialized in the
276
// copy constructor` warning emitted by GCC
277
#if defined(__clang__) || _GNUC_VER >= 406
278
#pragma GCC diagnostic push
279
#pragma GCC diagnostic ignored "-Wextra"
280
#endif
281

282
locale::__imp::__imp(const __imp& other)
283
    : facets_(max<size_t>(N, other.facets_.size())),
284
      name_(other.name_)
285
{
286
    facets_ = other.facets_;
287
    for (unsigned i = 0; i < facets_.size(); ++i)
288
        if (facets_[i])
289
            facets_[i]->__add_shared();
290
}
291

292
#if defined(__clang__) || _GNUC_VER >= 406
293
#pragma GCC diagnostic pop
294
#endif
295

296
locale::__imp::__imp(const __imp& other, const string& name, locale::category c)
297
    : facets_(N),
298
      name_("*")
299
{
300
    facets_ = other.facets_;
301
    for (unsigned i = 0; i < facets_.size(); ++i)
302
        if (facets_[i])
303
            facets_[i]->__add_shared();
304
#ifndef _LIBCPP_NO_EXCEPTIONS
305
    try
306
    {
307
#endif  // _LIBCPP_NO_EXCEPTIONS
308
        if (c & locale::collate)
309
        {
310
            install(new collate_byname<char>(name));
311
            install(new collate_byname<wchar_t>(name));
312
        }
313
        if (c & locale::ctype)
314
        {
315
            install(new ctype_byname<char>(name));
316
            install(new ctype_byname<wchar_t>(name));
317
            install(new codecvt_byname<char, char, mbstate_t>(name));
318
            install(new codecvt_byname<wchar_t, char, mbstate_t>(name));
319
            install(new codecvt_byname<char16_t, char, mbstate_t>(name));
320
            install(new codecvt_byname<char32_t, char, mbstate_t>(name));
321
        }
322
        if (c & locale::monetary)
323
        {
324
            install(new moneypunct_byname<char, false>(name));
325
            install(new moneypunct_byname<char, true>(name));
326
            install(new moneypunct_byname<wchar_t, false>(name));
327
            install(new moneypunct_byname<wchar_t, true>(name));
328
        }
329
        if (c & locale::numeric)
330
        {
331
            install(new numpunct_byname<char>(name));
332
            install(new numpunct_byname<wchar_t>(name));
333
        }
334
        if (c & locale::time)
335
        {
336
            install(new time_get_byname<char>(name));
337
            install(new time_get_byname<wchar_t>(name));
338
            install(new time_put_byname<char>(name));
339
            install(new time_put_byname<wchar_t>(name));
340
        }
341
        if (c & locale::messages)
342
        {
343
            install(new messages_byname<char>(name));
344
            install(new messages_byname<wchar_t>(name));
345
        }
346
#ifndef _LIBCPP_NO_EXCEPTIONS
347
    }
348
    catch (...)
349
    {
350
        for (unsigned i = 0; i < facets_.size(); ++i)
351
            if (facets_[i])
352
                facets_[i]->__release_shared();
353
        throw;
354
    }
355
#endif  // _LIBCPP_NO_EXCEPTIONS
356
}
357

358
template<class F>
359
inline
360
void
361
locale::__imp::install_from(const locale::__imp& one)
362
{
363
    long id = F::id.__get();
364
    install(const_cast<F*>(static_cast<const F*>(one.use_facet(id))), id);
365
}
366

367
locale::__imp::__imp(const __imp& other, const __imp& one, locale::category c)
368
    : facets_(N),
369
      name_("*")
370
{
371
    facets_ = other.facets_;
372
    for (unsigned i = 0; i < facets_.size(); ++i)
373
        if (facets_[i])
374
            facets_[i]->__add_shared();
375
#ifndef _LIBCPP_NO_EXCEPTIONS
376
    try
377
    {
378
#endif  // _LIBCPP_NO_EXCEPTIONS
379
        if (c & locale::collate)
380
        {
381
            install_from<_VSTD::collate<char> >(one);
382
            install_from<_VSTD::collate<wchar_t> >(one);
383
        }
384
        if (c & locale::ctype)
385
        {
386
            install_from<_VSTD::ctype<char> >(one);
387
            install_from<_VSTD::ctype<wchar_t> >(one);
388
            install_from<_VSTD::codecvt<char, char, mbstate_t> >(one);
389
            install_from<_VSTD::codecvt<char16_t, char, mbstate_t> >(one);
390
            install_from<_VSTD::codecvt<char32_t, char, mbstate_t> >(one);
391
            install_from<_VSTD::codecvt<wchar_t, char, mbstate_t> >(one);
392
        }
393
        if (c & locale::monetary)
394
        {
395
            install_from<moneypunct<char, false> >(one);
396
            install_from<moneypunct<char, true> >(one);
397
            install_from<moneypunct<wchar_t, false> >(one);
398
            install_from<moneypunct<wchar_t, true> >(one);
399
            install_from<money_get<char> >(one);
400
            install_from<money_get<wchar_t> >(one);
401
            install_from<money_put<char> >(one);
402
            install_from<money_put<wchar_t> >(one);
403
        }
404
        if (c & locale::numeric)
405
        {
406
            install_from<numpunct<char> >(one);
407
            install_from<numpunct<wchar_t> >(one);
408
            install_from<num_get<char> >(one);
409
            install_from<num_get<wchar_t> >(one);
410
            install_from<num_put<char> >(one);
411
            install_from<num_put<wchar_t> >(one);
412
        }
413
        if (c & locale::time)
414
        {
415
            install_from<time_get<char> >(one);
416
            install_from<time_get<wchar_t> >(one);
417
            install_from<time_put<char> >(one);
418
            install_from<time_put<wchar_t> >(one);
419
        }
420
        if (c & locale::messages)
421
        {
422
            install_from<_VSTD::messages<char> >(one);
423
            install_from<_VSTD::messages<wchar_t> >(one);
424
        }
425
#ifndef _LIBCPP_NO_EXCEPTIONS
426
    }
427
    catch (...)
428
    {
429
        for (unsigned i = 0; i < facets_.size(); ++i)
430
            if (facets_[i])
431
                facets_[i]->__release_shared();
432
        throw;
433
    }
434
#endif  // _LIBCPP_NO_EXCEPTIONS
435
}
436

437
locale::__imp::__imp(const __imp& other, facet* f, long id)
438
    : facets_(max<size_t>(N, other.facets_.size()+1)),
439
      name_("*")
440
{
441
    f->__add_shared();
442
    unique_ptr<facet, release> hold(f);
443
    facets_ = other.facets_;
444
    for (unsigned i = 0; i < other.facets_.size(); ++i)
445
        if (facets_[i])
446
            facets_[i]->__add_shared();
447
    install(hold.get(), id);
448
}
449

450
locale::__imp::~__imp()
451
{
452
    for (unsigned i = 0; i < facets_.size(); ++i)
453
        if (facets_[i])
454
            facets_[i]->__release_shared();
455
}
456

457
void
458
locale::__imp::install(facet* f, long id)
459
{
460
    f->__add_shared();
461
    unique_ptr<facet, release> hold(f);
462
    if (static_cast<size_t>(id) >= facets_.size())
463
        facets_.resize(static_cast<size_t>(id+1));
464
    if (facets_[static_cast<size_t>(id)])
465
        facets_[static_cast<size_t>(id)]->__release_shared();
466
    facets_[static_cast<size_t>(id)] = hold.release();
467
}
468

469
const locale::facet*
470
locale::__imp::use_facet(long id) const
471
{
472
#ifndef _LIBCPP_NO_EXCEPTIONS
473
    if (!has_facet(id))
474
        throw bad_cast();
475
#endif  // _LIBCPP_NO_EXCEPTIONS
476
    return facets_[static_cast<size_t>(id)];
477
}
478

479
// locale
480

481
const locale&
482
locale::__imp::make_classic()
483
{
484
    // only one thread can get in here and it only gets in once
485
    static aligned_storage<sizeof(locale)>::type buf;
486
    locale* c = reinterpret_cast<locale*>(&buf);
487
    c->__locale_ = &make<__imp>(1u);
488
    return *c;
489
}
490

491
const locale&
492
locale::classic()
493
{
494
    static const locale& c = __imp::make_classic();
495
    return c;
496
}
497

498
locale&
499
locale::__imp::make_global()
500
{
501
    // only one thread can get in here and it only gets in once
502
    static aligned_storage<sizeof(locale)>::type buf;
503
    auto *obj = ::new (&buf) locale(locale::classic());
504
    return *obj;
505
}
506

507
locale&
508
locale::__global()
509
{
510
    static locale& g = __imp::make_global();
511
    return g;
512
}
513

514
locale::locale()  _NOEXCEPT
515
    : __locale_(__global().__locale_)
516
{
517
    __locale_->__add_shared();
518
}
519

520
locale::locale(const locale& l)  _NOEXCEPT
521
    : __locale_(l.__locale_)
522
{
523
    __locale_->__add_shared();
524
}
525

526
locale::~locale()
527
{
528
    __locale_->__release_shared();
529
}
530

531
const locale&
532
locale::operator=(const locale& other)  _NOEXCEPT
533
{
534
    other.__locale_->__add_shared();
535
    __locale_->__release_shared();
536
    __locale_ = other.__locale_;
537
    return *this;
538
}
539

540
locale::locale(const char* name)
541
#ifndef _LIBCPP_NO_EXCEPTIONS
542
    : __locale_(name ? new __imp(name)
543
                     : throw runtime_error("locale constructed with null"))
544
#else  // _LIBCPP_NO_EXCEPTIONS
545
    : __locale_(new __imp(name))
546
#endif
547
{
548
    __locale_->__add_shared();
549
}
550

551
locale::locale(const string& name)
552
    : __locale_(new __imp(name))
553
{
554
    __locale_->__add_shared();
555
}
556

557
locale::locale(const locale& other, const char* name, category c)
558
#ifndef _LIBCPP_NO_EXCEPTIONS
559
    : __locale_(name ? new __imp(*other.__locale_, name, c)
560
                     : throw runtime_error("locale constructed with null"))
561
#else  // _LIBCPP_NO_EXCEPTIONS
562
    : __locale_(new __imp(*other.__locale_, name, c))
563
#endif
564
{
565
    __locale_->__add_shared();
566
}
567

568
locale::locale(const locale& other, const string& name, category c)
569
    : __locale_(new __imp(*other.__locale_, name, c))
570
{
571
    __locale_->__add_shared();
572
}
573

574
locale::locale(const locale& other, const locale& one, category c)
575
    : __locale_(new __imp(*other.__locale_, *one.__locale_, c))
576
{
577
    __locale_->__add_shared();
578
}
579

580
string
581
locale::name() const
582
{
583
    return __locale_->name();
584
}
585

586
void
587
locale::__install_ctor(const locale& other, facet* f, long id)
588
{
589
    if (f)
590
        __locale_ = new __imp(*other.__locale_, f, id);
591
    else
592
        __locale_ = other.__locale_;
593
    __locale_->__add_shared();
594
}
595

596
locale
597
locale::global(const locale& loc)
598
{
599
    locale& g = __global();
600
    locale r = g;
601
    g = loc;
602
    if (g.name() != "*")
603
        setlocale(LC_ALL, g.name().c_str());
604
    return r;
605
}
606

607
bool
608
locale::has_facet(id& x) const
609
{
610
    return __locale_->has_facet(x.__get());
611
}
612

613
const locale::facet*
614
locale::use_facet(id& x) const
615
{
616
    return __locale_->use_facet(x.__get());
617
}
618

619
bool
620
locale::operator==(const locale& y) const
621
{
622
    return (__locale_ == y.__locale_)
623
        || (__locale_->name() != "*" && __locale_->name() == y.__locale_->name());
624
}
625

626
// locale::facet
627

628
locale::facet::~facet()
629
{
630
}
631

632
void
633
locale::facet::__on_zero_shared() _NOEXCEPT
634
{
635
    delete this;
636
}
637

638
// locale::id
639

640
int32_t locale::id::__next_id = 0;
641

642
namespace
643
{
644

645
class __fake_bind
646
{
647
    locale::id* id_;
648
    void (locale::id::* pmf_)();
649
public:
650
    __fake_bind(void (locale::id::* pmf)(), locale::id* id)
651
        : id_(id), pmf_(pmf) {}
652

653
    void operator()() const
654
    {
655
        (id_->*pmf_)();
656
    }
657
};
658

659
}
660

661
long
662
locale::id::__get()
663
{
664
    call_once(__flag_, __fake_bind(&locale::id::__init, this));
665
    return __id_ - 1;
666
}
667

668
void
669
locale::id::__init()
670
{
671
    __id_ = __libcpp_atomic_add(&__next_id, 1);
672
}
673

674
// template <> class collate_byname<char>
675

676
collate_byname<char>::collate_byname(const char* n, size_t refs)
677
    : collate<char>(refs),
678
      __l(newlocale(LC_ALL_MASK, n, 0))
679
{
680
    if (__l == 0)
681
        __throw_runtime_error("collate_byname<char>::collate_byname"
682
                            " failed to construct for " + string(n));
683
}
684

685
collate_byname<char>::collate_byname(const string& name, size_t refs)
686
    : collate<char>(refs),
687
      __l(newlocale(LC_ALL_MASK, name.c_str(), 0))
688
{
689
    if (__l == 0)
690
        __throw_runtime_error("collate_byname<char>::collate_byname"
691
                            " failed to construct for " + name);
692
}
693

694
collate_byname<char>::~collate_byname()
695
{
696
    freelocale(__l);
697
}
698

699
int
700
collate_byname<char>::do_compare(const char_type* __lo1, const char_type* __hi1,
701
                                 const char_type* __lo2, const char_type* __hi2) const
702
{
703
    string_type lhs(__lo1, __hi1);
704
    string_type rhs(__lo2, __hi2);
705
    int r = strcoll_l(lhs.c_str(), rhs.c_str(), __l);
706
    if (r < 0)
707
        return -1;
708
    if (r > 0)
709
        return 1;
710
    return r;
711
}
712

713
collate_byname<char>::string_type
714
collate_byname<char>::do_transform(const char_type* lo, const char_type* hi) const
715
{
716
    const string_type in(lo, hi);
717
    string_type out(strxfrm_l(0, in.c_str(), 0, __l), char());
718
    strxfrm_l(const_cast<char*>(out.c_str()), in.c_str(), out.size()+1, __l);
719
    return out;
720
}
721

722
// template <> class collate_byname<wchar_t>
723

724
collate_byname<wchar_t>::collate_byname(const char* n, size_t refs)
725
    : collate<wchar_t>(refs),
726
      __l(newlocale(LC_ALL_MASK, n, 0))
727
{
728
    if (__l == 0)
729
        __throw_runtime_error("collate_byname<wchar_t>::collate_byname(size_t refs)"
730
                            " failed to construct for " + string(n));
731
}
732

733
collate_byname<wchar_t>::collate_byname(const string& name, size_t refs)
734
    : collate<wchar_t>(refs),
735
      __l(newlocale(LC_ALL_MASK, name.c_str(), 0))
736
{
737
    if (__l == 0)
738
        __throw_runtime_error("collate_byname<wchar_t>::collate_byname(size_t refs)"
739
                            " failed to construct for " + name);
740
}
741

742
collate_byname<wchar_t>::~collate_byname()
743
{
744
    freelocale(__l);
745
}
746

747
int
748
collate_byname<wchar_t>::do_compare(const char_type* __lo1, const char_type* __hi1,
749
                                 const char_type* __lo2, const char_type* __hi2) const
750
{
751
    string_type lhs(__lo1, __hi1);
752
    string_type rhs(__lo2, __hi2);
753
    int r = wcscoll_l(lhs.c_str(), rhs.c_str(), __l);
754
    if (r < 0)
755
        return -1;
756
    if (r > 0)
757
        return 1;
758
    return r;
759
}
760

761
collate_byname<wchar_t>::string_type
762
collate_byname<wchar_t>::do_transform(const char_type* lo, const char_type* hi) const
763
{
764
    const string_type in(lo, hi);
765
    string_type out(wcsxfrm_l(0, in.c_str(), 0, __l), wchar_t());
766
    wcsxfrm_l(const_cast<wchar_t*>(out.c_str()), in.c_str(), out.size()+1, __l);
767
    return out;
768
}
769

770
// template <> class ctype<wchar_t>;
771

772
const ctype_base::mask ctype_base::space;
773
const ctype_base::mask ctype_base::print;
774
const ctype_base::mask ctype_base::cntrl;
775
const ctype_base::mask ctype_base::upper;
776
const ctype_base::mask ctype_base::lower;
777
const ctype_base::mask ctype_base::alpha;
778
const ctype_base::mask ctype_base::digit;
779
const ctype_base::mask ctype_base::punct;
780
const ctype_base::mask ctype_base::xdigit;
781
const ctype_base::mask ctype_base::blank;
782
const ctype_base::mask ctype_base::alnum;
783
const ctype_base::mask ctype_base::graph;
784

785
locale::id ctype<wchar_t>::id;
786

787
ctype<wchar_t>::~ctype()
788
{
789
}
790

791
bool
792
ctype<wchar_t>::do_is(mask m, char_type c) const
793
{
794
    return isascii(c) ? (ctype<char>::classic_table()[c] & m) != 0 : false;
795
}
796

797
const wchar_t*
798
ctype<wchar_t>::do_is(const char_type* low, const char_type* high, mask* vec) const
799
{
800
    for (; low != high; ++low, ++vec)
801
        *vec = static_cast<mask>(isascii(*low) ?
802
                                   ctype<char>::classic_table()[*low] : 0);
803
    return low;
804
}
805

806
const wchar_t*
807
ctype<wchar_t>::do_scan_is(mask m, const char_type* low, const char_type* high) const
808
{
809
    for (; low != high; ++low)
810
        if (isascii(*low) && (ctype<char>::classic_table()[*low] & m))
811
            break;
812
    return low;
813
}
814

815
const wchar_t*
816
ctype<wchar_t>::do_scan_not(mask m, const char_type* low, const char_type* high) const
817
{
818
    for (; low != high; ++low)
819
        if (!(isascii(*low) && (ctype<char>::classic_table()[*low] & m)))
820
            break;
821
    return low;
822
}
823

824
wchar_t
825
ctype<wchar_t>::do_toupper(char_type c) const
826
{
827
#ifdef _LIBCPP_HAS_DEFAULTRUNELOCALE
828
    return isascii(c) ? _DefaultRuneLocale.__mapupper[c] : c;
829
#elif defined(__GLIBC__) || defined(__EMSCRIPTEN__) || \
830
      defined(__NetBSD__)
831
    return isascii(c) ? ctype<char>::__classic_upper_table()[c] : c;
832
#else
833
    return (isascii(c) && iswlower_l(c, _LIBCPP_GET_C_LOCALE)) ? c-L'a'+L'A' : c;
834
#endif
835
}
836

837
const wchar_t*
838
ctype<wchar_t>::do_toupper(char_type* low, const char_type* high) const
839
{
840
    for (; low != high; ++low)
841
#ifdef _LIBCPP_HAS_DEFAULTRUNELOCALE
842
        *low = isascii(*low) ? _DefaultRuneLocale.__mapupper[*low] : *low;
843
#elif defined(__GLIBC__) || defined(__EMSCRIPTEN__) || \
844
      defined(__NetBSD__)
845
        *low = isascii(*low) ? ctype<char>::__classic_upper_table()[*low]
846
                             : *low;
847
#else
848
        *low = (isascii(*low) && islower_l(*low, _LIBCPP_GET_C_LOCALE)) ? (*low-L'a'+L'A') : *low;
849
#endif
850
    return low;
851
}
852

853
wchar_t
854
ctype<wchar_t>::do_tolower(char_type c) const
855
{
856
#ifdef _LIBCPP_HAS_DEFAULTRUNELOCALE
857
    return isascii(c) ? _DefaultRuneLocale.__maplower[c] : c;
858
#elif defined(__GLIBC__) || defined(__EMSCRIPTEN__) || \
859
      defined(__NetBSD__)
860
    return isascii(c) ? ctype<char>::__classic_lower_table()[c] : c;
861
#else
862
    return (isascii(c) && isupper_l(c, _LIBCPP_GET_C_LOCALE)) ? c-L'A'+'a' : c;
863
#endif
864
}
865

866
const wchar_t*
867
ctype<wchar_t>::do_tolower(char_type* low, const char_type* high) const
868
{
869
    for (; low != high; ++low)
870
#ifdef _LIBCPP_HAS_DEFAULTRUNELOCALE
871
        *low = isascii(*low) ? _DefaultRuneLocale.__maplower[*low] : *low;
872
#elif defined(__GLIBC__) || defined(__EMSCRIPTEN__) || \
873
      defined(__NetBSD__)
874
        *low = isascii(*low) ? ctype<char>::__classic_lower_table()[*low]
875
                             : *low;
876
#else
877
        *low = (isascii(*low) && isupper_l(*low, _LIBCPP_GET_C_LOCALE)) ? *low-L'A'+L'a' : *low;
878
#endif
879
    return low;
880
}
881

882
wchar_t
883
ctype<wchar_t>::do_widen(char c) const
884
{
885
    return c;
886
}
887

888
const char*
889
ctype<wchar_t>::do_widen(const char* low, const char* high, char_type* dest) const
890
{
891
    for (; low != high; ++low, ++dest)
892
        *dest = *low;
893
    return low;
894
}
895

896
char
897
ctype<wchar_t>::do_narrow(char_type c, char dfault) const
898
{
899
    if (isascii(c))
900
        return static_cast<char>(c);
901
    return dfault;
902
}
903

904
const wchar_t*
905
ctype<wchar_t>::do_narrow(const char_type* low, const char_type* high, char dfault, char* dest) const
906
{
907
    for (; low != high; ++low, ++dest)
908
        if (isascii(*low))
909
            *dest = static_cast<char>(*low);
910
        else
911
            *dest = dfault;
912
    return low;
913
}
914

915
// template <> class ctype<char>;
916

917
locale::id ctype<char>::id;
918

919
ctype<char>::ctype(const mask* tab, bool del, size_t refs)
920
    : locale::facet(refs),
921
      __tab_(tab),
922
      __del_(del)
923
{
924
  if (__tab_ == 0)
925
      __tab_ = classic_table();
926
}
927

928
ctype<char>::~ctype()
929
{
930
    if (__tab_ && __del_)
931
        delete [] __tab_;
932
}
933

934
char
935
ctype<char>::do_toupper(char_type c) const
936
{
937
#ifdef _LIBCPP_HAS_DEFAULTRUNELOCALE
938
    return isascii(c) ?
939
      static_cast<char>(_DefaultRuneLocale.__mapupper[static_cast<ptrdiff_t>(c)]) : c;
940
#elif defined(__NetBSD__)
941
    return static_cast<char>(__classic_upper_table()[static_cast<unsigned char>(c)]);
942
#elif defined(__GLIBC__) || defined(__EMSCRIPTEN__)
943
    return isascii(c) ?
944
      static_cast<char>(__classic_upper_table()[static_cast<unsigned char>(c)]) : c;
945
#else
946
    return (isascii(c) && islower_l(c, _LIBCPP_GET_C_LOCALE)) ? c-'a'+'A' : c;
947
#endif
948
}
949

950
const char*
951
ctype<char>::do_toupper(char_type* low, const char_type* high) const
952
{
953
    for (; low != high; ++low)
954
#ifdef _LIBCPP_HAS_DEFAULTRUNELOCALE
955
        *low = isascii(*low) ?
956
          static_cast<char>(_DefaultRuneLocale.__mapupper[static_cast<ptrdiff_t>(*low)]) : *low;
957
#elif defined(__NetBSD__)
958
        *low = static_cast<char>(__classic_upper_table()[static_cast<unsigned char>(*low)]);
959
#elif defined(__GLIBC__) || defined(__EMSCRIPTEN__)
960
        *low = isascii(*low) ?
961
          static_cast<char>(__classic_upper_table()[static_cast<size_t>(*low)]) : *low;
962
#else
963
        *low = (isascii(*low) && islower_l(*low, _LIBCPP_GET_C_LOCALE)) ? *low-'a'+'A' : *low;
964
#endif
965
    return low;
966
}
967

968
char
969
ctype<char>::do_tolower(char_type c) const
970
{
971
#ifdef _LIBCPP_HAS_DEFAULTRUNELOCALE
972
    return isascii(c) ?
973
      static_cast<char>(_DefaultRuneLocale.__maplower[static_cast<ptrdiff_t>(c)]) : c;
974
#elif defined(__NetBSD__)
975
    return static_cast<char>(__classic_lower_table()[static_cast<unsigned char>(c)]);
976
#elif defined(__GLIBC__) || defined(__EMSCRIPTEN__)
977
    return isascii(c) ?
978
      static_cast<char>(__classic_lower_table()[static_cast<size_t>(c)]) : c;
979
#else
980
    return (isascii(c) && isupper_l(c, _LIBCPP_GET_C_LOCALE)) ? c-'A'+'a' : c;
981
#endif
982
}
983

984
const char*
985
ctype<char>::do_tolower(char_type* low, const char_type* high) const
986
{
987
    for (; low != high; ++low)
988
#ifdef _LIBCPP_HAS_DEFAULTRUNELOCALE
989
        *low = isascii(*low) ? static_cast<char>(_DefaultRuneLocale.__maplower[static_cast<ptrdiff_t>(*low)]) : *low;
990
#elif defined(__NetBSD__)
991
        *low = static_cast<char>(__classic_lower_table()[static_cast<unsigned char>(*low)]);
992
#elif defined(__GLIBC__) || defined(__EMSCRIPTEN__)
993
        *low = isascii(*low) ? static_cast<char>(__classic_lower_table()[static_cast<size_t>(*low)]) : *low;
994
#else
995
        *low = (isascii(*low) && isupper_l(*low, _LIBCPP_GET_C_LOCALE)) ? *low-'A'+'a' : *low;
996
#endif
997
    return low;
998
}
999

1000
char
1001
ctype<char>::do_widen(char c) const
1002
{
1003
    return c;
1004
}
1005

1006
const char*
1007
ctype<char>::do_widen(const char* low, const char* high, char_type* dest) const
1008
{
1009
    for (; low != high; ++low, ++dest)
1010
        *dest = *low;
1011
    return low;
1012
}
1013

1014
char
1015
ctype<char>::do_narrow(char_type c, char dfault) const
1016
{
1017
    if (isascii(c))
1018
        return static_cast<char>(c);
1019
    return dfault;
1020
}
1021

1022
const char*
1023
ctype<char>::do_narrow(const char_type* low, const char_type* high, char dfault, char* dest) const
1024
{
1025
    for (; low != high; ++low, ++dest)
1026
        if (isascii(*low))
1027
            *dest = *low;
1028
        else
1029
            *dest = dfault;
1030
    return low;
1031
}
1032

1033
#if defined(__EMSCRIPTEN__)
1034
extern "C" const unsigned short ** __ctype_b_loc();
1035
extern "C" const int ** __ctype_tolower_loc();
1036
extern "C" const int ** __ctype_toupper_loc();
1037
#endif
1038

1039
#ifdef _LIBCPP_PROVIDES_DEFAULT_RUNE_TABLE
1040
const ctype<char>::mask*
1041
ctype<char>::classic_table()  _NOEXCEPT
1042
{
1043
    static _LIBCPP_CONSTEXPR const ctype<char>::mask builtin_table[table_size] = {
1044
        cntrl,                          cntrl,
1045
        cntrl,                          cntrl,
1046
        cntrl,                          cntrl,
1047
        cntrl,                          cntrl,
1048
        cntrl,                          cntrl | space | blank,
1049
        cntrl | space,                  cntrl | space,
1050
        cntrl | space,                  cntrl | space,
1051
        cntrl,                          cntrl,
1052
        cntrl,                          cntrl,
1053
        cntrl,                          cntrl,
1054
        cntrl,                          cntrl,
1055
        cntrl,                          cntrl,
1056
        cntrl,                          cntrl,
1057
        cntrl,                          cntrl,
1058
        cntrl,                          cntrl,
1059
        cntrl,                          cntrl,
1060
        space | blank | print,          punct | print,
1061
        punct | print,                  punct | print,
1062
        punct | print,                  punct | print,
1063
        punct | print,                  punct | print,
1064
        punct | print,                  punct | print,
1065
        punct | print,                  punct | print,
1066
        punct | print,                  punct | print,
1067
        punct | print,                  punct | print,
1068
        digit | print | xdigit,         digit | print | xdigit,
1069
        digit | print | xdigit,         digit | print | xdigit,
1070
        digit | print | xdigit,         digit | print | xdigit,
1071
        digit | print | xdigit,         digit | print | xdigit,
1072
        digit | print | xdigit,         digit | print | xdigit,
1073
        punct | print,                  punct | print,
1074
        punct | print,                  punct | print,
1075
        punct | print,                  punct | print,
1076
        punct | print,                  upper | xdigit | print | alpha,
1077
        upper | xdigit | print | alpha, upper | xdigit | print | alpha,
1078
        upper | xdigit | print | alpha, upper | xdigit | print | alpha,
1079
        upper | xdigit | print | alpha, upper | print | alpha,
1080
        upper | print | alpha,          upper | print | alpha,
1081
        upper | print | alpha,          upper | print | alpha,
1082
        upper | print | alpha,          upper | print | alpha,
1083
        upper | print | alpha,          upper | print | alpha,
1084
        upper | print | alpha,          upper | print | alpha,
1085
        upper | print | alpha,          upper | print | alpha,
1086
        upper | print | alpha,          upper | print | alpha,
1087
        upper | print | alpha,          upper | print | alpha,
1088
        upper | print | alpha,          upper | print | alpha,
1089
        upper | print | alpha,          punct | print,
1090
        punct | print,                  punct | print,
1091
        punct | print,                  punct | print,
1092
        punct | print,                  lower | xdigit | print | alpha,
1093
        lower | xdigit | print | alpha, lower | xdigit | print | alpha,
1094
        lower | xdigit | print | alpha, lower | xdigit | print | alpha,
1095
        lower | xdigit | print | alpha, lower | print | alpha,
1096
        lower | print | alpha,          lower | print | alpha,
1097
        lower | print | alpha,          lower | print | alpha,
1098
        lower | print | alpha,          lower | print | alpha,
1099
        lower | print | alpha,          lower | print | alpha,
1100
        lower | print | alpha,          lower | print | alpha,
1101
        lower | print | alpha,          lower | print | alpha,
1102
        lower | print | alpha,          lower | print | alpha,
1103
        lower | print | alpha,          lower | print | alpha,
1104
        lower | print | alpha,          lower | print | alpha,
1105
        lower | print | alpha,          punct | print,
1106
        punct | print,                  punct | print,
1107
        punct | print,                  cntrl,
1108
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1109
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1110
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1111
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1112
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1113
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1114
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1115
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
1116
    };
1117
    return builtin_table;
1118
}
1119
#else
1120
const ctype<char>::mask*
1121
ctype<char>::classic_table()  _NOEXCEPT
1122
{
1123
#if defined(__APPLE__) || defined(__FreeBSD__)
1124
    return _DefaultRuneLocale.__runetype;
1125
#elif defined(__NetBSD__)
1126
    return _C_ctype_tab_ + 1;
1127
#elif defined(__GLIBC__)
1128
    return _LIBCPP_GET_C_LOCALE->__ctype_b;
1129
#elif __sun__
1130
    return __ctype_mask;
1131
#elif defined(_LIBCPP_MSVCRT) || defined(__MINGW32__)
1132
    return __pctype_func();
1133
#elif defined(__EMSCRIPTEN__)
1134
    return *__ctype_b_loc();
1135
#elif defined(_NEWLIB_VERSION)
1136
    // Newlib has a 257-entry table in ctype_.c, where (char)0 starts at [1].
1137
    return _ctype_ + 1;
1138
#elif defined(_AIX)
1139
    return (const unsigned int *)__lc_ctype_ptr->obj->mask;
1140
#else
1141
    // Platform not supported: abort so the person doing the port knows what to
1142
    // fix
1143
# warning  ctype<char>::classic_table() is not implemented
1144
    printf("ctype<char>::classic_table() is not implemented\n");
1145
    abort();
1146
    return NULL;
1147
#endif
1148
}
1149
#endif
1150

1151
#if defined(__GLIBC__)
1152
const int*
1153
ctype<char>::__classic_lower_table() _NOEXCEPT
1154
{
1155
    return _LIBCPP_GET_C_LOCALE->__ctype_tolower;
1156
}
1157

1158
const int*
1159
ctype<char>::__classic_upper_table() _NOEXCEPT
1160
{
1161
    return _LIBCPP_GET_C_LOCALE->__ctype_toupper;
1162
}
1163
#elif __NetBSD__
1164
const short*
1165
ctype<char>::__classic_lower_table() _NOEXCEPT
1166
{
1167
    return _C_tolower_tab_ + 1;
1168
}
1169

1170
const short*
1171
ctype<char>::__classic_upper_table() _NOEXCEPT
1172
{
1173
    return _C_toupper_tab_ + 1;
1174
}
1175

1176
#elif defined(__EMSCRIPTEN__)
1177
const int*
1178
ctype<char>::__classic_lower_table() _NOEXCEPT
1179
{
1180
    return *__ctype_tolower_loc();
1181
}
1182

1183
const int*
1184
ctype<char>::__classic_upper_table() _NOEXCEPT
1185
{
1186
    return *__ctype_toupper_loc();
1187
}
1188
#endif // __GLIBC__ || __NETBSD__ || __EMSCRIPTEN__
1189

1190
// template <> class ctype_byname<char>
1191

1192
ctype_byname<char>::ctype_byname(const char* name, size_t refs)
1193
    : ctype<char>(0, false, refs),
1194
      __l(newlocale(LC_ALL_MASK, name, 0))
1195
{
1196
    if (__l == 0)
1197
        __throw_runtime_error("ctype_byname<char>::ctype_byname"
1198
                            " failed to construct for " + string(name));
1199
}
1200

1201
ctype_byname<char>::ctype_byname(const string& name, size_t refs)
1202
    : ctype<char>(0, false, refs),
1203
      __l(newlocale(LC_ALL_MASK, name.c_str(), 0))
1204
{
1205
    if (__l == 0)
1206
        __throw_runtime_error("ctype_byname<char>::ctype_byname"
1207
                            " failed to construct for " + name);
1208
}
1209

1210
ctype_byname<char>::~ctype_byname()
1211
{
1212
    freelocale(__l);
1213
}
1214

1215
char
1216
ctype_byname<char>::do_toupper(char_type c) const
1217
{
1218
    return static_cast<char>(toupper_l(static_cast<unsigned char>(c), __l));
1219
}
1220

1221
const char*
1222
ctype_byname<char>::do_toupper(char_type* low, const char_type* high) const
1223
{
1224
    for (; low != high; ++low)
1225
        *low = static_cast<char>(toupper_l(static_cast<unsigned char>(*low), __l));
1226
    return low;
1227
}
1228

1229
char
1230
ctype_byname<char>::do_tolower(char_type c) const
1231
{
1232
    return static_cast<char>(tolower_l(static_cast<unsigned char>(c), __l));
1233
}
1234

1235
const char*
1236
ctype_byname<char>::do_tolower(char_type* low, const char_type* high) const
1237
{
1238
    for (; low != high; ++low)
1239
        *low = static_cast<char>(tolower_l(static_cast<unsigned char>(*low), __l));
1240
    return low;
1241
}
1242

1243
// template <> class ctype_byname<wchar_t>
1244

1245
ctype_byname<wchar_t>::ctype_byname(const char* name, size_t refs)
1246
    : ctype<wchar_t>(refs),
1247
      __l(newlocale(LC_ALL_MASK, name, 0))
1248
{
1249
    if (__l == 0)
1250
        __throw_runtime_error("ctype_byname<wchar_t>::ctype_byname"
1251
                            " failed to construct for " + string(name));
1252
}
1253

1254
ctype_byname<wchar_t>::ctype_byname(const string& name, size_t refs)
1255
    : ctype<wchar_t>(refs),
1256
      __l(newlocale(LC_ALL_MASK, name.c_str(), 0))
1257
{
1258
    if (__l == 0)
1259
        __throw_runtime_error("ctype_byname<wchar_t>::ctype_byname"
1260
                            " failed to construct for " + name);
1261
}
1262

1263
ctype_byname<wchar_t>::~ctype_byname()
1264
{
1265
    freelocale(__l);
1266
}
1267

1268
bool
1269
ctype_byname<wchar_t>::do_is(mask m, char_type c) const
1270
{
1271
#ifdef _LIBCPP_WCTYPE_IS_MASK
1272
    return static_cast<bool>(iswctype_l(c, m, __l));
1273
#else
1274
    bool result = false;
1275
    wint_t ch = static_cast<wint_t>(c);
1276
    if ((m & space) == space) result |= (iswspace_l(ch, __l) != 0);
1277
    if ((m & print) == print) result |= (iswprint_l(ch, __l) != 0);
1278
    if ((m & cntrl) == cntrl) result |= (iswcntrl_l(ch, __l) != 0);
1279
    if ((m & upper) == upper) result |= (iswupper_l(ch, __l) != 0);
1280
    if ((m & lower) == lower) result |= (iswlower_l(ch, __l) != 0);
1281
    if ((m & alpha) == alpha) result |= (iswalpha_l(ch, __l) != 0);
1282
    if ((m & digit) == digit) result |= (iswdigit_l(ch, __l) != 0);
1283
    if ((m & punct) == punct) result |= (iswpunct_l(ch, __l) != 0);
1284
    if ((m & xdigit) == xdigit) result |= (iswxdigit_l(ch, __l) != 0);
1285
    if ((m & blank) == blank) result |= (iswblank_l(ch, __l) != 0);
1286
    return result;
1287
#endif
1288
}
1289

1290
const wchar_t*
1291
ctype_byname<wchar_t>::do_is(const char_type* low, const char_type* high, mask* vec) const
1292
{
1293
    for (; low != high; ++low, ++vec)
1294
    {
1295
        if (isascii(*low))
1296
            *vec = static_cast<mask>(ctype<char>::classic_table()[*low]);
1297
        else
1298
        {
1299
            *vec = 0;
1300
            wint_t ch = static_cast<wint_t>(*low);
1301
            if (iswspace_l(ch, __l))
1302
                *vec |= space;
1303
#ifndef _LIBCPP_CTYPE_MASK_IS_COMPOSITE_PRINT
1304
            if (iswprint_l(ch, __l))
1305
                *vec |= print;
1306
#endif
1307
            if (iswcntrl_l(ch, __l))
1308
                *vec |= cntrl;
1309
            if (iswupper_l(ch, __l))
1310
                *vec |= upper;
1311
            if (iswlower_l(ch, __l))
1312
                *vec |= lower;
1313
#ifndef _LIBCPP_CTYPE_MASK_IS_COMPOSITE_ALPHA
1314
            if (iswalpha_l(ch, __l))
1315
                *vec |= alpha;
1316
#endif
1317
            if (iswdigit_l(ch, __l))
1318
                *vec |= digit;
1319
            if (iswpunct_l(ch, __l))
1320
                *vec |= punct;
1321
#ifndef _LIBCPP_CTYPE_MASK_IS_COMPOSITE_XDIGIT
1322
            if (iswxdigit_l(ch, __l))
1323
                *vec |= xdigit;
1324
#endif
1325
#if !defined(__sun__)
1326
            if (iswblank_l(ch, __l))
1327
                *vec |= blank;
1328
#endif
1329
        }
1330
    }
1331
    return low;
1332
}
1333

1334
const wchar_t*
1335
ctype_byname<wchar_t>::do_scan_is(mask m, const char_type* low, const char_type* high) const
1336
{
1337
    for (; low != high; ++low)
1338
    {
1339
#ifdef _LIBCPP_WCTYPE_IS_MASK
1340
        if (iswctype_l(*low, m, __l))
1341
            break;
1342
#else
1343
        wint_t ch = static_cast<wint_t>(*low);
1344
        if ((m & space) == space && iswspace_l(ch, __l)) break;
1345
        if ((m & print) == print && iswprint_l(ch, __l)) break;
1346
        if ((m & cntrl) == cntrl && iswcntrl_l(ch, __l)) break;
1347
        if ((m & upper) == upper && iswupper_l(ch, __l)) break;
1348
        if ((m & lower) == lower && iswlower_l(ch, __l)) break;
1349
        if ((m & alpha) == alpha && iswalpha_l(ch, __l)) break;
1350
        if ((m & digit) == digit && iswdigit_l(ch, __l)) break;
1351
        if ((m & punct) == punct && iswpunct_l(ch, __l)) break;
1352
        if ((m & xdigit) == xdigit && iswxdigit_l(ch, __l)) break;
1353
        if ((m & blank) == blank && iswblank_l(ch, __l)) break;
1354
#endif
1355
    }
1356
    return low;
1357
}
1358

1359
const wchar_t*
1360
ctype_byname<wchar_t>::do_scan_not(mask m, const char_type* low, const char_type* high) const
1361
{
1362
    for (; low != high; ++low)
1363
    {
1364
#ifdef _LIBCPP_WCTYPE_IS_MASK
1365
        if (!iswctype_l(*low, m, __l))
1366
            break;
1367
#else
1368
        wint_t ch = static_cast<wint_t>(*low);
1369
        if ((m & space) == space && iswspace_l(ch, __l)) continue;
1370
        if ((m & print) == print && iswprint_l(ch, __l)) continue;
1371
        if ((m & cntrl) == cntrl && iswcntrl_l(ch, __l)) continue;
1372
        if ((m & upper) == upper && iswupper_l(ch, __l)) continue;
1373
        if ((m & lower) == lower && iswlower_l(ch, __l)) continue;
1374
        if ((m & alpha) == alpha && iswalpha_l(ch, __l)) continue;
1375
        if ((m & digit) == digit && iswdigit_l(ch, __l)) continue;
1376
        if ((m & punct) == punct && iswpunct_l(ch, __l)) continue;
1377
        if ((m & xdigit) == xdigit && iswxdigit_l(ch, __l)) continue;
1378
        if ((m & blank) == blank && iswblank_l(ch, __l)) continue;
1379
        break;
1380
#endif
1381
    }
1382
    return low;
1383
}
1384

1385
wchar_t
1386
ctype_byname<wchar_t>::do_toupper(char_type c) const
1387
{
1388
    return towupper_l(c, __l);
1389
}
1390

1391
const wchar_t*
1392
ctype_byname<wchar_t>::do_toupper(char_type* low, const char_type* high) const
1393
{
1394
    for (; low != high; ++low)
1395
        *low = towupper_l(*low, __l);
1396
    return low;
1397
}
1398

1399
wchar_t
1400
ctype_byname<wchar_t>::do_tolower(char_type c) const
1401
{
1402
    return towlower_l(c, __l);
1403
}
1404

1405
const wchar_t*
1406
ctype_byname<wchar_t>::do_tolower(char_type* low, const char_type* high) const
1407
{
1408
    for (; low != high; ++low)
1409
        *low = towlower_l(*low, __l);
1410
    return low;
1411
}
1412

1413
wchar_t
1414
ctype_byname<wchar_t>::do_widen(char c) const
1415
{
1416
    return __libcpp_btowc_l(c, __l);
1417
}
1418

1419
const char*
1420
ctype_byname<wchar_t>::do_widen(const char* low, const char* high, char_type* dest) const
1421
{
1422
    for (; low != high; ++low, ++dest)
1423
        *dest = __libcpp_btowc_l(*low, __l);
1424
    return low;
1425
}
1426

1427
char
1428
ctype_byname<wchar_t>::do_narrow(char_type c, char dfault) const
1429
{
1430
    int r = __libcpp_wctob_l(c, __l);
1431
    return r != static_cast<int>(WEOF) ? static_cast<char>(r) : dfault;
1432
}
1433

1434
const wchar_t*
1435
ctype_byname<wchar_t>::do_narrow(const char_type* low, const char_type* high, char dfault, char* dest) const
1436
{
1437
    for (; low != high; ++low, ++dest)
1438
    {
1439
        int r = __libcpp_wctob_l(*low, __l);
1440
        *dest = r != static_cast<int>(WEOF) ? static_cast<char>(r) : dfault;
1441
    }
1442
    return low;
1443
}
1444

1445
// template <> class codecvt<char, char, mbstate_t>
1446

1447
locale::id codecvt<char, char, mbstate_t>::id;
1448

1449
codecvt<char, char, mbstate_t>::~codecvt()
1450
{
1451
}
1452

1453
codecvt<char, char, mbstate_t>::result
1454
codecvt<char, char, mbstate_t>::do_out(state_type&,
1455
    const intern_type* frm, const intern_type*, const intern_type*& frm_nxt,
1456
    extern_type* to, extern_type*, extern_type*& to_nxt) const
1457
{
1458
    frm_nxt = frm;
1459
    to_nxt = to;
1460
    return noconv;
1461
}
1462

1463
codecvt<char, char, mbstate_t>::result
1464
codecvt<char, char, mbstate_t>::do_in(state_type&,
1465
    const extern_type* frm, const extern_type*, const extern_type*& frm_nxt,
1466
    intern_type* to, intern_type*, intern_type*& to_nxt) const
1467
{
1468
    frm_nxt = frm;
1469
    to_nxt = to;
1470
    return noconv;
1471
}
1472

1473
codecvt<char, char, mbstate_t>::result
1474
codecvt<char, char, mbstate_t>::do_unshift(state_type&,
1475
    extern_type* to, extern_type*, extern_type*& to_nxt) const
1476
{
1477
    to_nxt = to;
1478
    return noconv;
1479
}
1480

1481
int
1482
codecvt<char, char, mbstate_t>::do_encoding() const  _NOEXCEPT
1483
{
1484
    return 1;
1485
}
1486

1487
bool
1488
codecvt<char, char, mbstate_t>::do_always_noconv() const  _NOEXCEPT
1489
{
1490
    return true;
1491
}
1492

1493
int
1494
codecvt<char, char, mbstate_t>::do_length(state_type&,
1495
    const extern_type* frm, const extern_type* end, size_t mx) const
1496
{
1497
    return static_cast<int>(min<size_t>(mx, static_cast<size_t>(end-frm)));
1498
}
1499

1500
int
1501
codecvt<char, char, mbstate_t>::do_max_length() const  _NOEXCEPT
1502
{
1503
    return 1;
1504
}
1505

1506
// template <> class codecvt<wchar_t, char, mbstate_t>
1507

1508
locale::id codecvt<wchar_t, char, mbstate_t>::id;
1509

1510
codecvt<wchar_t, char, mbstate_t>::codecvt(size_t refs)
1511
    : locale::facet(refs),
1512
      __l(_LIBCPP_GET_C_LOCALE)
1513
{
1514
}
1515

1516
codecvt<wchar_t, char, mbstate_t>::codecvt(const char* nm, size_t refs)
1517
    : locale::facet(refs),
1518
      __l(newlocale(LC_ALL_MASK, nm, 0))
1519
{
1520
    if (__l == 0)
1521
        __throw_runtime_error("codecvt_byname<wchar_t, char, mbstate_t>::codecvt_byname"
1522
                            " failed to construct for " + string(nm));
1523
}
1524

1525
codecvt<wchar_t, char, mbstate_t>::~codecvt()
1526
{
1527
    if (__l != _LIBCPP_GET_C_LOCALE)
1528
        freelocale(__l);
1529
}
1530

1531
codecvt<wchar_t, char, mbstate_t>::result
1532
codecvt<wchar_t, char, mbstate_t>::do_out(state_type& st,
1533
    const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt,
1534
    extern_type* to, extern_type* to_end, extern_type*& to_nxt) const
1535
{
1536
    // look for first internal null in frm
1537
    const intern_type* fend = frm;
1538
    for (; fend != frm_end; ++fend)
1539
        if (*fend == 0)
1540
            break;
1541
    // loop over all null-terminated sequences in frm
1542
    to_nxt = to;
1543
    for (frm_nxt = frm; frm != frm_end && to != to_end; frm = frm_nxt, to = to_nxt)
1544
    {
1545
        // save state in case it is needed to recover to_nxt on error
1546
        mbstate_t save_state = st;
1547
        size_t n = __libcpp_wcsnrtombs_l(to, &frm_nxt, static_cast<size_t>(fend-frm),
1548
                                     static_cast<size_t>(to_end-to), &st, __l);
1549
        if (n == size_t(-1))
1550
        {
1551
            // need to recover to_nxt
1552
            for (to_nxt = to; frm != frm_nxt; ++frm)
1553
            {
1554
                n = __libcpp_wcrtomb_l(to_nxt, *frm, &save_state, __l);
1555
                if (n == size_t(-1))
1556
                    break;
1557
                to_nxt += n;
1558
            }
1559
            frm_nxt = frm;
1560
            return error;
1561
        }
1562
        if (n == 0)
1563
            return partial;
1564
        to_nxt += n;
1565
        if (to_nxt == to_end)
1566
            break;
1567
        if (fend != frm_end)  // set up next null terminated sequence
1568
        {
1569
            // Try to write the terminating null
1570
            extern_type tmp[MB_LEN_MAX];
1571
            n = __libcpp_wcrtomb_l(tmp, intern_type(), &st, __l);
1572
            if (n == size_t(-1))  // on error
1573
                return error;
1574
            if (n > static_cast<size_t>(to_end-to_nxt))  // is there room?
1575
                return partial;
1576
            for (extern_type* p = tmp; n; --n)  // write it
1577
                *to_nxt++ = *p++;
1578
            ++frm_nxt;
1579
            // look for next null in frm
1580
            for (fend = frm_nxt; fend != frm_end; ++fend)
1581
                if (*fend == 0)
1582
                    break;
1583
        }
1584
    }
1585
    return frm_nxt == frm_end ? ok : partial;
1586
}
1587

1588
codecvt<wchar_t, char, mbstate_t>::result
1589
codecvt<wchar_t, char, mbstate_t>::do_in(state_type& st,
1590
    const extern_type* frm, const extern_type* frm_end, const extern_type*& frm_nxt,
1591
    intern_type* to, intern_type* to_end, intern_type*& to_nxt) const
1592
{
1593
    // look for first internal null in frm
1594
    const extern_type* fend = frm;
1595
    for (; fend != frm_end; ++fend)
1596
        if (*fend == 0)
1597
            break;
1598
    // loop over all null-terminated sequences in frm
1599
    to_nxt = to;
1600
    for (frm_nxt = frm; frm != frm_end && to != to_end; frm = frm_nxt, to = to_nxt)
1601
    {
1602
        // save state in case it is needed to recover to_nxt on error
1603
        mbstate_t save_state = st;
1604
        size_t n = __libcpp_mbsnrtowcs_l(to, &frm_nxt, static_cast<size_t>(fend-frm),
1605
                                     static_cast<size_t>(to_end-to), &st, __l);
1606
        if (n == size_t(-1))
1607
        {
1608
            // need to recover to_nxt
1609
            for (to_nxt = to; frm != frm_nxt; ++to_nxt)
1610
            {
1611
                n = __libcpp_mbrtowc_l(to_nxt, frm, static_cast<size_t>(fend-frm),
1612
                                   &save_state, __l);
1613
                switch (n)
1614
                {
1615
                case 0:
1616
                    ++frm;
1617
                    break;
1618
                case size_t(-1):
1619
                    frm_nxt = frm;
1620
                    return error;
1621
                case size_t(-2):
1622
                    frm_nxt = frm;
1623
                    return partial;
1624
                default:
1625
                    frm += n;
1626
                    break;
1627
                }
1628
            }
1629
            frm_nxt = frm;
1630
            return frm_nxt == frm_end ? ok : partial;
1631
        }
1632
        if (n == size_t(-1))
1633
            return error;
1634
        to_nxt += n;
1635
        if (to_nxt == to_end)
1636
            break;
1637
        if (fend != frm_end)  // set up next null terminated sequence
1638
        {
1639
            // Try to write the terminating null
1640
            n = __libcpp_mbrtowc_l(to_nxt, frm_nxt, 1, &st, __l);
1641
            if (n != 0)  // on error
1642
                return error;
1643
            ++to_nxt;
1644
            ++frm_nxt;
1645
            // look for next null in frm
1646
            for (fend = frm_nxt; fend != frm_end; ++fend)
1647
                if (*fend == 0)
1648
                    break;
1649
        }
1650
    }
1651
    return frm_nxt == frm_end ? ok : partial;
1652
}
1653

1654
codecvt<wchar_t, char, mbstate_t>::result
1655
codecvt<wchar_t, char, mbstate_t>::do_unshift(state_type& st,
1656
    extern_type* to, extern_type* to_end, extern_type*& to_nxt) const
1657
{
1658
    to_nxt = to;
1659
    extern_type tmp[MB_LEN_MAX];
1660
    size_t n = __libcpp_wcrtomb_l(tmp, intern_type(), &st, __l);
1661
    if (n == size_t(-1) || n == 0)  // on error
1662
        return error;
1663
    --n;
1664
    if (n > static_cast<size_t>(to_end-to_nxt))  // is there room?
1665
        return partial;
1666
    for (extern_type* p = tmp; n; --n)  // write it
1667
        *to_nxt++ = *p++;
1668
    return ok;
1669
}
1670

1671
int
1672
codecvt<wchar_t, char, mbstate_t>::do_encoding() const  _NOEXCEPT
1673
{
1674
    if (__libcpp_mbtowc_l(nullptr, nullptr, MB_LEN_MAX, __l) != 0)
1675
        return -1;
1676

1677
    // stateless encoding
1678
    if (__l == 0 || __libcpp_mb_cur_max_l(__l) == 1)  // there are no known constant length encodings
1679
        return 1;                // which take more than 1 char to form a wchar_t
1680
    return 0;
1681
}
1682

1683
bool
1684
codecvt<wchar_t, char, mbstate_t>::do_always_noconv() const  _NOEXCEPT
1685
{
1686
    return false;
1687
}
1688

1689
int
1690
codecvt<wchar_t, char, mbstate_t>::do_length(state_type& st,
1691
    const extern_type* frm, const extern_type* frm_end, size_t mx) const
1692
{
1693
    int nbytes = 0;
1694
    for (size_t nwchar_t = 0; nwchar_t < mx && frm != frm_end; ++nwchar_t)
1695
    {
1696
        size_t n = __libcpp_mbrlen_l(frm, static_cast<size_t>(frm_end-frm), &st, __l);
1697
        switch (n)
1698
        {
1699
        case 0:
1700
            ++nbytes;
1701
            ++frm;
1702
            break;
1703
        case size_t(-1):
1704
        case size_t(-2):
1705
            return nbytes;
1706
        default:
1707
            nbytes += n;
1708
            frm += n;
1709
            break;
1710
        }
1711
    }
1712
    return nbytes;
1713
}
1714

1715
int
1716
codecvt<wchar_t, char, mbstate_t>::do_max_length() const  _NOEXCEPT
1717
{
1718
    return __l == 0 ? 1 : static_cast<int>(__libcpp_mb_cur_max_l(__l));
1719
}
1720

1721
//                                     Valid UTF ranges
1722
//     UTF-32               UTF-16                          UTF-8               # of code points
1723
//                     first      second       first   second    third   fourth
1724
// 000000 - 00007F  0000 - 007F               00 - 7F                                 127
1725
// 000080 - 0007FF  0080 - 07FF               C2 - DF, 80 - BF                       1920
1726
// 000800 - 000FFF  0800 - 0FFF               E0 - E0, A0 - BF, 80 - BF              2048
1727
// 001000 - 00CFFF  1000 - CFFF               E1 - EC, 80 - BF, 80 - BF             49152
1728
// 00D000 - 00D7FF  D000 - D7FF               ED - ED, 80 - 9F, 80 - BF              2048
1729
// 00D800 - 00DFFF                invalid
1730
// 00E000 - 00FFFF  E000 - FFFF               EE - EF, 80 - BF, 80 - BF              8192
1731
// 010000 - 03FFFF  D800 - D8BF, DC00 - DFFF  F0 - F0, 90 - BF, 80 - BF, 80 - BF   196608
1732
// 040000 - 0FFFFF  D8C0 - DBBF, DC00 - DFFF  F1 - F3, 80 - BF, 80 - BF, 80 - BF   786432
1733
// 100000 - 10FFFF  DBC0 - DBFF, DC00 - DFFF  F4 - F4, 80 - 8F, 80 - BF, 80 - BF    65536
1734

1735
static
1736
codecvt_base::result
1737
utf16_to_utf8(const uint16_t* frm, const uint16_t* frm_end, const uint16_t*& frm_nxt,
1738
              uint8_t* to, uint8_t* to_end, uint8_t*& to_nxt,
1739
              unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = codecvt_mode(0))
1740
{
1741
    frm_nxt = frm;
1742
    to_nxt = to;
1743
    if (mode & generate_header)
1744
    {
1745
        if (to_end-to_nxt < 3)
1746
            return codecvt_base::partial;
1747
        *to_nxt++ = static_cast<uint8_t>(0xEF);
1748
        *to_nxt++ = static_cast<uint8_t>(0xBB);
1749
        *to_nxt++ = static_cast<uint8_t>(0xBF);
1750
    }
1751
    for (; frm_nxt < frm_end; ++frm_nxt)
1752
    {
1753
        uint16_t wc1 = *frm_nxt;
1754
        if (wc1 > Maxcode)
1755
            return codecvt_base::error;
1756
        if (wc1 < 0x0080)
1757
        {
1758
            if (to_end-to_nxt < 1)
1759
                return codecvt_base::partial;
1760
            *to_nxt++ = static_cast<uint8_t>(wc1);
1761
        }
1762
        else if (wc1 < 0x0800)
1763
        {
1764
            if (to_end-to_nxt < 2)
1765
                return codecvt_base::partial;
1766
            *to_nxt++ = static_cast<uint8_t>(0xC0 | (wc1 >> 6));
1767
            *to_nxt++ = static_cast<uint8_t>(0x80 | (wc1 & 0x03F));
1768
        }
1769
        else if (wc1 < 0xD800)
1770
        {
1771
            if (to_end-to_nxt < 3)
1772
                return codecvt_base::partial;
1773
            *to_nxt++ = static_cast<uint8_t>(0xE0 |  (wc1 >> 12));
1774
            *to_nxt++ = static_cast<uint8_t>(0x80 | ((wc1 & 0x0FC0) >> 6));
1775
            *to_nxt++ = static_cast<uint8_t>(0x80 |  (wc1 & 0x003F));
1776
        }
1777
        else if (wc1 < 0xDC00)
1778
        {
1779
            if (frm_end-frm_nxt < 2)
1780
                return codecvt_base::partial;
1781
            uint16_t wc2 = frm_nxt[1];
1782
            if ((wc2 & 0xFC00) != 0xDC00)
1783
                return codecvt_base::error;
1784
            if (to_end-to_nxt < 4)
1785
                return codecvt_base::partial;
1786
            if (((((wc1 & 0x03C0UL) >> 6) + 1) << 16) +
1787
                ((wc1 & 0x003FUL) << 10) + (wc2 & 0x03FF) > Maxcode)
1788
                return codecvt_base::error;
1789
            ++frm_nxt;
1790
            uint8_t z = ((wc1 & 0x03C0) >> 6) + 1;
1791
            *to_nxt++ = static_cast<uint8_t>(0xF0 | (z >> 2));
1792
            *to_nxt++ = static_cast<uint8_t>(0x80 | ((z & 0x03) << 4)     | ((wc1 & 0x003C) >> 2));
1793
            *to_nxt++ = static_cast<uint8_t>(0x80 | ((wc1 & 0x0003) << 4) | ((wc2 & 0x03C0) >> 6));
1794
            *to_nxt++ = static_cast<uint8_t>(0x80 |  (wc2 & 0x003F));
1795
        }
1796
        else if (wc1 < 0xE000)
1797
        {
1798
            return codecvt_base::error;
1799
        }
1800
        else
1801
        {
1802
            if (to_end-to_nxt < 3)
1803
                return codecvt_base::partial;
1804
            *to_nxt++ = static_cast<uint8_t>(0xE0 |  (wc1 >> 12));
1805
            *to_nxt++ = static_cast<uint8_t>(0x80 | ((wc1 & 0x0FC0) >> 6));
1806
            *to_nxt++ = static_cast<uint8_t>(0x80 |  (wc1 & 0x003F));
1807
        }
1808
    }
1809
    return codecvt_base::ok;
1810
}
1811

1812
static
1813
codecvt_base::result
1814
utf16_to_utf8(const uint32_t* frm, const uint32_t* frm_end, const uint32_t*& frm_nxt,
1815
              uint8_t* to, uint8_t* to_end, uint8_t*& to_nxt,
1816
              unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = codecvt_mode(0))
1817
{
1818
    frm_nxt = frm;
1819
    to_nxt = to;
1820
    if (mode & generate_header)
1821
    {
1822
        if (to_end-to_nxt < 3)
1823
            return codecvt_base::partial;
1824
        *to_nxt++ = static_cast<uint8_t>(0xEF);
1825
        *to_nxt++ = static_cast<uint8_t>(0xBB);
1826
        *to_nxt++ = static_cast<uint8_t>(0xBF);
1827
    }
1828
    for (; frm_nxt < frm_end; ++frm_nxt)
1829
    {
1830
        uint16_t wc1 = static_cast<uint16_t>(*frm_nxt);
1831
        if (wc1 > Maxcode)
1832
            return codecvt_base::error;
1833
        if (wc1 < 0x0080)
1834
        {
1835
            if (to_end-to_nxt < 1)
1836
                return codecvt_base::partial;
1837
            *to_nxt++ = static_cast<uint8_t>(wc1);
1838
        }
1839
        else if (wc1 < 0x0800)
1840
        {
1841
            if (to_end-to_nxt < 2)
1842
                return codecvt_base::partial;
1843
            *to_nxt++ = static_cast<uint8_t>(0xC0 | (wc1 >> 6));
1844
            *to_nxt++ = static_cast<uint8_t>(0x80 | (wc1 & 0x03F));
1845
        }
1846
        else if (wc1 < 0xD800)
1847
        {
1848
            if (to_end-to_nxt < 3)
1849
                return codecvt_base::partial;
1850
            *to_nxt++ = static_cast<uint8_t>(0xE0 |  (wc1 >> 12));
1851
            *to_nxt++ = static_cast<uint8_t>(0x80 | ((wc1 & 0x0FC0) >> 6));
1852
            *to_nxt++ = static_cast<uint8_t>(0x80 |  (wc1 & 0x003F));
1853
        }
1854
        else if (wc1 < 0xDC00)
1855
        {
1856
            if (frm_end-frm_nxt < 2)
1857
                return codecvt_base::partial;
1858
            uint16_t wc2 = static_cast<uint16_t>(frm_nxt[1]);
1859
            if ((wc2 & 0xFC00) != 0xDC00)
1860
                return codecvt_base::error;
1861
            if (to_end-to_nxt < 4)
1862
                return codecvt_base::partial;
1863
            if (((((wc1 & 0x03C0UL) >> 6) + 1) << 16) +
1864
                ((wc1 & 0x003FUL) << 10) + (wc2 & 0x03FF) > Maxcode)
1865
                return codecvt_base::error;
1866
            ++frm_nxt;
1867
            uint8_t z = ((wc1 & 0x03C0) >> 6) + 1;
1868
            *to_nxt++ = static_cast<uint8_t>(0xF0 | (z >> 2));
1869
            *to_nxt++ = static_cast<uint8_t>(0x80 | ((z & 0x03) << 4)     | ((wc1 & 0x003C) >> 2));
1870
            *to_nxt++ = static_cast<uint8_t>(0x80 | ((wc1 & 0x0003) << 4) | ((wc2 & 0x03C0) >> 6));
1871
            *to_nxt++ = static_cast<uint8_t>(0x80 |  (wc2 & 0x003F));
1872
        }
1873
        else if (wc1 < 0xE000)
1874
        {
1875
            return codecvt_base::error;
1876
        }
1877
        else
1878
        {
1879
            if (to_end-to_nxt < 3)
1880
                return codecvt_base::partial;
1881
            *to_nxt++ = static_cast<uint8_t>(0xE0 |  (wc1 >> 12));
1882
            *to_nxt++ = static_cast<uint8_t>(0x80 | ((wc1 & 0x0FC0) >> 6));
1883
            *to_nxt++ = static_cast<uint8_t>(0x80 |  (wc1 & 0x003F));
1884
        }
1885
    }
1886
    return codecvt_base::ok;
1887
}
1888

1889
static
1890
codecvt_base::result
1891
utf8_to_utf16(const uint8_t* frm, const uint8_t* frm_end, const uint8_t*& frm_nxt,
1892
              uint16_t* to, uint16_t* to_end, uint16_t*& to_nxt,
1893
              unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = codecvt_mode(0))
1894
{
1895
    frm_nxt = frm;
1896
    to_nxt = to;
1897
    if (mode & consume_header)
1898
    {
1899
        if (frm_end-frm_nxt >= 3 && frm_nxt[0] == 0xEF && frm_nxt[1] == 0xBB &&
1900
                                                          frm_nxt[2] == 0xBF)
1901
            frm_nxt += 3;
1902
    }
1903
    for (; frm_nxt < frm_end && to_nxt < to_end; ++to_nxt)
1904
    {
1905
        uint8_t c1 = *frm_nxt;
1906
        if (c1 > Maxcode)
1907
            return codecvt_base::error;
1908
        if (c1 < 0x80)
1909
        {
1910
            *to_nxt = static_cast<uint16_t>(c1);
1911
            ++frm_nxt;
1912
        }
1913
        else if (c1 < 0xC2)
1914
        {
1915
            return codecvt_base::error;
1916
        }
1917
        else if (c1 < 0xE0)
1918
        {
1919
            if (frm_end-frm_nxt < 2)
1920
                return codecvt_base::partial;
1921
            uint8_t c2 = frm_nxt[1];
1922
            if ((c2 & 0xC0) != 0x80)
1923
                return codecvt_base::error;
1924
            uint16_t t = static_cast<uint16_t>(((c1 & 0x1F) << 6) | (c2 & 0x3F));
1925
            if (t > Maxcode)
1926
                return codecvt_base::error;
1927
            *to_nxt = t;
1928
            frm_nxt += 2;
1929
        }
1930
        else if (c1 < 0xF0)
1931
        {
1932
            if (frm_end-frm_nxt < 3)
1933
                return codecvt_base::partial;
1934
            uint8_t c2 = frm_nxt[1];
1935
            uint8_t c3 = frm_nxt[2];
1936
            switch (c1)
1937
            {
1938
            case 0xE0:
1939
                if ((c2 & 0xE0) != 0xA0)
1940
                    return codecvt_base::error;
1941
                 break;
1942
            case 0xED:
1943
                if ((c2 & 0xE0) != 0x80)
1944
                    return codecvt_base::error;
1945
                 break;
1946
            default:
1947
                if ((c2 & 0xC0) != 0x80)
1948
                    return codecvt_base::error;
1949
                 break;
1950
            }
1951
            if ((c3 & 0xC0) != 0x80)
1952
                return codecvt_base::error;
1953
            uint16_t t = static_cast<uint16_t>(((c1 & 0x0F) << 12)
1954
                                             | ((c2 & 0x3F) << 6)
1955
                                             |  (c3 & 0x3F));
1956
            if (t > Maxcode)
1957
                return codecvt_base::error;
1958
            *to_nxt = t;
1959
            frm_nxt += 3;
1960
        }
1961
        else if (c1 < 0xF5)
1962
        {
1963
            if (frm_end-frm_nxt < 4)
1964
                return codecvt_base::partial;
1965
            uint8_t c2 = frm_nxt[1];
1966
            uint8_t c3 = frm_nxt[2];
1967
            uint8_t c4 = frm_nxt[3];
1968
            switch (c1)
1969
            {
1970
            case 0xF0:
1971
                if (!(0x90 <= c2 && c2 <= 0xBF))
1972
                    return codecvt_base::error;
1973
                 break;
1974
            case 0xF4:
1975
                if ((c2 & 0xF0) != 0x80)
1976
                    return codecvt_base::error;
1977
                 break;
1978
            default:
1979
                if ((c2 & 0xC0) != 0x80)
1980
                    return codecvt_base::error;
1981
                 break;
1982
            }
1983
            if ((c3 & 0xC0) != 0x80 || (c4 & 0xC0) != 0x80)
1984
                return codecvt_base::error;
1985
            if (to_end-to_nxt < 2)
1986
                return codecvt_base::partial;
1987
            if ((((c1 & 7UL) << 18) +
1988
                ((c2 & 0x3FUL) << 12) +
1989
                ((c3 & 0x3FUL) << 6) + (c4 & 0x3F)) > Maxcode)
1990
                return codecvt_base::error;
1991
            *to_nxt = static_cast<uint16_t>(
1992
                    0xD800
1993
                  | (((((c1 & 0x07) << 2) | ((c2 & 0x30) >> 4)) - 1) << 6)
1994
                  | ((c2 & 0x0F) << 2)
1995
                  | ((c3 & 0x30) >> 4));
1996
            *++to_nxt = static_cast<uint16_t>(
1997
                    0xDC00
1998
                  | ((c3 & 0x0F) << 6)
1999
                  |  (c4 & 0x3F));
2000
            frm_nxt += 4;
2001
        }
2002
        else
2003
        {
2004
            return codecvt_base::error;
2005
        }
2006
    }
2007
    return frm_nxt < frm_end ? codecvt_base::partial : codecvt_base::ok;
2008
}
2009

2010
static
2011
codecvt_base::result
2012
utf8_to_utf16(const uint8_t* frm, const uint8_t* frm_end, const uint8_t*& frm_nxt,
2013
              uint32_t* to, uint32_t* to_end, uint32_t*& to_nxt,
2014
              unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = codecvt_mode(0))
2015
{
2016
    frm_nxt = frm;
2017
    to_nxt = to;
2018
    if (mode & consume_header)
2019
    {
2020
        if (frm_end-frm_nxt >= 3 && frm_nxt[0] == 0xEF && frm_nxt[1] == 0xBB &&
2021
                                                          frm_nxt[2] == 0xBF)
2022
            frm_nxt += 3;
2023
    }
2024
    for (; frm_nxt < frm_end && to_nxt < to_end; ++to_nxt)
2025
    {
2026
        uint8_t c1 = *frm_nxt;
2027
        if (c1 > Maxcode)
2028
            return codecvt_base::error;
2029
        if (c1 < 0x80)
2030
        {
2031
            *to_nxt = static_cast<uint32_t>(c1);
2032
            ++frm_nxt;
2033
        }
2034
        else if (c1 < 0xC2)
2035
        {
2036
            return codecvt_base::error;
2037
        }
2038
        else if (c1 < 0xE0)
2039
        {
2040
            if (frm_end-frm_nxt < 2)
2041
                return codecvt_base::partial;
2042
            uint8_t c2 = frm_nxt[1];
2043
            if ((c2 & 0xC0) != 0x80)
2044
                return codecvt_base::error;
2045
            uint16_t t = static_cast<uint16_t>(((c1 & 0x1F) << 6) | (c2 & 0x3F));
2046
            if (t > Maxcode)
2047
                return codecvt_base::error;
2048
            *to_nxt = static_cast<uint32_t>(t);
2049
            frm_nxt += 2;
2050
        }
2051
        else if (c1 < 0xF0)
2052
        {
2053
            if (frm_end-frm_nxt < 3)
2054
                return codecvt_base::partial;
2055
            uint8_t c2 = frm_nxt[1];
2056
            uint8_t c3 = frm_nxt[2];
2057
            switch (c1)
2058
            {
2059
            case 0xE0:
2060
                if ((c2 & 0xE0) != 0xA0)
2061
                    return codecvt_base::error;
2062
                 break;
2063
            case 0xED:
2064
                if ((c2 & 0xE0) != 0x80)
2065
                    return codecvt_base::error;
2066
                 break;
2067
            default:
2068
                if ((c2 & 0xC0) != 0x80)
2069
                    return codecvt_base::error;
2070
                 break;
2071
            }
2072
            if ((c3 & 0xC0) != 0x80)
2073
                return codecvt_base::error;
2074
            uint16_t t = static_cast<uint16_t>(((c1 & 0x0F) << 12)
2075
                                             | ((c2 & 0x3F) << 6)
2076
                                             |  (c3 & 0x3F));
2077
            if (t > Maxcode)
2078
                return codecvt_base::error;
2079
            *to_nxt = static_cast<uint32_t>(t);
2080
            frm_nxt += 3;
2081
        }
2082
        else if (c1 < 0xF5)
2083
        {
2084
            if (frm_end-frm_nxt < 4)
2085
                return codecvt_base::partial;
2086
            uint8_t c2 = frm_nxt[1];
2087
            uint8_t c3 = frm_nxt[2];
2088
            uint8_t c4 = frm_nxt[3];
2089
            switch (c1)
2090
            {
2091
            case 0xF0:
2092
                if (!(0x90 <= c2 && c2 <= 0xBF))
2093
                    return codecvt_base::error;
2094
                 break;
2095
            case 0xF4:
2096
                if ((c2 & 0xF0) != 0x80)
2097
                    return codecvt_base::error;
2098
                 break;
2099
            default:
2100
                if ((c2 & 0xC0) != 0x80)
2101
                    return codecvt_base::error;
2102
                 break;
2103
            }
2104
            if ((c3 & 0xC0) != 0x80 || (c4 & 0xC0) != 0x80)
2105
                return codecvt_base::error;
2106
            if (to_end-to_nxt < 2)
2107
                return codecvt_base::partial;
2108
            if ((((c1 & 7UL) << 18) +
2109
                ((c2 & 0x3FUL) << 12) +
2110
                ((c3 & 0x3FUL) << 6) + (c4 & 0x3F)) > Maxcode)
2111
                return codecvt_base::error;
2112
            *to_nxt = static_cast<uint32_t>(
2113
                    0xD800
2114
                  | (((((c1 & 0x07) << 2) | ((c2 & 0x30) >> 4)) - 1) << 6)
2115
                  | ((c2 & 0x0F) << 2)
2116
                  | ((c3 & 0x30) >> 4));
2117
            *++to_nxt = static_cast<uint32_t>(
2118
                    0xDC00
2119
                  | ((c3 & 0x0F) << 6)
2120
                  |  (c4 & 0x3F));
2121
            frm_nxt += 4;
2122
        }
2123
        else
2124
        {
2125
            return codecvt_base::error;
2126
        }
2127
    }
2128
    return frm_nxt < frm_end ? codecvt_base::partial : codecvt_base::ok;
2129
}
2130

2131
static
2132
int
2133
utf8_to_utf16_length(const uint8_t* frm, const uint8_t* frm_end,
2134
                     size_t mx, unsigned long Maxcode = 0x10FFFF,
2135
                     codecvt_mode mode = codecvt_mode(0))
2136
{
2137
    const uint8_t* frm_nxt = frm;
2138
    if (mode & consume_header)
2139
    {
2140
        if (frm_end-frm_nxt >= 3 && frm_nxt[0] == 0xEF && frm_nxt[1] == 0xBB &&
2141
                                                          frm_nxt[2] == 0xBF)
2142
            frm_nxt += 3;
2143
    }
2144
    for (size_t nchar16_t = 0; frm_nxt < frm_end && nchar16_t < mx; ++nchar16_t)
2145
    {
2146
        uint8_t c1 = *frm_nxt;
2147
        if (c1 > Maxcode)
2148
            break;
2149
        if (c1 < 0x80)
2150
        {
2151
            ++frm_nxt;
2152
        }
2153
        else if (c1 < 0xC2)
2154
        {
2155
            break;
2156
        }
2157
        else if (c1 < 0xE0)
2158
        {
2159
            if ((frm_end-frm_nxt < 2) || (frm_nxt[1] & 0xC0) != 0x80)
2160
                break;
2161
            uint16_t t = static_cast<uint16_t>(((c1 & 0x1F) << 6) | (frm_nxt[1] & 0x3F));
2162
            if (t > Maxcode)
2163
                break;
2164
            frm_nxt += 2;
2165
        }
2166
        else if (c1 < 0xF0)
2167
        {
2168
            if (frm_end-frm_nxt < 3)
2169
                break;
2170
            uint8_t c2 = frm_nxt[1];
2171
            uint8_t c3 = frm_nxt[2];
2172
            switch (c1)
2173
            {
2174
            case 0xE0:
2175
                if ((c2 & 0xE0) != 0xA0)
2176
                    return static_cast<int>(frm_nxt - frm);
2177
                break;
2178
            case 0xED:
2179
                if ((c2 & 0xE0) != 0x80)
2180
                    return static_cast<int>(frm_nxt - frm);
2181
                 break;
2182
            default:
2183
                if ((c2 & 0xC0) != 0x80)
2184
                    return static_cast<int>(frm_nxt - frm);
2185
                 break;
2186
            }
2187
            if ((c3 & 0xC0) != 0x80)
2188
                break;
2189
            if ((((c1 & 0x0Fu) << 12) | ((c2 & 0x3Fu) << 6) | (c3 & 0x3Fu)) > Maxcode)
2190
                break;
2191
            frm_nxt += 3;
2192
        }
2193
        else if (c1 < 0xF5)
2194
        {
2195
            if (frm_end-frm_nxt < 4 || mx-nchar16_t < 2)
2196
                break;
2197
            uint8_t c2 = frm_nxt[1];
2198
            uint8_t c3 = frm_nxt[2];
2199
            uint8_t c4 = frm_nxt[3];
2200
            switch (c1)
2201
            {
2202
            case 0xF0:
2203
                if (!(0x90 <= c2 && c2 <= 0xBF))
2204
                    return static_cast<int>(frm_nxt - frm);
2205
                 break;
2206
            case 0xF4:
2207
                if ((c2 & 0xF0) != 0x80)
2208
                    return static_cast<int>(frm_nxt - frm);
2209
                 break;
2210
            default:
2211
                if ((c2 & 0xC0) != 0x80)
2212
                    return static_cast<int>(frm_nxt - frm);
2213
                 break;
2214
            }
2215
            if ((c3 & 0xC0) != 0x80 || (c4 & 0xC0) != 0x80)
2216
                break;
2217
            if ((((c1 & 7UL) << 18) +
2218
                ((c2 & 0x3FUL) << 12) +
2219
                ((c3 & 0x3FUL) << 6) + (c4 & 0x3F)) > Maxcode)
2220
                break;
2221
            ++nchar16_t;
2222
            frm_nxt += 4;
2223
        }
2224
        else
2225
        {
2226
            break;
2227
        }
2228
    }
2229
    return static_cast<int>(frm_nxt - frm);
2230
}
2231

2232
static
2233
codecvt_base::result
2234
ucs4_to_utf8(const uint32_t* frm, const uint32_t* frm_end, const uint32_t*& frm_nxt,
2235
             uint8_t* to, uint8_t* to_end, uint8_t*& to_nxt,
2236
             unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = codecvt_mode(0))
2237
{
2238
    frm_nxt = frm;
2239
    to_nxt = to;
2240
    if (mode & generate_header)
2241
    {
2242
        if (to_end-to_nxt < 3)
2243
            return codecvt_base::partial;
2244
        *to_nxt++ = static_cast<uint8_t>(0xEF);
2245
        *to_nxt++ = static_cast<uint8_t>(0xBB);
2246
        *to_nxt++ = static_cast<uint8_t>(0xBF);
2247
    }
2248
    for (; frm_nxt < frm_end; ++frm_nxt)
2249
    {
2250
        uint32_t wc = *frm_nxt;
2251
        if ((wc & 0xFFFFF800) == 0x00D800 || wc > Maxcode)
2252
            return codecvt_base::error;
2253
        if (wc < 0x000080)
2254
        {
2255
            if (to_end-to_nxt < 1)
2256
                return codecvt_base::partial;
2257
            *to_nxt++ = static_cast<uint8_t>(wc);
2258
        }
2259
        else if (wc < 0x000800)
2260
        {
2261
            if (to_end-to_nxt < 2)
2262
                return codecvt_base::partial;
2263
            *to_nxt++ = static_cast<uint8_t>(0xC0 | (wc >> 6));
2264
            *to_nxt++ = static_cast<uint8_t>(0x80 | (wc & 0x03F));
2265
        }
2266
        else if (wc < 0x010000)
2267
        {
2268
            if (to_end-to_nxt < 3)
2269
                return codecvt_base::partial;
2270
            *to_nxt++ = static_cast<uint8_t>(0xE0 |  (wc >> 12));
2271
            *to_nxt++ = static_cast<uint8_t>(0x80 | ((wc & 0x0FC0) >> 6));
2272
            *to_nxt++ = static_cast<uint8_t>(0x80 |  (wc & 0x003F));
2273
        }
2274
        else // if (wc < 0x110000)
2275
        {
2276
            if (to_end-to_nxt < 4)
2277
                return codecvt_base::partial;
2278
            *to_nxt++ = static_cast<uint8_t>(0xF0 |  (wc >> 18));
2279
            *to_nxt++ = static_cast<uint8_t>(0x80 | ((wc & 0x03F000) >> 12));
2280
            *to_nxt++ = static_cast<uint8_t>(0x80 | ((wc & 0x000FC0) >> 6));
2281
            *to_nxt++ = static_cast<uint8_t>(0x80 |  (wc & 0x00003F));
2282
        }
2283
    }
2284
    return codecvt_base::ok;
2285
}
2286

2287
static
2288
codecvt_base::result
2289
utf8_to_ucs4(const uint8_t* frm, const uint8_t* frm_end, const uint8_t*& frm_nxt,
2290
             uint32_t* to, uint32_t* to_end, uint32_t*& to_nxt,
2291
             unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = codecvt_mode(0))
2292
{
2293
    frm_nxt = frm;
2294
    to_nxt = to;
2295
    if (mode & consume_header)
2296
    {
2297
        if (frm_end-frm_nxt >= 3 && frm_nxt[0] == 0xEF && frm_nxt[1] == 0xBB &&
2298
                                                          frm_nxt[2] == 0xBF)
2299
            frm_nxt += 3;
2300
    }
2301
    for (; frm_nxt < frm_end && to_nxt < to_end; ++to_nxt)
2302
    {
2303
        uint8_t c1 = static_cast<uint8_t>(*frm_nxt);
2304
        if (c1 < 0x80)
2305
        {
2306
            if (c1 > Maxcode)
2307
                return codecvt_base::error;
2308
            *to_nxt = static_cast<uint32_t>(c1);
2309
            ++frm_nxt;
2310
        }
2311
        else if (c1 < 0xC2)
2312
        {
2313
            return codecvt_base::error;
2314
        }
2315
        else if (c1 < 0xE0)
2316
        {
2317
            if (frm_end-frm_nxt < 2)
2318
                return codecvt_base::partial;
2319
            uint8_t c2 = frm_nxt[1];
2320
            if ((c2 & 0xC0) != 0x80)
2321
                return codecvt_base::error;
2322
            uint32_t t = static_cast<uint32_t>(((c1 & 0x1F) << 6)
2323
                                              | (c2 & 0x3F));
2324
            if (t > Maxcode)
2325
                return codecvt_base::error;
2326
            *to_nxt = t;
2327
            frm_nxt += 2;
2328
        }
2329
        else if (c1 < 0xF0)
2330
        {
2331
            if (frm_end-frm_nxt < 3)
2332
                return codecvt_base::partial;
2333
            uint8_t c2 = frm_nxt[1];
2334
            uint8_t c3 = frm_nxt[2];
2335
            switch (c1)
2336
            {
2337
            case 0xE0:
2338
                if ((c2 & 0xE0) != 0xA0)
2339
                    return codecvt_base::error;
2340
                 break;
2341
            case 0xED:
2342
                if ((c2 & 0xE0) != 0x80)
2343
                    return codecvt_base::error;
2344
                 break;
2345
            default:
2346
                if ((c2 & 0xC0) != 0x80)
2347
                    return codecvt_base::error;
2348
                 break;
2349
            }
2350
            if ((c3 & 0xC0) != 0x80)
2351
                return codecvt_base::error;
2352
            uint32_t t = static_cast<uint32_t>(((c1 & 0x0F) << 12)
2353
                                             | ((c2 & 0x3F) << 6)
2354
                                             |  (c3 & 0x3F));
2355
            if (t > Maxcode)
2356
                return codecvt_base::error;
2357
            *to_nxt = t;
2358
            frm_nxt += 3;
2359
        }
2360
        else if (c1 < 0xF5)
2361
        {
2362
            if (frm_end-frm_nxt < 4)
2363
                return codecvt_base::partial;
2364
            uint8_t c2 = frm_nxt[1];
2365
            uint8_t c3 = frm_nxt[2];
2366
            uint8_t c4 = frm_nxt[3];
2367
            switch (c1)
2368
            {
2369
            case 0xF0:
2370
                if (!(0x90 <= c2 && c2 <= 0xBF))
2371
                    return codecvt_base::error;
2372
                 break;
2373
            case 0xF4:
2374
                if ((c2 & 0xF0) != 0x80)
2375
                    return codecvt_base::error;
2376
                 break;
2377
            default:
2378
                if ((c2 & 0xC0) != 0x80)
2379
                    return codecvt_base::error;
2380
                 break;
2381
            }
2382
            if ((c3 & 0xC0) != 0x80 || (c4 & 0xC0) != 0x80)
2383
                return codecvt_base::error;
2384
            uint32_t t = static_cast<uint32_t>(((c1 & 0x07) << 18)
2385
                                             | ((c2 & 0x3F) << 12)
2386
                                             | ((c3 & 0x3F) << 6)
2387
                                             |  (c4 & 0x3F));
2388
            if (t > Maxcode)
2389
                return codecvt_base::error;
2390
            *to_nxt = t;
2391
            frm_nxt += 4;
2392
        }
2393
        else
2394
        {
2395
            return codecvt_base::error;
2396
        }
2397
    }
2398
    return frm_nxt < frm_end ? codecvt_base::partial : codecvt_base::ok;
2399
}
2400

2401
static
2402
int
2403
utf8_to_ucs4_length(const uint8_t* frm, const uint8_t* frm_end,
2404
                    size_t mx, unsigned long Maxcode = 0x10FFFF,
2405
                    codecvt_mode mode = codecvt_mode(0))
2406
{
2407
    const uint8_t* frm_nxt = frm;
2408
    if (mode & consume_header)
2409
    {
2410
        if (frm_end-frm_nxt >= 3 && frm_nxt[0] == 0xEF && frm_nxt[1] == 0xBB &&
2411
                                                          frm_nxt[2] == 0xBF)
2412
            frm_nxt += 3;
2413
    }
2414
    for (size_t nchar32_t = 0; frm_nxt < frm_end && nchar32_t < mx; ++nchar32_t)
2415
    {
2416
        uint8_t c1 = static_cast<uint8_t>(*frm_nxt);
2417
        if (c1 < 0x80)
2418
        {
2419
            if (c1 > Maxcode)
2420
                break;
2421
            ++frm_nxt;
2422
        }
2423
        else if (c1 < 0xC2)
2424
        {
2425
            break;
2426
        }
2427
        else if (c1 < 0xE0)
2428
        {
2429
            if ((frm_end-frm_nxt < 2) || ((frm_nxt[1] & 0xC0) != 0x80))
2430
                break;
2431
            if ((((c1 & 0x1Fu) << 6) | (frm_nxt[1] & 0x3Fu)) > Maxcode)
2432
                break;
2433
            frm_nxt += 2;
2434
        }
2435
        else if (c1 < 0xF0)
2436
        {
2437
            if (frm_end-frm_nxt < 3)
2438
                break;
2439
            uint8_t c2 = frm_nxt[1];
2440
            uint8_t c3 = frm_nxt[2];
2441
            switch (c1)
2442
            {
2443
            case 0xE0:
2444
                if ((c2 & 0xE0) != 0xA0)
2445
                    return static_cast<int>(frm_nxt - frm);
2446
                break;
2447
            case 0xED:
2448
                if ((c2 & 0xE0) != 0x80)
2449
                    return static_cast<int>(frm_nxt - frm);
2450
                 break;
2451
            default:
2452
                if ((c2 & 0xC0) != 0x80)
2453
                    return static_cast<int>(frm_nxt - frm);
2454
                 break;
2455
            }
2456
            if ((c3 & 0xC0) != 0x80)
2457
                break;
2458
            if ((((c1 & 0x0Fu) << 12) | ((c2 & 0x3Fu) << 6) | (c3 & 0x3Fu)) > Maxcode)
2459
                break;
2460
            frm_nxt += 3;
2461
        }
2462
        else if (c1 < 0xF5)
2463
        {
2464
            if (frm_end-frm_nxt < 4)
2465
                break;
2466
            uint8_t c2 = frm_nxt[1];
2467
            uint8_t c3 = frm_nxt[2];
2468
            uint8_t c4 = frm_nxt[3];
2469
            switch (c1)
2470
            {
2471
            case 0xF0:
2472
                if (!(0x90 <= c2 && c2 <= 0xBF))
2473
                    return static_cast<int>(frm_nxt - frm);
2474
                 break;
2475
            case 0xF4:
2476
                if ((c2 & 0xF0) != 0x80)
2477
                    return static_cast<int>(frm_nxt - frm);
2478
                 break;
2479
            default:
2480
                if ((c2 & 0xC0) != 0x80)
2481
                    return static_cast<int>(frm_nxt - frm);
2482
                 break;
2483
            }
2484
            if ((c3 & 0xC0) != 0x80 || (c4 & 0xC0) != 0x80)
2485
                break;
2486
            if ((((c1 & 0x07u) << 18) | ((c2 & 0x3Fu) << 12) |
2487
                 ((c3 & 0x3Fu) << 6)  |  (c4 & 0x3Fu)) > Maxcode)
2488
                break;
2489
            frm_nxt += 4;
2490
        }
2491
        else
2492
        {
2493
            break;
2494
        }
2495
    }
2496
    return static_cast<int>(frm_nxt - frm);
2497
}
2498

2499
static
2500
codecvt_base::result
2501
ucs2_to_utf8(const uint16_t* frm, const uint16_t* frm_end, const uint16_t*& frm_nxt,
2502
             uint8_t* to, uint8_t* to_end, uint8_t*& to_nxt,
2503
             unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = codecvt_mode(0))
2504
{
2505
    frm_nxt = frm;
2506
    to_nxt = to;
2507
    if (mode & generate_header)
2508
    {
2509
        if (to_end-to_nxt < 3)
2510
            return codecvt_base::partial;
2511
        *to_nxt++ = static_cast<uint8_t>(0xEF);
2512
        *to_nxt++ = static_cast<uint8_t>(0xBB);
2513
        *to_nxt++ = static_cast<uint8_t>(0xBF);
2514
    }
2515
    for (; frm_nxt < frm_end; ++frm_nxt)
2516
    {
2517
        uint16_t wc = *frm_nxt;
2518
        if ((wc & 0xF800) == 0xD800 || wc > Maxcode)
2519
            return codecvt_base::error;
2520
        if (wc < 0x0080)
2521
        {
2522
            if (to_end-to_nxt < 1)
2523
                return codecvt_base::partial;
2524
            *to_nxt++ = static_cast<uint8_t>(wc);
2525
        }
2526
        else if (wc < 0x0800)
2527
        {
2528
            if (to_end-to_nxt < 2)
2529
                return codecvt_base::partial;
2530
            *to_nxt++ = static_cast<uint8_t>(0xC0 | (wc >> 6));
2531
            *to_nxt++ = static_cast<uint8_t>(0x80 | (wc & 0x03F));
2532
        }
2533
        else // if (wc <= 0xFFFF)
2534
        {
2535
            if (to_end-to_nxt < 3)
2536
                return codecvt_base::partial;
2537
            *to_nxt++ = static_cast<uint8_t>(0xE0 |  (wc >> 12));
2538
            *to_nxt++ = static_cast<uint8_t>(0x80 | ((wc & 0x0FC0) >> 6));
2539
            *to_nxt++ = static_cast<uint8_t>(0x80 |  (wc & 0x003F));
2540
        }
2541
    }
2542
    return codecvt_base::ok;
2543
}
2544

2545
static
2546
codecvt_base::result
2547
utf8_to_ucs2(const uint8_t* frm, const uint8_t* frm_end, const uint8_t*& frm_nxt,
2548
             uint16_t* to, uint16_t* to_end, uint16_t*& to_nxt,
2549
             unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = codecvt_mode(0))
2550
{
2551
    frm_nxt = frm;
2552
    to_nxt = to;
2553
    if (mode & consume_header)
2554
    {
2555
        if (frm_end-frm_nxt >= 3 && frm_nxt[0] == 0xEF && frm_nxt[1] == 0xBB &&
2556
                                                          frm_nxt[2] == 0xBF)
2557
            frm_nxt += 3;
2558
    }
2559
    for (; frm_nxt < frm_end && to_nxt < to_end; ++to_nxt)
2560
    {
2561
        uint8_t c1 = static_cast<uint8_t>(*frm_nxt);
2562
        if (c1 < 0x80)
2563
        {
2564
            if (c1 > Maxcode)
2565
                return codecvt_base::error;
2566
            *to_nxt = static_cast<uint16_t>(c1);
2567
            ++frm_nxt;
2568
        }
2569
        else if (c1 < 0xC2)
2570
        {
2571
            return codecvt_base::error;
2572
        }
2573
        else if (c1 < 0xE0)
2574
        {
2575
            if (frm_end-frm_nxt < 2)
2576
                return codecvt_base::partial;
2577
            uint8_t c2 = frm_nxt[1];
2578
            if ((c2 & 0xC0) != 0x80)
2579
                return codecvt_base::error;
2580
            uint16_t t = static_cast<uint16_t>(((c1 & 0x1F) << 6)
2581
                                              | (c2 & 0x3F));
2582
            if (t > Maxcode)
2583
                return codecvt_base::error;
2584
            *to_nxt = t;
2585
            frm_nxt += 2;
2586
        }
2587
        else if (c1 < 0xF0)
2588
        {
2589
            if (frm_end-frm_nxt < 3)
2590
                return codecvt_base::partial;
2591
            uint8_t c2 = frm_nxt[1];
2592
            uint8_t c3 = frm_nxt[2];
2593
            switch (c1)
2594
            {
2595
            case 0xE0:
2596
                if ((c2 & 0xE0) != 0xA0)
2597
                    return codecvt_base::error;
2598
                 break;
2599
            case 0xED:
2600
                if ((c2 & 0xE0) != 0x80)
2601
                    return codecvt_base::error;
2602
                 break;
2603
            default:
2604
                if ((c2 & 0xC0) != 0x80)
2605
                    return codecvt_base::error;
2606
                 break;
2607
            }
2608
            if ((c3 & 0xC0) != 0x80)
2609
                return codecvt_base::error;
2610
            uint16_t t = static_cast<uint16_t>(((c1 & 0x0F) << 12)
2611
                                             | ((c2 & 0x3F) << 6)
2612
                                             |  (c3 & 0x3F));
2613
            if (t > Maxcode)
2614
                return codecvt_base::error;
2615
            *to_nxt = t;
2616
            frm_nxt += 3;
2617
        }
2618
        else
2619
        {
2620
            return codecvt_base::error;
2621
        }
2622
    }
2623
    return frm_nxt < frm_end ? codecvt_base::partial : codecvt_base::ok;
2624
}
2625

2626
static
2627
int
2628
utf8_to_ucs2_length(const uint8_t* frm, const uint8_t* frm_end,
2629
                    size_t mx, unsigned long Maxcode = 0x10FFFF,
2630
                    codecvt_mode mode = codecvt_mode(0))
2631
{
2632
    const uint8_t* frm_nxt = frm;
2633
    if (mode & consume_header)
2634
    {
2635
        if (frm_end-frm_nxt >= 3 && frm_nxt[0] == 0xEF && frm_nxt[1] == 0xBB &&
2636
                                                          frm_nxt[2] == 0xBF)
2637
            frm_nxt += 3;
2638
    }
2639
    for (size_t nchar32_t = 0; frm_nxt < frm_end && nchar32_t < mx; ++nchar32_t)
2640
    {
2641
        uint8_t c1 = static_cast<uint8_t>(*frm_nxt);
2642
        if (c1 < 0x80)
2643
        {
2644
            if (c1 > Maxcode)
2645
                break;
2646
            ++frm_nxt;
2647
        }
2648
        else if (c1 < 0xC2)
2649
        {
2650
            break;
2651
        }
2652
        else if (c1 < 0xE0)
2653
        {
2654
            if ((frm_end-frm_nxt < 2) || ((frm_nxt[1] & 0xC0) != 0x80))
2655
                break;
2656
            if ((((c1 & 0x1Fu) << 6) | (frm_nxt[1] & 0x3Fu)) > Maxcode)
2657
                break;
2658
            frm_nxt += 2;
2659
        }
2660
        else if (c1 < 0xF0)
2661
        {
2662
            if (frm_end-frm_nxt < 3)
2663
                break;
2664
            uint8_t c2 = frm_nxt[1];
2665
            uint8_t c3 = frm_nxt[2];
2666
            switch (c1)
2667
            {
2668
            case 0xE0:
2669
                if ((c2 & 0xE0) != 0xA0)
2670
                    return static_cast<int>(frm_nxt - frm);
2671
                break;
2672
            case 0xED:
2673
                if ((c2 & 0xE0) != 0x80)
2674
                    return static_cast<int>(frm_nxt - frm);
2675
                 break;
2676
            default:
2677
                if ((c2 & 0xC0) != 0x80)
2678
                    return static_cast<int>(frm_nxt - frm);
2679
                 break;
2680
            }
2681
            if ((c3 & 0xC0) != 0x80)
2682
                break;
2683
            if ((((c1 & 0x0Fu) << 12) | ((c2 & 0x3Fu) << 6) | (c3 & 0x3Fu)) > Maxcode)
2684
                break;
2685
            frm_nxt += 3;
2686
        }
2687
        else
2688
        {
2689
            break;
2690
        }
2691
    }
2692
    return static_cast<int>(frm_nxt - frm);
2693
}
2694

2695
static
2696
codecvt_base::result
2697
ucs4_to_utf16be(const uint32_t* frm, const uint32_t* frm_end, const uint32_t*& frm_nxt,
2698
                uint8_t* to, uint8_t* to_end, uint8_t*& to_nxt,
2699
                unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = codecvt_mode(0))
2700
{
2701
    frm_nxt = frm;
2702
    to_nxt = to;
2703
    if (mode & generate_header)
2704
    {
2705
        if (to_end-to_nxt < 2)
2706
            return codecvt_base::partial;
2707
        *to_nxt++ = static_cast<uint8_t>(0xFE);
2708
        *to_nxt++ = static_cast<uint8_t>(0xFF);
2709
    }
2710
    for (; frm_nxt < frm_end; ++frm_nxt)
2711
    {
2712
        uint32_t wc = *frm_nxt;
2713
        if ((wc & 0xFFFFF800) == 0x00D800 || wc > Maxcode)
2714
            return codecvt_base::error;
2715
        if (wc < 0x010000)
2716
        {
2717
            if (to_end-to_nxt < 2)
2718
                return codecvt_base::partial;
2719
            *to_nxt++ = static_cast<uint8_t>(wc >> 8);
2720
            *to_nxt++ = static_cast<uint8_t>(wc);
2721
        }
2722
        else
2723
        {
2724
            if (to_end-to_nxt < 4)
2725
                return codecvt_base::partial;
2726
            uint16_t t = static_cast<uint16_t>(
2727
                    0xD800
2728
                  | ((((wc & 0x1F0000) >> 16) - 1) << 6)
2729
                  |   ((wc & 0x00FC00) >> 10));
2730
            *to_nxt++ = static_cast<uint8_t>(t >> 8);
2731
            *to_nxt++ = static_cast<uint8_t>(t);
2732
            t = static_cast<uint16_t>(0xDC00 | (wc & 0x03FF));
2733
            *to_nxt++ = static_cast<uint8_t>(t >> 8);
2734
            *to_nxt++ = static_cast<uint8_t>(t);
2735
        }
2736
    }
2737
    return codecvt_base::ok;
2738
}
2739

2740
static
2741
codecvt_base::result
2742
utf16be_to_ucs4(const uint8_t* frm, const uint8_t* frm_end, const uint8_t*& frm_nxt,
2743
                uint32_t* to, uint32_t* to_end, uint32_t*& to_nxt,
2744
                unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = codecvt_mode(0))
2745
{
2746
    frm_nxt = frm;
2747
    to_nxt = to;
2748
    if (mode & consume_header)
2749
    {
2750
        if (frm_end-frm_nxt >= 2 && frm_nxt[0] == 0xFE && frm_nxt[1] == 0xFF)
2751
            frm_nxt += 2;
2752
    }
2753
    for (; frm_nxt < frm_end - 1 && to_nxt < to_end; ++to_nxt)
2754
    {
2755
        uint16_t c1 = static_cast<uint16_t>(frm_nxt[0] << 8 | frm_nxt[1]);
2756
        if ((c1 & 0xFC00) == 0xDC00)
2757
            return codecvt_base::error;
2758
        if ((c1 & 0xFC00) != 0xD800)
2759
        {
2760
            if (c1 > Maxcode)
2761
                return codecvt_base::error;
2762
            *to_nxt = static_cast<uint32_t>(c1);
2763
            frm_nxt += 2;
2764
        }
2765
        else
2766
        {
2767
            if (frm_end-frm_nxt < 4)
2768
                return codecvt_base::partial;
2769
            uint16_t c2 = static_cast<uint16_t>(frm_nxt[2] << 8 | frm_nxt[3]);
2770
            if ((c2 & 0xFC00) != 0xDC00)
2771
                return codecvt_base::error;
2772
            uint32_t t = static_cast<uint32_t>(
2773
                    ((((c1 & 0x03C0) >> 6) + 1) << 16)
2774
                  |   ((c1 & 0x003F) << 10)
2775
                  |    (c2 & 0x03FF));
2776
            if (t > Maxcode)
2777
                return codecvt_base::error;
2778
            *to_nxt = t;
2779
            frm_nxt += 4;
2780
        }
2781
    }
2782
    return frm_nxt < frm_end ? codecvt_base::partial : codecvt_base::ok;
2783
}
2784

2785
static
2786
int
2787
utf16be_to_ucs4_length(const uint8_t* frm, const uint8_t* frm_end,
2788
                       size_t mx, unsigned long Maxcode = 0x10FFFF,
2789
                       codecvt_mode mode = codecvt_mode(0))
2790
{
2791
    const uint8_t* frm_nxt = frm;
2792
    if (mode & consume_header)
2793
    {
2794
        if (frm_end-frm_nxt >= 2 && frm_nxt[0] == 0xFE && frm_nxt[1] == 0xFF)
2795
            frm_nxt += 2;
2796
    }
2797
    for (size_t nchar32_t = 0; frm_nxt < frm_end - 1 && nchar32_t < mx; ++nchar32_t)
2798
    {
2799
        uint16_t c1 = static_cast<uint16_t>(frm_nxt[0] << 8 | frm_nxt[1]);
2800
        if ((c1 & 0xFC00) == 0xDC00)
2801
            break;
2802
        if ((c1 & 0xFC00) != 0xD800)
2803
        {
2804
            if (c1 > Maxcode)
2805
                break;
2806
            frm_nxt += 2;
2807
        }
2808
        else
2809
        {
2810
            if (frm_end-frm_nxt < 4)
2811
                break;
2812
            uint16_t c2 = static_cast<uint16_t>(frm_nxt[2] << 8 | frm_nxt[3]);
2813
            if ((c2 & 0xFC00) != 0xDC00)
2814
                break;
2815
            uint32_t t = static_cast<uint32_t>(
2816
                    ((((c1 & 0x03C0) >> 6) + 1) << 16)
2817
                  |   ((c1 & 0x003F) << 10)
2818
                  |    (c2 & 0x03FF));
2819
            if (t > Maxcode)
2820
                break;
2821
            frm_nxt += 4;
2822
        }
2823
    }
2824
    return static_cast<int>(frm_nxt - frm);
2825
}
2826

2827
static
2828
codecvt_base::result
2829
ucs4_to_utf16le(const uint32_t* frm, const uint32_t* frm_end, const uint32_t*& frm_nxt,
2830
                uint8_t* to, uint8_t* to_end, uint8_t*& to_nxt,
2831
                unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = codecvt_mode(0))
2832
{
2833
    frm_nxt = frm;
2834
    to_nxt = to;
2835
    if (mode & generate_header)
2836
    {
2837
        if (to_end - to_nxt < 2)
2838
            return codecvt_base::partial;
2839
        *to_nxt++ = static_cast<uint8_t>(0xFF);
2840
        *to_nxt++ = static_cast<uint8_t>(0xFE);
2841
    }
2842
    for (; frm_nxt < frm_end; ++frm_nxt)
2843
    {
2844
        uint32_t wc = *frm_nxt;
2845
        if ((wc & 0xFFFFF800) == 0x00D800 || wc > Maxcode)
2846
            return codecvt_base::error;
2847
        if (wc < 0x010000)
2848
        {
2849
            if (to_end-to_nxt < 2)
2850
                return codecvt_base::partial;
2851
            *to_nxt++ = static_cast<uint8_t>(wc);
2852
            *to_nxt++ = static_cast<uint8_t>(wc >> 8);
2853
        }
2854
        else
2855
        {
2856
            if (to_end-to_nxt < 4)
2857
                return codecvt_base::partial;
2858
            uint16_t t = static_cast<uint16_t>(
2859
                    0xD800
2860
                  | ((((wc & 0x1F0000) >> 16) - 1) << 6)
2861
                  |   ((wc & 0x00FC00) >> 10));
2862
            *to_nxt++ = static_cast<uint8_t>(t);
2863
            *to_nxt++ = static_cast<uint8_t>(t >> 8);
2864
            t = static_cast<uint16_t>(0xDC00 | (wc & 0x03FF));
2865
            *to_nxt++ = static_cast<uint8_t>(t);
2866
            *to_nxt++ = static_cast<uint8_t>(t >> 8);
2867
        }
2868
    }
2869
    return codecvt_base::ok;
2870
}
2871

2872
static
2873
codecvt_base::result
2874
utf16le_to_ucs4(const uint8_t* frm, const uint8_t* frm_end, const uint8_t*& frm_nxt,
2875
                uint32_t* to, uint32_t* to_end, uint32_t*& to_nxt,
2876
                unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = codecvt_mode(0))
2877
{
2878
    frm_nxt = frm;
2879
    to_nxt = to;
2880
    if (mode & consume_header)
2881
    {
2882
        if (frm_end-frm_nxt >= 2 && frm_nxt[0] == 0xFF && frm_nxt[1] == 0xFE)
2883
            frm_nxt += 2;
2884
    }
2885
    for (; frm_nxt < frm_end - 1 && to_nxt < to_end; ++to_nxt)
2886
    {
2887
        uint16_t c1 = static_cast<uint16_t>(frm_nxt[1] << 8 | frm_nxt[0]);
2888
        if ((c1 & 0xFC00) == 0xDC00)
2889
            return codecvt_base::error;
2890
        if ((c1 & 0xFC00) != 0xD800)
2891
        {
2892
            if (c1 > Maxcode)
2893
                return codecvt_base::error;
2894
            *to_nxt = static_cast<uint32_t>(c1);
2895
            frm_nxt += 2;
2896
        }
2897
        else
2898
        {
2899
            if (frm_end-frm_nxt < 4)
2900
                return codecvt_base::partial;
2901
            uint16_t c2 = static_cast<uint16_t>(frm_nxt[3] << 8 | frm_nxt[2]);
2902
            if ((c2 & 0xFC00) != 0xDC00)
2903
                return codecvt_base::error;
2904
            uint32_t t = static_cast<uint32_t>(
2905
                    ((((c1 & 0x03C0) >> 6) + 1) << 16)
2906
                  |   ((c1 & 0x003F) << 10)
2907
                  |    (c2 & 0x03FF));
2908
            if (t > Maxcode)
2909
                return codecvt_base::error;
2910
            *to_nxt = t;
2911
            frm_nxt += 4;
2912
        }
2913
    }
2914
    return frm_nxt < frm_end ? codecvt_base::partial : codecvt_base::ok;
2915
}
2916

2917
static
2918
int
2919
utf16le_to_ucs4_length(const uint8_t* frm, const uint8_t* frm_end,
2920
                       size_t mx, unsigned long Maxcode = 0x10FFFF,
2921
                       codecvt_mode mode = codecvt_mode(0))
2922
{
2923
    const uint8_t* frm_nxt = frm;
2924
    if (mode & consume_header)
2925
    {
2926
        if (frm_end-frm_nxt >= 2 && frm_nxt[0] == 0xFF && frm_nxt[1] == 0xFE)
2927
            frm_nxt += 2;
2928
    }
2929
    for (size_t nchar32_t = 0; frm_nxt < frm_end - 1 && nchar32_t < mx; ++nchar32_t)
2930
    {
2931
        uint16_t c1 = static_cast<uint16_t>(frm_nxt[1] << 8 | frm_nxt[0]);
2932
        if ((c1 & 0xFC00) == 0xDC00)
2933
            break;
2934
        if ((c1 & 0xFC00) != 0xD800)
2935
        {
2936
            if (c1 > Maxcode)
2937
                break;
2938
            frm_nxt += 2;
2939
        }
2940
        else
2941
        {
2942
            if (frm_end-frm_nxt < 4)
2943
                break;
2944
            uint16_t c2 = static_cast<uint16_t>(frm_nxt[3] << 8 | frm_nxt[2]);
2945
            if ((c2 & 0xFC00) != 0xDC00)
2946
                break;
2947
            uint32_t t = static_cast<uint32_t>(
2948
                    ((((c1 & 0x03C0) >> 6) + 1) << 16)
2949
                  |   ((c1 & 0x003F) << 10)
2950
                  |    (c2 & 0x03FF));
2951
            if (t > Maxcode)
2952
                break;
2953
            frm_nxt += 4;
2954
        }
2955
    }
2956
    return static_cast<int>(frm_nxt - frm);
2957
}
2958

2959
static
2960
codecvt_base::result
2961
ucs2_to_utf16be(const uint16_t* frm, const uint16_t* frm_end, const uint16_t*& frm_nxt,
2962
                uint8_t* to, uint8_t* to_end, uint8_t*& to_nxt,
2963
                unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = codecvt_mode(0))
2964
{
2965
    frm_nxt = frm;
2966
    to_nxt = to;
2967
    if (mode & generate_header)
2968
    {
2969
        if (to_end-to_nxt < 2)
2970
            return codecvt_base::partial;
2971
        *to_nxt++ = static_cast<uint8_t>(0xFE);
2972
        *to_nxt++ = static_cast<uint8_t>(0xFF);
2973
    }
2974
    for (; frm_nxt < frm_end; ++frm_nxt)
2975
    {
2976
        uint16_t wc = *frm_nxt;
2977
        if ((wc & 0xF800) == 0xD800 || wc > Maxcode)
2978
            return codecvt_base::error;
2979
        if (to_end-to_nxt < 2)
2980
            return codecvt_base::partial;
2981
        *to_nxt++ = static_cast<uint8_t>(wc >> 8);
2982
        *to_nxt++ = static_cast<uint8_t>(wc);
2983
    }
2984
    return codecvt_base::ok;
2985
}
2986

2987
static
2988
codecvt_base::result
2989
utf16be_to_ucs2(const uint8_t* frm, const uint8_t* frm_end, const uint8_t*& frm_nxt,
2990
                uint16_t* to, uint16_t* to_end, uint16_t*& to_nxt,
2991
                unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = codecvt_mode(0))
2992
{
2993
    frm_nxt = frm;
2994
    to_nxt = to;
2995
    if (mode & consume_header)
2996
    {
2997
        if (frm_end-frm_nxt >= 2 && frm_nxt[0] == 0xFE && frm_nxt[1] == 0xFF)
2998
            frm_nxt += 2;
2999
    }
3000
    for (; frm_nxt < frm_end - 1 && to_nxt < to_end; ++to_nxt)
3001
    {
3002
        uint16_t c1 = static_cast<uint16_t>(frm_nxt[0] << 8 | frm_nxt[1]);
3003
        if ((c1 & 0xF800) == 0xD800 || c1 > Maxcode)
3004
            return codecvt_base::error;
3005
        *to_nxt = c1;
3006
        frm_nxt += 2;
3007
    }
3008
    return frm_nxt < frm_end ? codecvt_base::partial : codecvt_base::ok;
3009
}
3010

3011
static
3012
int
3013
utf16be_to_ucs2_length(const uint8_t* frm, const uint8_t* frm_end,
3014
                       size_t mx, unsigned long Maxcode = 0x10FFFF,
3015
                       codecvt_mode mode = codecvt_mode(0))
3016
{
3017
    const uint8_t* frm_nxt = frm;
3018
    if (mode & consume_header)
3019
    {
3020
        if (frm_end-frm_nxt >= 2 && frm_nxt[0] == 0xFE && frm_nxt[1] == 0xFF)
3021
            frm_nxt += 2;
3022
    }
3023
    for (size_t nchar16_t = 0; frm_nxt < frm_end - 1 && nchar16_t < mx; ++nchar16_t)
3024
    {
3025
        uint16_t c1 = static_cast<uint16_t>(frm_nxt[0] << 8 | frm_nxt[1]);
3026
        if ((c1 & 0xF800) == 0xD800 || c1 > Maxcode)
3027
            break;
3028
        frm_nxt += 2;
3029
    }
3030
    return static_cast<int>(frm_nxt - frm);
3031
}
3032

3033
static
3034
codecvt_base::result
3035
ucs2_to_utf16le(const uint16_t* frm, const uint16_t* frm_end, const uint16_t*& frm_nxt,
3036
                uint8_t* to, uint8_t* to_end, uint8_t*& to_nxt,
3037
                unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = codecvt_mode(0))
3038
{
3039
    frm_nxt = frm;
3040
    to_nxt = to;
3041
    if (mode & generate_header)
3042
    {
3043
        if (to_end-to_nxt < 2)
3044
            return codecvt_base::partial;
3045
        *to_nxt++ = static_cast<uint8_t>(0xFF);
3046
        *to_nxt++ = static_cast<uint8_t>(0xFE);
3047
    }
3048
    for (; frm_nxt < frm_end; ++frm_nxt)
3049
    {
3050
        uint16_t wc = *frm_nxt;
3051
        if ((wc & 0xF800) == 0xD800 || wc > Maxcode)
3052
            return codecvt_base::error;
3053
        if (to_end-to_nxt < 2)
3054
            return codecvt_base::partial;
3055
        *to_nxt++ = static_cast<uint8_t>(wc);
3056
        *to_nxt++ = static_cast<uint8_t>(wc >> 8);
3057
    }
3058
    return codecvt_base::ok;
3059
}
3060

3061
static
3062
codecvt_base::result
3063
utf16le_to_ucs2(const uint8_t* frm, const uint8_t* frm_end, const uint8_t*& frm_nxt,
3064
                uint16_t* to, uint16_t* to_end, uint16_t*& to_nxt,
3065
                unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = codecvt_mode(0))
3066
{
3067
    frm_nxt = frm;
3068
    to_nxt = to;
3069
    if (mode & consume_header)
3070
    {
3071
        if (frm_end-frm_nxt >= 2 && frm_nxt[0] == 0xFF && frm_nxt[1] == 0xFE)
3072
            frm_nxt += 2;
3073
    }
3074
    for (; frm_nxt < frm_end - 1 && to_nxt < to_end; ++to_nxt)
3075
    {
3076
        uint16_t c1 = static_cast<uint16_t>(frm_nxt[1] << 8 | frm_nxt[0]);
3077
        if ((c1 & 0xF800) == 0xD800 || c1 > Maxcode)
3078
            return codecvt_base::error;
3079
        *to_nxt = c1;
3080
        frm_nxt += 2;
3081
    }
3082
    return frm_nxt < frm_end ? codecvt_base::partial : codecvt_base::ok;
3083
}
3084

3085
static
3086
int
3087
utf16le_to_ucs2_length(const uint8_t* frm, const uint8_t* frm_end,
3088
                       size_t mx, unsigned long Maxcode = 0x10FFFF,
3089
                       codecvt_mode mode = codecvt_mode(0))
3090
{
3091
    const uint8_t* frm_nxt = frm;
3092
    frm_nxt = frm;
3093
    if (mode & consume_header)
3094
    {
3095
        if (frm_end-frm_nxt >= 2 && frm_nxt[0] == 0xFF && frm_nxt[1] == 0xFE)
3096
            frm_nxt += 2;
3097
    }
3098
    for (size_t nchar16_t = 0; frm_nxt < frm_end - 1 && nchar16_t < mx; ++nchar16_t)
3099
    {
3100
        uint16_t c1 = static_cast<uint16_t>(frm_nxt[1] << 8 | frm_nxt[0]);
3101
        if ((c1 & 0xF800) == 0xD800 || c1 > Maxcode)
3102
            break;
3103
        frm_nxt += 2;
3104
    }
3105
    return static_cast<int>(frm_nxt - frm);
3106
}
3107

3108
// template <> class codecvt<char16_t, char, mbstate_t>
3109

3110
locale::id codecvt<char16_t, char, mbstate_t>::id;
3111

3112
codecvt<char16_t, char, mbstate_t>::~codecvt()
3113
{
3114
}
3115

3116
codecvt<char16_t, char, mbstate_t>::result
3117
codecvt<char16_t, char, mbstate_t>::do_out(state_type&,
3118
    const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt,
3119
    extern_type* to, extern_type* to_end, extern_type*& to_nxt) const
3120
{
3121
    const uint16_t* _frm = reinterpret_cast<const uint16_t*>(frm);
3122
    const uint16_t* _frm_end = reinterpret_cast<const uint16_t*>(frm_end);
3123
    const uint16_t* _frm_nxt = _frm;
3124
    uint8_t* _to = reinterpret_cast<uint8_t*>(to);
3125
    uint8_t* _to_end = reinterpret_cast<uint8_t*>(to_end);
3126
    uint8_t* _to_nxt = _to;
3127
    result r = utf16_to_utf8(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt);
3128
    frm_nxt = frm + (_frm_nxt - _frm);
3129
    to_nxt = to + (_to_nxt - _to);
3130
    return r;
3131
}
3132

3133
codecvt<char16_t, char, mbstate_t>::result
3134
codecvt<char16_t, char, mbstate_t>::do_in(state_type&,
3135
    const extern_type* frm, const extern_type* frm_end, const extern_type*& frm_nxt,
3136
    intern_type* to, intern_type* to_end, intern_type*& to_nxt) const
3137
{
3138
    const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
3139
    const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
3140
    const uint8_t* _frm_nxt = _frm;
3141
    uint16_t* _to = reinterpret_cast<uint16_t*>(to);
3142
    uint16_t* _to_end = reinterpret_cast<uint16_t*>(to_end);
3143
    uint16_t* _to_nxt = _to;
3144
    result r = utf8_to_utf16(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt);
3145
    frm_nxt = frm + (_frm_nxt - _frm);
3146
    to_nxt = to + (_to_nxt - _to);
3147
    return r;
3148
}
3149

3150
codecvt<char16_t, char, mbstate_t>::result
3151
codecvt<char16_t, char, mbstate_t>::do_unshift(state_type&,
3152
    extern_type* to, extern_type*, extern_type*& to_nxt) const
3153
{
3154
    to_nxt = to;
3155
    return noconv;
3156
}
3157

3158
int
3159
codecvt<char16_t, char, mbstate_t>::do_encoding() const  _NOEXCEPT
3160
{
3161
    return 0;
3162
}
3163

3164
bool
3165
codecvt<char16_t, char, mbstate_t>::do_always_noconv() const  _NOEXCEPT
3166
{
3167
    return false;
3168
}
3169

3170
int
3171
codecvt<char16_t, char, mbstate_t>::do_length(state_type&,
3172
    const extern_type* frm, const extern_type* frm_end, size_t mx) const
3173
{
3174
    const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
3175
    const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
3176
    return utf8_to_utf16_length(_frm, _frm_end, mx);
3177
}
3178

3179
int
3180
codecvt<char16_t, char, mbstate_t>::do_max_length() const  _NOEXCEPT
3181
{
3182
    return 4;
3183
}
3184

3185
// template <> class codecvt<char32_t, char, mbstate_t>
3186

3187
locale::id codecvt<char32_t, char, mbstate_t>::id;
3188

3189
codecvt<char32_t, char, mbstate_t>::~codecvt()
3190
{
3191
}
3192

3193
codecvt<char32_t, char, mbstate_t>::result
3194
codecvt<char32_t, char, mbstate_t>::do_out(state_type&,
3195
    const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt,
3196
    extern_type* to, extern_type* to_end, extern_type*& to_nxt) const
3197
{
3198
    const uint32_t* _frm = reinterpret_cast<const uint32_t*>(frm);
3199
    const uint32_t* _frm_end = reinterpret_cast<const uint32_t*>(frm_end);
3200
    const uint32_t* _frm_nxt = _frm;
3201
    uint8_t* _to = reinterpret_cast<uint8_t*>(to);
3202
    uint8_t* _to_end = reinterpret_cast<uint8_t*>(to_end);
3203
    uint8_t* _to_nxt = _to;
3204
    result r = ucs4_to_utf8(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt);
3205
    frm_nxt = frm + (_frm_nxt - _frm);
3206
    to_nxt = to + (_to_nxt - _to);
3207
    return r;
3208
}
3209

3210
codecvt<char32_t, char, mbstate_t>::result
3211
codecvt<char32_t, char, mbstate_t>::do_in(state_type&,
3212
    const extern_type* frm, const extern_type* frm_end, const extern_type*& frm_nxt,
3213
    intern_type* to, intern_type* to_end, intern_type*& to_nxt) const
3214
{
3215
    const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
3216
    const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
3217
    const uint8_t* _frm_nxt = _frm;
3218
    uint32_t* _to = reinterpret_cast<uint32_t*>(to);
3219
    uint32_t* _to_end = reinterpret_cast<uint32_t*>(to_end);
3220
    uint32_t* _to_nxt = _to;
3221
    result r = utf8_to_ucs4(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt);
3222
    frm_nxt = frm + (_frm_nxt - _frm);
3223
    to_nxt = to + (_to_nxt - _to);
3224
    return r;
3225
}
3226

3227
codecvt<char32_t, char, mbstate_t>::result
3228
codecvt<char32_t, char, mbstate_t>::do_unshift(state_type&,
3229
    extern_type* to, extern_type*, extern_type*& to_nxt) const
3230
{
3231
    to_nxt = to;
3232
    return noconv;
3233
}
3234

3235
int
3236
codecvt<char32_t, char, mbstate_t>::do_encoding() const  _NOEXCEPT
3237
{
3238
    return 0;
3239
}
3240

3241
bool
3242
codecvt<char32_t, char, mbstate_t>::do_always_noconv() const  _NOEXCEPT
3243
{
3244
    return false;
3245
}
3246

3247
int
3248
codecvt<char32_t, char, mbstate_t>::do_length(state_type&,
3249
    const extern_type* frm, const extern_type* frm_end, size_t mx) const
3250
{
3251
    const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
3252
    const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
3253
    return utf8_to_ucs4_length(_frm, _frm_end, mx);
3254
}
3255

3256
int
3257
codecvt<char32_t, char, mbstate_t>::do_max_length() const  _NOEXCEPT
3258
{
3259
    return 4;
3260
}
3261

3262
// __codecvt_utf8<wchar_t>
3263

3264
__codecvt_utf8<wchar_t>::result
3265
__codecvt_utf8<wchar_t>::do_out(state_type&,
3266
    const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt,
3267
    extern_type* to, extern_type* to_end, extern_type*& to_nxt) const
3268
{
3269
#if defined(_LIBCPP_SHORT_WCHAR)
3270
    const uint16_t* _frm = reinterpret_cast<const uint16_t*>(frm);
3271
    const uint16_t* _frm_end = reinterpret_cast<const uint16_t*>(frm_end);
3272
    const uint16_t* _frm_nxt = _frm;
3273
#else
3274
    const uint32_t* _frm = reinterpret_cast<const uint32_t*>(frm);
3275
    const uint32_t* _frm_end = reinterpret_cast<const uint32_t*>(frm_end);
3276
    const uint32_t* _frm_nxt = _frm;
3277
#endif
3278
    uint8_t* _to = reinterpret_cast<uint8_t*>(to);
3279
    uint8_t* _to_end = reinterpret_cast<uint8_t*>(to_end);
3280
    uint8_t* _to_nxt = _to;
3281
#if defined(_LIBCPP_SHORT_WCHAR)
3282
    result r = ucs2_to_utf8(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
3283
                            _Maxcode_, _Mode_);
3284
#else
3285
    result r = ucs4_to_utf8(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
3286
                            _Maxcode_, _Mode_);
3287
#endif
3288
    frm_nxt = frm + (_frm_nxt - _frm);
3289
    to_nxt = to + (_to_nxt - _to);
3290
    return r;
3291
}
3292

3293
__codecvt_utf8<wchar_t>::result
3294
__codecvt_utf8<wchar_t>::do_in(state_type&,
3295
    const extern_type* frm, const extern_type* frm_end, const extern_type*& frm_nxt,
3296
    intern_type* to, intern_type* to_end, intern_type*& to_nxt) const
3297
{
3298
    const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
3299
    const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
3300
    const uint8_t* _frm_nxt = _frm;
3301
#if defined(_LIBCPP_SHORT_WCHAR)
3302
    uint16_t* _to = reinterpret_cast<uint16_t*>(to);
3303
    uint16_t* _to_end = reinterpret_cast<uint16_t*>(to_end);
3304
    uint16_t* _to_nxt = _to;
3305
    result r = utf8_to_ucs2(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
3306
                            _Maxcode_, _Mode_);
3307
#else
3308
    uint32_t* _to = reinterpret_cast<uint32_t*>(to);
3309
    uint32_t* _to_end = reinterpret_cast<uint32_t*>(to_end);
3310
    uint32_t* _to_nxt = _to;
3311
    result r = utf8_to_ucs4(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
3312
                            _Maxcode_, _Mode_);
3313
#endif
3314
    frm_nxt = frm + (_frm_nxt - _frm);
3315
    to_nxt = to + (_to_nxt - _to);
3316
    return r;
3317
}
3318

3319
__codecvt_utf8<wchar_t>::result
3320
__codecvt_utf8<wchar_t>::do_unshift(state_type&,
3321
    extern_type* to, extern_type*, extern_type*& to_nxt) const
3322
{
3323
    to_nxt = to;
3324
    return noconv;
3325
}
3326

3327
int
3328
__codecvt_utf8<wchar_t>::do_encoding() const  _NOEXCEPT
3329
{
3330
    return 0;
3331
}
3332

3333
bool
3334
__codecvt_utf8<wchar_t>::do_always_noconv() const  _NOEXCEPT
3335
{
3336
    return false;
3337
}
3338

3339
int
3340
__codecvt_utf8<wchar_t>::do_length(state_type&,
3341
    const extern_type* frm, const extern_type* frm_end, size_t mx) const
3342
{
3343
    const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
3344
    const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
3345
    return utf8_to_ucs4_length(_frm, _frm_end, mx, _Maxcode_, _Mode_);
3346
}
3347

3348
int
3349
__codecvt_utf8<wchar_t>::do_max_length() const  _NOEXCEPT
3350
{
3351
    if (_Mode_ & consume_header)
3352
        return 7;
3353
    return 4;
3354
}
3355

3356
// __codecvt_utf8<char16_t>
3357

3358
__codecvt_utf8<char16_t>::result
3359
__codecvt_utf8<char16_t>::do_out(state_type&,
3360
    const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt,
3361
    extern_type* to, extern_type* to_end, extern_type*& to_nxt) const
3362
{
3363
    const uint16_t* _frm = reinterpret_cast<const uint16_t*>(frm);
3364
    const uint16_t* _frm_end = reinterpret_cast<const uint16_t*>(frm_end);
3365
    const uint16_t* _frm_nxt = _frm;
3366
    uint8_t* _to = reinterpret_cast<uint8_t*>(to);
3367
    uint8_t* _to_end = reinterpret_cast<uint8_t*>(to_end);
3368
    uint8_t* _to_nxt = _to;
3369
    result r = ucs2_to_utf8(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
3370
                            _Maxcode_, _Mode_);
3371
    frm_nxt = frm + (_frm_nxt - _frm);
3372
    to_nxt = to + (_to_nxt - _to);
3373
    return r;
3374
}
3375

3376
__codecvt_utf8<char16_t>::result
3377
__codecvt_utf8<char16_t>::do_in(state_type&,
3378
    const extern_type* frm, const extern_type* frm_end, const extern_type*& frm_nxt,
3379
    intern_type* to, intern_type* to_end, intern_type*& to_nxt) const
3380
{
3381
    const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
3382
    const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
3383
    const uint8_t* _frm_nxt = _frm;
3384
    uint16_t* _to = reinterpret_cast<uint16_t*>(to);
3385
    uint16_t* _to_end = reinterpret_cast<uint16_t*>(to_end);
3386
    uint16_t* _to_nxt = _to;
3387
    result r = utf8_to_ucs2(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
3388
                            _Maxcode_, _Mode_);
3389
    frm_nxt = frm + (_frm_nxt - _frm);
3390
    to_nxt = to + (_to_nxt - _to);
3391
    return r;
3392
}
3393

3394
__codecvt_utf8<char16_t>::result
3395
__codecvt_utf8<char16_t>::do_unshift(state_type&,
3396
    extern_type* to, extern_type*, extern_type*& to_nxt) const
3397
{
3398
    to_nxt = to;
3399
    return noconv;
3400
}
3401

3402
int
3403
__codecvt_utf8<char16_t>::do_encoding() const  _NOEXCEPT
3404
{
3405
    return 0;
3406
}
3407

3408
bool
3409
__codecvt_utf8<char16_t>::do_always_noconv() const  _NOEXCEPT
3410
{
3411
    return false;
3412
}
3413

3414
int
3415
__codecvt_utf8<char16_t>::do_length(state_type&,
3416
    const extern_type* frm, const extern_type* frm_end, size_t mx) const
3417
{
3418
    const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
3419
    const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
3420
    return utf8_to_ucs2_length(_frm, _frm_end, mx, _Maxcode_, _Mode_);
3421
}
3422

3423
int
3424
__codecvt_utf8<char16_t>::do_max_length() const  _NOEXCEPT
3425
{
3426
    if (_Mode_ & consume_header)
3427
        return 6;
3428
    return 3;
3429
}
3430

3431
// __codecvt_utf8<char32_t>
3432

3433
__codecvt_utf8<char32_t>::result
3434
__codecvt_utf8<char32_t>::do_out(state_type&,
3435
    const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt,
3436
    extern_type* to, extern_type* to_end, extern_type*& to_nxt) const
3437
{
3438
    const uint32_t* _frm = reinterpret_cast<const uint32_t*>(frm);
3439
    const uint32_t* _frm_end = reinterpret_cast<const uint32_t*>(frm_end);
3440
    const uint32_t* _frm_nxt = _frm;
3441
    uint8_t* _to = reinterpret_cast<uint8_t*>(to);
3442
    uint8_t* _to_end = reinterpret_cast<uint8_t*>(to_end);
3443
    uint8_t* _to_nxt = _to;
3444
    result r = ucs4_to_utf8(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
3445
                            _Maxcode_, _Mode_);
3446
    frm_nxt = frm + (_frm_nxt - _frm);
3447
    to_nxt = to + (_to_nxt - _to);
3448
    return r;
3449
}
3450

3451
__codecvt_utf8<char32_t>::result
3452
__codecvt_utf8<char32_t>::do_in(state_type&,
3453
    const extern_type* frm, const extern_type* frm_end, const extern_type*& frm_nxt,
3454
    intern_type* to, intern_type* to_end, intern_type*& to_nxt) const
3455
{
3456
    const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
3457
    const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
3458
    const uint8_t* _frm_nxt = _frm;
3459
    uint32_t* _to = reinterpret_cast<uint32_t*>(to);
3460
    uint32_t* _to_end = reinterpret_cast<uint32_t*>(to_end);
3461
    uint32_t* _to_nxt = _to;
3462
    result r = utf8_to_ucs4(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
3463
                            _Maxcode_, _Mode_);
3464
    frm_nxt = frm + (_frm_nxt - _frm);
3465
    to_nxt = to + (_to_nxt - _to);
3466
    return r;
3467
}
3468

3469
__codecvt_utf8<char32_t>::result
3470
__codecvt_utf8<char32_t>::do_unshift(state_type&,
3471
    extern_type* to, extern_type*, extern_type*& to_nxt) const
3472
{
3473
    to_nxt = to;
3474
    return noconv;
3475
}
3476

3477
int
3478
__codecvt_utf8<char32_t>::do_encoding() const  _NOEXCEPT
3479
{
3480
    return 0;
3481
}
3482

3483
bool
3484
__codecvt_utf8<char32_t>::do_always_noconv() const  _NOEXCEPT
3485
{
3486
    return false;
3487
}
3488

3489
int
3490
__codecvt_utf8<char32_t>::do_length(state_type&,
3491
    const extern_type* frm, const extern_type* frm_end, size_t mx) const
3492
{
3493
    const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
3494
    const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
3495
    return utf8_to_ucs4_length(_frm, _frm_end, mx, _Maxcode_, _Mode_);
3496
}
3497

3498
int
3499
__codecvt_utf8<char32_t>::do_max_length() const  _NOEXCEPT
3500
{
3501
    if (_Mode_ & consume_header)
3502
        return 7;
3503
    return 4;
3504
}
3505

3506
// __codecvt_utf16<wchar_t, false>
3507

3508
__codecvt_utf16<wchar_t, false>::result
3509
__codecvt_utf16<wchar_t, false>::do_out(state_type&,
3510
    const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt,
3511
    extern_type* to, extern_type* to_end, extern_type*& to_nxt) const
3512
{
3513
    const uint32_t* _frm = reinterpret_cast<const uint32_t*>(frm);
3514
    const uint32_t* _frm_end = reinterpret_cast<const uint32_t*>(frm_end);
3515
    const uint32_t* _frm_nxt = _frm;
3516
    uint8_t* _to = reinterpret_cast<uint8_t*>(to);
3517
    uint8_t* _to_end = reinterpret_cast<uint8_t*>(to_end);
3518
    uint8_t* _to_nxt = _to;
3519
    result r = ucs4_to_utf16be(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
3520
                               _Maxcode_, _Mode_);
3521
    frm_nxt = frm + (_frm_nxt - _frm);
3522
    to_nxt = to + (_to_nxt - _to);
3523
    return r;
3524
}
3525

3526
__codecvt_utf16<wchar_t, false>::result
3527
__codecvt_utf16<wchar_t, false>::do_in(state_type&,
3528
    const extern_type* frm, const extern_type* frm_end, const extern_type*& frm_nxt,
3529
    intern_type* to, intern_type* to_end, intern_type*& to_nxt) const
3530
{
3531
    const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
3532
    const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
3533
    const uint8_t* _frm_nxt = _frm;
3534
    uint32_t* _to = reinterpret_cast<uint32_t*>(to);
3535
    uint32_t* _to_end = reinterpret_cast<uint32_t*>(to_end);
3536
    uint32_t* _to_nxt = _to;
3537
    result r = utf16be_to_ucs4(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
3538
                               _Maxcode_, _Mode_);
3539
    frm_nxt = frm + (_frm_nxt - _frm);
3540
    to_nxt = to + (_to_nxt - _to);
3541
    return r;
3542
}
3543

3544
__codecvt_utf16<wchar_t, false>::result
3545
__codecvt_utf16<wchar_t, false>::do_unshift(state_type&,
3546
    extern_type* to, extern_type*, extern_type*& to_nxt) const
3547
{
3548
    to_nxt = to;
3549
    return noconv;
3550
}
3551

3552
int
3553
__codecvt_utf16<wchar_t, false>::do_encoding() const  _NOEXCEPT
3554
{
3555
    return 0;
3556
}
3557

3558
bool
3559
__codecvt_utf16<wchar_t, false>::do_always_noconv() const  _NOEXCEPT
3560
{
3561
    return false;
3562
}
3563

3564
int
3565
__codecvt_utf16<wchar_t, false>::do_length(state_type&,
3566
    const extern_type* frm, const extern_type* frm_end, size_t mx) const
3567
{
3568
    const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
3569
    const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
3570
    return utf16be_to_ucs4_length(_frm, _frm_end, mx, _Maxcode_, _Mode_);
3571
}
3572

3573
int
3574
__codecvt_utf16<wchar_t, false>::do_max_length() const  _NOEXCEPT
3575
{
3576
    if (_Mode_ & consume_header)
3577
        return 6;
3578
    return 4;
3579
}
3580

3581
// __codecvt_utf16<wchar_t, true>
3582

3583
__codecvt_utf16<wchar_t, true>::result
3584
__codecvt_utf16<wchar_t, true>::do_out(state_type&,
3585
    const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt,
3586
    extern_type* to, extern_type* to_end, extern_type*& to_nxt) const
3587
{
3588
    const uint32_t* _frm = reinterpret_cast<const uint32_t*>(frm);
3589
    const uint32_t* _frm_end = reinterpret_cast<const uint32_t*>(frm_end);
3590
    const uint32_t* _frm_nxt = _frm;
3591
    uint8_t* _to = reinterpret_cast<uint8_t*>(to);
3592
    uint8_t* _to_end = reinterpret_cast<uint8_t*>(to_end);
3593
    uint8_t* _to_nxt = _to;
3594
    result r = ucs4_to_utf16le(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
3595
                               _Maxcode_, _Mode_);
3596
    frm_nxt = frm + (_frm_nxt - _frm);
3597
    to_nxt = to + (_to_nxt - _to);
3598
    return r;
3599
}
3600

3601
__codecvt_utf16<wchar_t, true>::result
3602
__codecvt_utf16<wchar_t, true>::do_in(state_type&,
3603
    const extern_type* frm, const extern_type* frm_end, const extern_type*& frm_nxt,
3604
    intern_type* to, intern_type* to_end, intern_type*& to_nxt) const
3605
{
3606
    const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
3607
    const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
3608
    const uint8_t* _frm_nxt = _frm;
3609
    uint32_t* _to = reinterpret_cast<uint32_t*>(to);
3610
    uint32_t* _to_end = reinterpret_cast<uint32_t*>(to_end);
3611
    uint32_t* _to_nxt = _to;
3612
    result r = utf16le_to_ucs4(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
3613
                               _Maxcode_, _Mode_);
3614
    frm_nxt = frm + (_frm_nxt - _frm);
3615
    to_nxt = to + (_to_nxt - _to);
3616
    return r;
3617
}
3618

3619
__codecvt_utf16<wchar_t, true>::result
3620
__codecvt_utf16<wchar_t, true>::do_unshift(state_type&,
3621
    extern_type* to, extern_type*, extern_type*& to_nxt) const
3622
{
3623
    to_nxt = to;
3624
    return noconv;
3625
}
3626

3627
int
3628
__codecvt_utf16<wchar_t, true>::do_encoding() const  _NOEXCEPT
3629
{
3630
    return 0;
3631
}
3632

3633
bool
3634
__codecvt_utf16<wchar_t, true>::do_always_noconv() const  _NOEXCEPT
3635
{
3636
    return false;
3637
}
3638

3639
int
3640
__codecvt_utf16<wchar_t, true>::do_length(state_type&,
3641
    const extern_type* frm, const extern_type* frm_end, size_t mx) const
3642
{
3643
    const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
3644
    const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
3645
    return utf16le_to_ucs4_length(_frm, _frm_end, mx, _Maxcode_, _Mode_);
3646
}
3647

3648
int
3649
__codecvt_utf16<wchar_t, true>::do_max_length() const  _NOEXCEPT
3650
{
3651
    if (_Mode_ & consume_header)
3652
        return 6;
3653
    return 4;
3654
}
3655

3656
// __codecvt_utf16<char16_t, false>
3657

3658
__codecvt_utf16<char16_t, false>::result
3659
__codecvt_utf16<char16_t, false>::do_out(state_type&,
3660
    const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt,
3661
    extern_type* to, extern_type* to_end, extern_type*& to_nxt) const
3662
{
3663
    const uint16_t* _frm = reinterpret_cast<const uint16_t*>(frm);
3664
    const uint16_t* _frm_end = reinterpret_cast<const uint16_t*>(frm_end);
3665
    const uint16_t* _frm_nxt = _frm;
3666
    uint8_t* _to = reinterpret_cast<uint8_t*>(to);
3667
    uint8_t* _to_end = reinterpret_cast<uint8_t*>(to_end);
3668
    uint8_t* _to_nxt = _to;
3669
    result r = ucs2_to_utf16be(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
3670
                               _Maxcode_, _Mode_);
3671
    frm_nxt = frm + (_frm_nxt - _frm);
3672
    to_nxt = to + (_to_nxt - _to);
3673
    return r;
3674
}
3675

3676
__codecvt_utf16<char16_t, false>::result
3677
__codecvt_utf16<char16_t, false>::do_in(state_type&,
3678
    const extern_type* frm, const extern_type* frm_end, const extern_type*& frm_nxt,
3679
    intern_type* to, intern_type* to_end, intern_type*& to_nxt) const
3680
{
3681
    const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
3682
    const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
3683
    const uint8_t* _frm_nxt = _frm;
3684
    uint16_t* _to = reinterpret_cast<uint16_t*>(to);
3685
    uint16_t* _to_end = reinterpret_cast<uint16_t*>(to_end);
3686
    uint16_t* _to_nxt = _to;
3687
    result r = utf16be_to_ucs2(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
3688
                               _Maxcode_, _Mode_);
3689
    frm_nxt = frm + (_frm_nxt - _frm);
3690
    to_nxt = to + (_to_nxt - _to);
3691
    return r;
3692
}
3693

3694
__codecvt_utf16<char16_t, false>::result
3695
__codecvt_utf16<char16_t, false>::do_unshift(state_type&,
3696
    extern_type* to, extern_type*, extern_type*& to_nxt) const
3697
{
3698
    to_nxt = to;
3699
    return noconv;
3700
}
3701

3702
int
3703
__codecvt_utf16<char16_t, false>::do_encoding() const  _NOEXCEPT
3704
{
3705
    return 0;
3706
}
3707

3708
bool
3709
__codecvt_utf16<char16_t, false>::do_always_noconv() const  _NOEXCEPT
3710
{
3711
    return false;
3712
}
3713

3714
int
3715
__codecvt_utf16<char16_t, false>::do_length(state_type&,
3716
    const extern_type* frm, const extern_type* frm_end, size_t mx) const
3717
{
3718
    const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
3719
    const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
3720
    return utf16be_to_ucs2_length(_frm, _frm_end, mx, _Maxcode_, _Mode_);
3721
}
3722

3723
int
3724
__codecvt_utf16<char16_t, false>::do_max_length() const  _NOEXCEPT
3725
{
3726
    if (_Mode_ & consume_header)
3727
        return 4;
3728
    return 2;
3729
}
3730

3731
// __codecvt_utf16<char16_t, true>
3732

3733
__codecvt_utf16<char16_t, true>::result
3734
__codecvt_utf16<char16_t, true>::do_out(state_type&,
3735
    const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt,
3736
    extern_type* to, extern_type* to_end, extern_type*& to_nxt) const
3737
{
3738
    const uint16_t* _frm = reinterpret_cast<const uint16_t*>(frm);
3739
    const uint16_t* _frm_end = reinterpret_cast<const uint16_t*>(frm_end);
3740
    const uint16_t* _frm_nxt = _frm;
3741
    uint8_t* _to = reinterpret_cast<uint8_t*>(to);
3742
    uint8_t* _to_end = reinterpret_cast<uint8_t*>(to_end);
3743
    uint8_t* _to_nxt = _to;
3744
    result r = ucs2_to_utf16le(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
3745
                               _Maxcode_, _Mode_);
3746
    frm_nxt = frm + (_frm_nxt - _frm);
3747
    to_nxt = to + (_to_nxt - _to);
3748
    return r;
3749
}
3750

3751
__codecvt_utf16<char16_t, true>::result
3752
__codecvt_utf16<char16_t, true>::do_in(state_type&,
3753
    const extern_type* frm, const extern_type* frm_end, const extern_type*& frm_nxt,
3754
    intern_type* to, intern_type* to_end, intern_type*& to_nxt) const
3755
{
3756
    const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
3757
    const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
3758
    const uint8_t* _frm_nxt = _frm;
3759
    uint16_t* _to = reinterpret_cast<uint16_t*>(to);
3760
    uint16_t* _to_end = reinterpret_cast<uint16_t*>(to_end);
3761
    uint16_t* _to_nxt = _to;
3762
    result r = utf16le_to_ucs2(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
3763
                               _Maxcode_, _Mode_);
3764
    frm_nxt = frm + (_frm_nxt - _frm);
3765
    to_nxt = to + (_to_nxt - _to);
3766
    return r;
3767
}
3768

3769
__codecvt_utf16<char16_t, true>::result
3770
__codecvt_utf16<char16_t, true>::do_unshift(state_type&,
3771
    extern_type* to, extern_type*, extern_type*& to_nxt) const
3772
{
3773
    to_nxt = to;
3774
    return noconv;
3775
}
3776

3777
int
3778
__codecvt_utf16<char16_t, true>::do_encoding() const  _NOEXCEPT
3779
{
3780
    return 0;
3781
}
3782

3783
bool
3784
__codecvt_utf16<char16_t, true>::do_always_noconv() const  _NOEXCEPT
3785
{
3786
    return false;
3787
}
3788

3789
int
3790
__codecvt_utf16<char16_t, true>::do_length(state_type&,
3791
    const extern_type* frm, const extern_type* frm_end, size_t mx) const
3792
{
3793
    const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
3794
    const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
3795
    return utf16le_to_ucs2_length(_frm, _frm_end, mx, _Maxcode_, _Mode_);
3796
}
3797

3798
int
3799
__codecvt_utf16<char16_t, true>::do_max_length() const  _NOEXCEPT
3800
{
3801
    if (_Mode_ & consume_header)
3802
        return 4;
3803
    return 2;
3804
}
3805

3806
// __codecvt_utf16<char32_t, false>
3807

3808
__codecvt_utf16<char32_t, false>::result
3809
__codecvt_utf16<char32_t, false>::do_out(state_type&,
3810
    const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt,
3811
    extern_type* to, extern_type* to_end, extern_type*& to_nxt) const
3812
{
3813
    const uint32_t* _frm = reinterpret_cast<const uint32_t*>(frm);
3814
    const uint32_t* _frm_end = reinterpret_cast<const uint32_t*>(frm_end);
3815
    const uint32_t* _frm_nxt = _frm;
3816
    uint8_t* _to = reinterpret_cast<uint8_t*>(to);
3817
    uint8_t* _to_end = reinterpret_cast<uint8_t*>(to_end);
3818
    uint8_t* _to_nxt = _to;
3819
    result r = ucs4_to_utf16be(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
3820
                               _Maxcode_, _Mode_);
3821
    frm_nxt = frm + (_frm_nxt - _frm);
3822
    to_nxt = to + (_to_nxt - _to);
3823
    return r;
3824
}
3825

3826
__codecvt_utf16<char32_t, false>::result
3827
__codecvt_utf16<char32_t, false>::do_in(state_type&,
3828
    const extern_type* frm, const extern_type* frm_end, const extern_type*& frm_nxt,
3829
    intern_type* to, intern_type* to_end, intern_type*& to_nxt) const
3830
{
3831
    const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
3832
    const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
3833
    const uint8_t* _frm_nxt = _frm;
3834
    uint32_t* _to = reinterpret_cast<uint32_t*>(to);
3835
    uint32_t* _to_end = reinterpret_cast<uint32_t*>(to_end);
3836
    uint32_t* _to_nxt = _to;
3837
    result r = utf16be_to_ucs4(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
3838
                               _Maxcode_, _Mode_);
3839
    frm_nxt = frm + (_frm_nxt - _frm);
3840
    to_nxt = to + (_to_nxt - _to);
3841
    return r;
3842
}
3843

3844
__codecvt_utf16<char32_t, false>::result
3845
__codecvt_utf16<char32_t, false>::do_unshift(state_type&,
3846
    extern_type* to, extern_type*, extern_type*& to_nxt) const
3847
{
3848
    to_nxt = to;
3849
    return noconv;
3850
}
3851

3852
int
3853
__codecvt_utf16<char32_t, false>::do_encoding() const  _NOEXCEPT
3854
{
3855
    return 0;
3856
}
3857

3858
bool
3859
__codecvt_utf16<char32_t, false>::do_always_noconv() const  _NOEXCEPT
3860
{
3861
    return false;
3862
}
3863

3864
int
3865
__codecvt_utf16<char32_t, false>::do_length(state_type&,
3866
    const extern_type* frm, const extern_type* frm_end, size_t mx) const
3867
{
3868
    const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
3869
    const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
3870
    return utf16be_to_ucs4_length(_frm, _frm_end, mx, _Maxcode_, _Mode_);
3871
}
3872

3873
int
3874
__codecvt_utf16<char32_t, false>::do_max_length() const  _NOEXCEPT
3875
{
3876
    if (_Mode_ & consume_header)
3877
        return 6;
3878
    return 4;
3879
}
3880

3881
// __codecvt_utf16<char32_t, true>
3882

3883
__codecvt_utf16<char32_t, true>::result
3884
__codecvt_utf16<char32_t, true>::do_out(state_type&,
3885
    const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt,
3886
    extern_type* to, extern_type* to_end, extern_type*& to_nxt) const
3887
{
3888
    const uint32_t* _frm = reinterpret_cast<const uint32_t*>(frm);
3889
    const uint32_t* _frm_end = reinterpret_cast<const uint32_t*>(frm_end);
3890
    const uint32_t* _frm_nxt = _frm;
3891
    uint8_t* _to = reinterpret_cast<uint8_t*>(to);
3892
    uint8_t* _to_end = reinterpret_cast<uint8_t*>(to_end);
3893
    uint8_t* _to_nxt = _to;
3894
    result r = ucs4_to_utf16le(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
3895
                               _Maxcode_, _Mode_);
3896
    frm_nxt = frm + (_frm_nxt - _frm);
3897
    to_nxt = to + (_to_nxt - _to);
3898
    return r;
3899
}
3900

3901
__codecvt_utf16<char32_t, true>::result
3902
__codecvt_utf16<char32_t, true>::do_in(state_type&,
3903
    const extern_type* frm, const extern_type* frm_end, const extern_type*& frm_nxt,
3904
    intern_type* to, intern_type* to_end, intern_type*& to_nxt) const
3905
{
3906
    const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
3907
    const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
3908
    const uint8_t* _frm_nxt = _frm;
3909
    uint32_t* _to = reinterpret_cast<uint32_t*>(to);
3910
    uint32_t* _to_end = reinterpret_cast<uint32_t*>(to_end);
3911
    uint32_t* _to_nxt = _to;
3912
    result r = utf16le_to_ucs4(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
3913
                               _Maxcode_, _Mode_);
3914
    frm_nxt = frm + (_frm_nxt - _frm);
3915
    to_nxt = to + (_to_nxt - _to);
3916
    return r;
3917
}
3918

3919
__codecvt_utf16<char32_t, true>::result
3920
__codecvt_utf16<char32_t, true>::do_unshift(state_type&,
3921
    extern_type* to, extern_type*, extern_type*& to_nxt) const
3922
{
3923
    to_nxt = to;
3924
    return noconv;
3925
}
3926

3927
int
3928
__codecvt_utf16<char32_t, true>::do_encoding() const  _NOEXCEPT
3929
{
3930
    return 0;
3931
}
3932

3933
bool
3934
__codecvt_utf16<char32_t, true>::do_always_noconv() const  _NOEXCEPT
3935
{
3936
    return false;
3937
}
3938

3939
int
3940
__codecvt_utf16<char32_t, true>::do_length(state_type&,
3941
    const extern_type* frm, const extern_type* frm_end, size_t mx) const
3942
{
3943
    const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
3944
    const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
3945
    return utf16le_to_ucs4_length(_frm, _frm_end, mx, _Maxcode_, _Mode_);
3946
}
3947

3948
int
3949
__codecvt_utf16<char32_t, true>::do_max_length() const  _NOEXCEPT
3950
{
3951
    if (_Mode_ & consume_header)
3952
        return 6;
3953
    return 4;
3954
}
3955

3956
// __codecvt_utf8_utf16<wchar_t>
3957

3958
__codecvt_utf8_utf16<wchar_t>::result
3959
__codecvt_utf8_utf16<wchar_t>::do_out(state_type&,
3960
    const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt,
3961
    extern_type* to, extern_type* to_end, extern_type*& to_nxt) const
3962
{
3963
    const uint32_t* _frm = reinterpret_cast<const uint32_t*>(frm);
3964
    const uint32_t* _frm_end = reinterpret_cast<const uint32_t*>(frm_end);
3965
    const uint32_t* _frm_nxt = _frm;
3966
    uint8_t* _to = reinterpret_cast<uint8_t*>(to);
3967
    uint8_t* _to_end = reinterpret_cast<uint8_t*>(to_end);
3968
    uint8_t* _to_nxt = _to;
3969
    result r = utf16_to_utf8(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
3970
                             _Maxcode_, _Mode_);
3971
    frm_nxt = frm + (_frm_nxt - _frm);
3972
    to_nxt = to + (_to_nxt - _to);
3973
    return r;
3974
}
3975

3976
__codecvt_utf8_utf16<wchar_t>::result
3977
__codecvt_utf8_utf16<wchar_t>::do_in(state_type&,
3978
    const extern_type* frm, const extern_type* frm_end, const extern_type*& frm_nxt,
3979
    intern_type* to, intern_type* to_end, intern_type*& to_nxt) const
3980
{
3981
    const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
3982
    const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
3983
    const uint8_t* _frm_nxt = _frm;
3984
    uint32_t* _to = reinterpret_cast<uint32_t*>(to);
3985
    uint32_t* _to_end = reinterpret_cast<uint32_t*>(to_end);
3986
    uint32_t* _to_nxt = _to;
3987
    result r = utf8_to_utf16(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
3988
                             _Maxcode_, _Mode_);
3989
    frm_nxt = frm + (_frm_nxt - _frm);
3990
    to_nxt = to + (_to_nxt - _to);
3991
    return r;
3992
}
3993

3994
__codecvt_utf8_utf16<wchar_t>::result
3995
__codecvt_utf8_utf16<wchar_t>::do_unshift(state_type&,
3996
    extern_type* to, extern_type*, extern_type*& to_nxt) const
3997
{
3998
    to_nxt = to;
3999
    return noconv;
4000
}
4001

4002
int
4003
__codecvt_utf8_utf16<wchar_t>::do_encoding() const  _NOEXCEPT
4004
{
4005
    return 0;
4006
}
4007

4008
bool
4009
__codecvt_utf8_utf16<wchar_t>::do_always_noconv() const  _NOEXCEPT
4010
{
4011
    return false;
4012
}
4013

4014
int
4015
__codecvt_utf8_utf16<wchar_t>::do_length(state_type&,
4016
    const extern_type* frm, const extern_type* frm_end, size_t mx) const
4017
{
4018
    const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
4019
    const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
4020
    return utf8_to_utf16_length(_frm, _frm_end, mx, _Maxcode_, _Mode_);
4021
}
4022

4023
int
4024
__codecvt_utf8_utf16<wchar_t>::do_max_length() const  _NOEXCEPT
4025
{
4026
    if (_Mode_ & consume_header)
4027
        return 7;
4028
    return 4;
4029
}
4030

4031
// __codecvt_utf8_utf16<char16_t>
4032

4033
__codecvt_utf8_utf16<char16_t>::result
4034
__codecvt_utf8_utf16<char16_t>::do_out(state_type&,
4035
    const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt,
4036
    extern_type* to, extern_type* to_end, extern_type*& to_nxt) const
4037
{
4038
    const uint16_t* _frm = reinterpret_cast<const uint16_t*>(frm);
4039
    const uint16_t* _frm_end = reinterpret_cast<const uint16_t*>(frm_end);
4040
    const uint16_t* _frm_nxt = _frm;
4041
    uint8_t* _to = reinterpret_cast<uint8_t*>(to);
4042
    uint8_t* _to_end = reinterpret_cast<uint8_t*>(to_end);
4043
    uint8_t* _to_nxt = _to;
4044
    result r = utf16_to_utf8(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
4045
                             _Maxcode_, _Mode_);
4046
    frm_nxt = frm + (_frm_nxt - _frm);
4047
    to_nxt = to + (_to_nxt - _to);
4048
    return r;
4049
}
4050

4051
__codecvt_utf8_utf16<char16_t>::result
4052
__codecvt_utf8_utf16<char16_t>::do_in(state_type&,
4053
    const extern_type* frm, const extern_type* frm_end, const extern_type*& frm_nxt,
4054
    intern_type* to, intern_type* to_end, intern_type*& to_nxt) const
4055
{
4056
    const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
4057
    const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
4058
    const uint8_t* _frm_nxt = _frm;
4059
    uint16_t* _to = reinterpret_cast<uint16_t*>(to);
4060
    uint16_t* _to_end = reinterpret_cast<uint16_t*>(to_end);
4061
    uint16_t* _to_nxt = _to;
4062
    result r = utf8_to_utf16(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
4063
                             _Maxcode_, _Mode_);
4064
    frm_nxt = frm + (_frm_nxt - _frm);
4065
    to_nxt = to + (_to_nxt - _to);
4066
    return r;
4067
}
4068

4069
__codecvt_utf8_utf16<char16_t>::result
4070
__codecvt_utf8_utf16<char16_t>::do_unshift(state_type&,
4071
    extern_type* to, extern_type*, extern_type*& to_nxt) const
4072
{
4073
    to_nxt = to;
4074
    return noconv;
4075
}
4076

4077
int
4078
__codecvt_utf8_utf16<char16_t>::do_encoding() const  _NOEXCEPT
4079
{
4080
    return 0;
4081
}
4082

4083
bool
4084
__codecvt_utf8_utf16<char16_t>::do_always_noconv() const  _NOEXCEPT
4085
{
4086
    return false;
4087
}
4088

4089
int
4090
__codecvt_utf8_utf16<char16_t>::do_length(state_type&,
4091
    const extern_type* frm, const extern_type* frm_end, size_t mx) const
4092
{
4093
    const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
4094
    const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
4095
    return utf8_to_utf16_length(_frm, _frm_end, mx, _Maxcode_, _Mode_);
4096
}
4097

4098
int
4099
__codecvt_utf8_utf16<char16_t>::do_max_length() const  _NOEXCEPT
4100
{
4101
    if (_Mode_ & consume_header)
4102
        return 7;
4103
    return 4;
4104
}
4105

4106
// __codecvt_utf8_utf16<char32_t>
4107

4108
__codecvt_utf8_utf16<char32_t>::result
4109
__codecvt_utf8_utf16<char32_t>::do_out(state_type&,
4110
    const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt,
4111
    extern_type* to, extern_type* to_end, extern_type*& to_nxt) const
4112
{
4113
    const uint32_t* _frm = reinterpret_cast<const uint32_t*>(frm);
4114
    const uint32_t* _frm_end = reinterpret_cast<const uint32_t*>(frm_end);
4115
    const uint32_t* _frm_nxt = _frm;
4116
    uint8_t* _to = reinterpret_cast<uint8_t*>(to);
4117
    uint8_t* _to_end = reinterpret_cast<uint8_t*>(to_end);
4118
    uint8_t* _to_nxt = _to;
4119
    result r = utf16_to_utf8(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
4120
                             _Maxcode_, _Mode_);
4121
    frm_nxt = frm + (_frm_nxt - _frm);
4122
    to_nxt = to + (_to_nxt - _to);
4123
    return r;
4124
}
4125

4126
__codecvt_utf8_utf16<char32_t>::result
4127
__codecvt_utf8_utf16<char32_t>::do_in(state_type&,
4128
    const extern_type* frm, const extern_type* frm_end, const extern_type*& frm_nxt,
4129
    intern_type* to, intern_type* to_end, intern_type*& to_nxt) const
4130
{
4131
    const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
4132
    const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
4133
    const uint8_t* _frm_nxt = _frm;
4134
    uint32_t* _to = reinterpret_cast<uint32_t*>(to);
4135
    uint32_t* _to_end = reinterpret_cast<uint32_t*>(to_end);
4136
    uint32_t* _to_nxt = _to;
4137
    result r = utf8_to_utf16(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
4138
                             _Maxcode_, _Mode_);
4139
    frm_nxt = frm + (_frm_nxt - _frm);
4140
    to_nxt = to + (_to_nxt - _to);
4141
    return r;
4142
}
4143

4144
__codecvt_utf8_utf16<char32_t>::result
4145
__codecvt_utf8_utf16<char32_t>::do_unshift(state_type&,
4146
    extern_type* to, extern_type*, extern_type*& to_nxt) const
4147
{
4148
    to_nxt = to;
4149
    return noconv;
4150
}
4151

4152
int
4153
__codecvt_utf8_utf16<char32_t>::do_encoding() const  _NOEXCEPT
4154
{
4155
    return 0;
4156
}
4157

4158
bool
4159
__codecvt_utf8_utf16<char32_t>::do_always_noconv() const  _NOEXCEPT
4160
{
4161
    return false;
4162
}
4163

4164
int
4165
__codecvt_utf8_utf16<char32_t>::do_length(state_type&,
4166
    const extern_type* frm, const extern_type* frm_end, size_t mx) const
4167
{
4168
    const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
4169
    const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
4170
    return utf8_to_utf16_length(_frm, _frm_end, mx, _Maxcode_, _Mode_);
4171
}
4172

4173
int
4174
__codecvt_utf8_utf16<char32_t>::do_max_length() const  _NOEXCEPT
4175
{
4176
    if (_Mode_ & consume_header)
4177
        return 7;
4178
    return 4;
4179
}
4180

4181
// __narrow_to_utf8<16>
4182

4183
__narrow_to_utf8<16>::~__narrow_to_utf8()
4184
{
4185
}
4186

4187
// __narrow_to_utf8<32>
4188

4189
__narrow_to_utf8<32>::~__narrow_to_utf8()
4190
{
4191
}
4192

4193
// __widen_from_utf8<16>
4194

4195
__widen_from_utf8<16>::~__widen_from_utf8()
4196
{
4197
}
4198

4199
// __widen_from_utf8<32>
4200

4201
__widen_from_utf8<32>::~__widen_from_utf8()
4202
{
4203
}
4204

4205

4206
static bool checked_string_to_wchar_convert(wchar_t& dest,
4207
                                            const char* ptr,
4208
                                            locale_t loc) {
4209
  if (*ptr == '\0')
4210
    return false;
4211
  mbstate_t mb = {};
4212
  wchar_t out;
4213
  size_t ret = __libcpp_mbrtowc_l(&out, ptr, strlen(ptr), &mb, loc);
4214
  if (ret == static_cast<size_t>(-1) || ret == static_cast<size_t>(-2)) {
4215
    return false;
4216
  }
4217
  dest = out;
4218
  return true;
4219
}
4220

4221
static bool checked_string_to_char_convert(char& dest,
4222
                                           const char* ptr,
4223
                                           locale_t __loc) {
4224
  if (*ptr == '\0')
4225
    return false;
4226
  if (!ptr[1]) {
4227
    dest = *ptr;
4228
    return true;
4229
  }
4230
  // First convert the MBS into a wide char then attempt to narrow it using
4231
  // wctob_l.
4232
  wchar_t wout;
4233
  if (!checked_string_to_wchar_convert(wout, ptr, __loc))
4234
    return false;
4235
  int res;
4236
  if ((res = __libcpp_wctob_l(wout, __loc)) != char_traits<char>::eof()) {
4237
    dest = res;
4238
    return true;
4239
  }
4240
  // FIXME: Work around specific multibyte sequences that we can reasonable
4241
  // translate into a different single byte.
4242
  switch (wout) {
4243
  case L'\u202F': // narrow non-breaking space
4244
  case L'\u00A0': // non-breaking space
4245
    dest = ' ';
4246
    return true;
4247
  default:
4248
    return false;
4249
  }
4250
  _LIBCPP_UNREACHABLE();
4251
}
4252

4253

4254
// numpunct<char> && numpunct<wchar_t>
4255

4256
locale::id numpunct< char  >::id;
4257
locale::id numpunct<wchar_t>::id;
4258

4259
numpunct<char>::numpunct(size_t refs)
4260
    : locale::facet(refs),
4261
      __decimal_point_('.'),
4262
      __thousands_sep_(',')
4263
{
4264
}
4265

4266
numpunct<wchar_t>::numpunct(size_t refs)
4267
    : locale::facet(refs),
4268
      __decimal_point_(L'.'),
4269
      __thousands_sep_(L',')
4270
{
4271
}
4272

4273
numpunct<char>::~numpunct()
4274
{
4275
}
4276

4277
numpunct<wchar_t>::~numpunct()
4278
{
4279
}
4280

4281
 char   numpunct< char  >::do_decimal_point() const {return __decimal_point_;}
4282
wchar_t numpunct<wchar_t>::do_decimal_point() const {return __decimal_point_;}
4283

4284
 char   numpunct< char  >::do_thousands_sep() const {return __thousands_sep_;}
4285
wchar_t numpunct<wchar_t>::do_thousands_sep() const {return __thousands_sep_;}
4286

4287
string numpunct< char  >::do_grouping() const {return __grouping_;}
4288
string numpunct<wchar_t>::do_grouping() const {return __grouping_;}
4289

4290
 string numpunct< char  >::do_truename() const {return "true";}
4291
wstring numpunct<wchar_t>::do_truename() const {return L"true";}
4292

4293
 string numpunct< char  >::do_falsename() const {return "false";}
4294
wstring numpunct<wchar_t>::do_falsename() const {return L"false";}
4295

4296
// numpunct_byname<char>
4297

4298
numpunct_byname<char>::numpunct_byname(const char* nm, size_t refs)
4299
    : numpunct<char>(refs)
4300
{
4301
    __init(nm);
4302
}
4303

4304
numpunct_byname<char>::numpunct_byname(const string& nm, size_t refs)
4305
    : numpunct<char>(refs)
4306
{
4307
    __init(nm.c_str());
4308
}
4309

4310
numpunct_byname<char>::~numpunct_byname()
4311
{
4312
}
4313

4314
void
4315
numpunct_byname<char>::__init(const char* nm)
4316
{
4317
    if (strcmp(nm, "C") != 0)
4318
    {
4319
        __libcpp_unique_locale loc(nm);
4320
        if (!loc)
4321
            __throw_runtime_error("numpunct_byname<char>::numpunct_byname"
4322
                                " failed to construct for " + string(nm));
4323

4324
        lconv* lc = __libcpp_localeconv_l(loc.get());
4325
        checked_string_to_char_convert(__decimal_point_, lc->decimal_point,
4326
                                       loc.get());
4327
        checked_string_to_char_convert(__thousands_sep_, lc->thousands_sep,
4328
                                       loc.get());
4329
        __grouping_ = lc->grouping;
4330
        // localization for truename and falsename is not available
4331
    }
4332
}
4333

4334
// numpunct_byname<wchar_t>
4335

4336
numpunct_byname<wchar_t>::numpunct_byname(const char* nm, size_t refs)
4337
    : numpunct<wchar_t>(refs)
4338
{
4339
    __init(nm);
4340
}
4341

4342
numpunct_byname<wchar_t>::numpunct_byname(const string& nm, size_t refs)
4343
    : numpunct<wchar_t>(refs)
4344
{
4345
    __init(nm.c_str());
4346
}
4347

4348
numpunct_byname<wchar_t>::~numpunct_byname()
4349
{
4350
}
4351

4352
void
4353
numpunct_byname<wchar_t>::__init(const char* nm)
4354
{
4355
    if (strcmp(nm, "C") != 0)
4356
    {
4357
        __libcpp_unique_locale loc(nm);
4358
        if (!loc)
4359
            __throw_runtime_error("numpunct_byname<wchar_t>::numpunct_byname"
4360
                                " failed to construct for " + string(nm));
4361

4362
        lconv* lc = __libcpp_localeconv_l(loc.get());
4363
        checked_string_to_wchar_convert(__decimal_point_, lc->decimal_point,
4364
                                        loc.get());
4365
        checked_string_to_wchar_convert(__thousands_sep_, lc->thousands_sep,
4366
                                        loc.get());
4367
        __grouping_ = lc->grouping;
4368
        // localization for truename and falsename is not available
4369
    }
4370
}
4371

4372
// num_get helpers
4373

4374
int
4375
__num_get_base::__get_base(ios_base& iob)
4376
{
4377
    ios_base::fmtflags __basefield = iob.flags() & ios_base::basefield;
4378
    if (__basefield == ios_base::oct)
4379
        return 8;
4380
    else if (__basefield == ios_base::hex)
4381
        return 16;
4382
    else if (__basefield == 0)
4383
        return 0;
4384
    return 10;
4385
}
4386

4387
const char __num_get_base::__src[33] = "0123456789abcdefABCDEFxX+-pPiInN";
4388

4389
void
4390
__check_grouping(const string& __grouping, unsigned* __g, unsigned* __g_end,
4391
                 ios_base::iostate& __err)
4392
{
4393
    if (__grouping.size() != 0)
4394
    {
4395
        reverse(__g, __g_end);
4396
        const char* __ig = __grouping.data();
4397
        const char* __eg = __ig + __grouping.size();
4398
        for (unsigned* __r = __g; __r < __g_end-1; ++__r)
4399
        {
4400
            if (0 < *__ig && *__ig < numeric_limits<char>::max())
4401
            {
4402
                if (static_cast<unsigned>(*__ig) != *__r)
4403
                {
4404
                    __err = ios_base::failbit;
4405
                    return;
4406
                }
4407
            }
4408
            if (__eg - __ig > 1)
4409
                ++__ig;
4410
        }
4411
        if (0 < *__ig && *__ig < numeric_limits<char>::max())
4412
        {
4413
            if (static_cast<unsigned>(*__ig) < __g_end[-1] || __g_end[-1] == 0)
4414
                __err = ios_base::failbit;
4415
        }
4416
    }
4417
}
4418

4419
void
4420
__num_put_base::__format_int(char* __fmtp, const char* __len, bool __signd,
4421
                             ios_base::fmtflags __flags)
4422
{
4423
    if (__flags & ios_base::showpos)
4424
        *__fmtp++ = '+';
4425
    if (__flags & ios_base::showbase)
4426
        *__fmtp++ = '#';
4427
    while(*__len)
4428
        *__fmtp++ = *__len++;
4429
    if ((__flags & ios_base::basefield) == ios_base::oct)
4430
        *__fmtp = 'o';
4431
    else if ((__flags & ios_base::basefield) == ios_base::hex)
4432
    {
4433
        if (__flags & ios_base::uppercase)
4434
            *__fmtp = 'X';
4435
        else
4436
            *__fmtp = 'x';
4437
    }
4438
    else if (__signd)
4439
        *__fmtp = 'd';
4440
    else
4441
        *__fmtp = 'u';
4442
}
4443

4444
bool
4445
__num_put_base::__format_float(char* __fmtp, const char* __len,
4446
                               ios_base::fmtflags __flags)
4447
{
4448
    bool specify_precision = true;
4449
    if (__flags & ios_base::showpos)
4450
        *__fmtp++ = '+';
4451
    if (__flags & ios_base::showpoint)
4452
        *__fmtp++ = '#';
4453
    ios_base::fmtflags floatfield = __flags & ios_base::floatfield;
4454
    bool uppercase = (__flags & ios_base::uppercase) != 0;
4455
    if (floatfield == (ios_base::fixed | ios_base::scientific))
4456
        specify_precision = false;
4457
    else
4458
    {
4459
        *__fmtp++ = '.';
4460
        *__fmtp++ = '*';
4461
    }
4462
    while(*__len)
4463
        *__fmtp++ = *__len++;
4464
    if (floatfield == ios_base::fixed)
4465
    {
4466
        if (uppercase)
4467
            *__fmtp = 'F';
4468
        else
4469
            *__fmtp = 'f';
4470
    }
4471
    else if (floatfield == ios_base::scientific)
4472
    {
4473
        if (uppercase)
4474
            *__fmtp = 'E';
4475
        else
4476
            *__fmtp = 'e';
4477
    }
4478
    else if (floatfield == (ios_base::fixed | ios_base::scientific))
4479
    {
4480
        if (uppercase)
4481
            *__fmtp = 'A';
4482
        else
4483
            *__fmtp = 'a';
4484
    }
4485
    else
4486
    {
4487
        if (uppercase)
4488
            *__fmtp = 'G';
4489
        else
4490
            *__fmtp = 'g';
4491
    }
4492
    return specify_precision;
4493
}
4494

4495
char*
4496
__num_put_base::__identify_padding(char* __nb, char* __ne,
4497
                                   const ios_base& __iob)
4498
{
4499
    switch (__iob.flags() & ios_base::adjustfield)
4500
    {
4501
    case ios_base::internal:
4502
        if (__nb[0] == '-' || __nb[0] == '+')
4503
            return __nb+1;
4504
        if (__ne - __nb >= 2 && __nb[0] == '0'
4505
                            && (__nb[1] == 'x' || __nb[1] == 'X'))
4506
            return __nb+2;
4507
        break;
4508
    case ios_base::left:
4509
        return __ne;
4510
    case ios_base::right:
4511
    default:
4512
        break;
4513
    }
4514
    return __nb;
4515
}
4516

4517
// time_get
4518

4519
static
4520
string*
4521
init_weeks()
4522
{
4523
    static string weeks[14];
4524
    weeks[0]  = "Sunday";
4525
    weeks[1]  = "Monday";
4526
    weeks[2]  = "Tuesday";
4527
    weeks[3]  = "Wednesday";
4528
    weeks[4]  = "Thursday";
4529
    weeks[5]  = "Friday";
4530
    weeks[6]  = "Saturday";
4531
    weeks[7]  = "Sun";
4532
    weeks[8]  = "Mon";
4533
    weeks[9]  = "Tue";
4534
    weeks[10] = "Wed";
4535
    weeks[11] = "Thu";
4536
    weeks[12] = "Fri";
4537
    weeks[13] = "Sat";
4538
    return weeks;
4539
}
4540

4541
static
4542
wstring*
4543
init_wweeks()
4544
{
4545
    static wstring weeks[14];
4546
    weeks[0]  = L"Sunday";
4547
    weeks[1]  = L"Monday";
4548
    weeks[2]  = L"Tuesday";
4549
    weeks[3]  = L"Wednesday";
4550
    weeks[4]  = L"Thursday";
4551
    weeks[5]  = L"Friday";
4552
    weeks[6]  = L"Saturday";
4553
    weeks[7]  = L"Sun";
4554
    weeks[8]  = L"Mon";
4555
    weeks[9]  = L"Tue";
4556
    weeks[10] = L"Wed";
4557
    weeks[11] = L"Thu";
4558
    weeks[12] = L"Fri";
4559
    weeks[13] = L"Sat";
4560
    return weeks;
4561
}
4562

4563
template <>
4564
const string*
4565
__time_get_c_storage<char>::__weeks() const
4566
{
4567
    static const string* weeks = init_weeks();
4568
    return weeks;
4569
}
4570

4571
template <>
4572
const wstring*
4573
__time_get_c_storage<wchar_t>::__weeks() const
4574
{
4575
    static const wstring* weeks = init_wweeks();
4576
    return weeks;
4577
}
4578

4579
static
4580
string*
4581
init_months()
4582
{
4583
    static string months[24];
4584
    months[0]  = "January";
4585
    months[1]  = "February";
4586
    months[2]  = "March";
4587
    months[3]  = "April";
4588
    months[4]  = "May";
4589
    months[5]  = "June";
4590
    months[6]  = "July";
4591
    months[7]  = "August";
4592
    months[8]  = "September";
4593
    months[9]  = "October";
4594
    months[10] = "November";
4595
    months[11] = "December";
4596
    months[12] = "Jan";
4597
    months[13] = "Feb";
4598
    months[14] = "Mar";
4599
    months[15] = "Apr";
4600
    months[16] = "May";
4601
    months[17] = "Jun";
4602
    months[18] = "Jul";
4603
    months[19] = "Aug";
4604
    months[20] = "Sep";
4605
    months[21] = "Oct";
4606
    months[22] = "Nov";
4607
    months[23] = "Dec";
4608
    return months;
4609
}
4610

4611
static
4612
wstring*
4613
init_wmonths()
4614
{
4615
    static wstring months[24];
4616
    months[0]  = L"January";
4617
    months[1]  = L"February";
4618
    months[2]  = L"March";
4619
    months[3]  = L"April";
4620
    months[4]  = L"May";
4621
    months[5]  = L"June";
4622
    months[6]  = L"July";
4623
    months[7]  = L"August";
4624
    months[8]  = L"September";
4625
    months[9]  = L"October";
4626
    months[10] = L"November";
4627
    months[11] = L"December";
4628
    months[12] = L"Jan";
4629
    months[13] = L"Feb";
4630
    months[14] = L"Mar";
4631
    months[15] = L"Apr";
4632
    months[16] = L"May";
4633
    months[17] = L"Jun";
4634
    months[18] = L"Jul";
4635
    months[19] = L"Aug";
4636
    months[20] = L"Sep";
4637
    months[21] = L"Oct";
4638
    months[22] = L"Nov";
4639
    months[23] = L"Dec";
4640
    return months;
4641
}
4642

4643
template <>
4644
const string*
4645
__time_get_c_storage<char>::__months() const
4646
{
4647
    static const string* months = init_months();
4648
    return months;
4649
}
4650

4651
template <>
4652
const wstring*
4653
__time_get_c_storage<wchar_t>::__months() const
4654
{
4655
    static const wstring* months = init_wmonths();
4656
    return months;
4657
}
4658

4659
static
4660
string*
4661
init_am_pm()
4662
{
4663
    static string am_pm[2];
4664
    am_pm[0]  = "AM";
4665
    am_pm[1]  = "PM";
4666
    return am_pm;
4667
}
4668

4669
static
4670
wstring*
4671
init_wam_pm()
4672
{
4673
    static wstring am_pm[2];
4674
    am_pm[0]  = L"AM";
4675
    am_pm[1]  = L"PM";
4676
    return am_pm;
4677
}
4678

4679
template <>
4680
const string*
4681
__time_get_c_storage<char>::__am_pm() const
4682
{
4683
    static const string* am_pm = init_am_pm();
4684
    return am_pm;
4685
}
4686

4687
template <>
4688
const wstring*
4689
__time_get_c_storage<wchar_t>::__am_pm() const
4690
{
4691
    static const wstring* am_pm = init_wam_pm();
4692
    return am_pm;
4693
}
4694

4695
template <>
4696
const string&
4697
__time_get_c_storage<char>::__x() const
4698
{
4699
    static string s("%m/%d/%y");
4700
    return s;
4701
}
4702

4703
template <>
4704
const wstring&
4705
__time_get_c_storage<wchar_t>::__x() const
4706
{
4707
    static wstring s(L"%m/%d/%y");
4708
    return s;
4709
}
4710

4711
template <>
4712
const string&
4713
__time_get_c_storage<char>::__X() const
4714
{
4715
    static string s("%H:%M:%S");
4716
    return s;
4717
}
4718

4719
template <>
4720
const wstring&
4721
__time_get_c_storage<wchar_t>::__X() const
4722
{
4723
    static wstring s(L"%H:%M:%S");
4724
    return s;
4725
}
4726

4727
template <>
4728
const string&
4729
__time_get_c_storage<char>::__c() const
4730
{
4731
    static string s("%a %b %d %H:%M:%S %Y");
4732
    return s;
4733
}
4734

4735
template <>
4736
const wstring&
4737
__time_get_c_storage<wchar_t>::__c() const
4738
{
4739
    static wstring s(L"%a %b %d %H:%M:%S %Y");
4740
    return s;
4741
}
4742

4743
template <>
4744
const string&
4745
__time_get_c_storage<char>::__r() const
4746
{
4747
    static string s("%I:%M:%S %p");
4748
    return s;
4749
}
4750

4751
template <>
4752
const wstring&
4753
__time_get_c_storage<wchar_t>::__r() const
4754
{
4755
    static wstring s(L"%I:%M:%S %p");
4756
    return s;
4757
}
4758

4759
// time_get_byname
4760

4761
__time_get::__time_get(const char* nm)
4762
    : __loc_(newlocale(LC_ALL_MASK, nm, 0))
4763
{
4764
    if (__loc_ == 0)
4765
        __throw_runtime_error("time_get_byname"
4766
                            " failed to construct for " + string(nm));
4767
}
4768

4769
__time_get::__time_get(const string& nm)
4770
    : __loc_(newlocale(LC_ALL_MASK, nm.c_str(), 0))
4771
{
4772
    if (__loc_ == 0)
4773
        __throw_runtime_error("time_get_byname"
4774
                            " failed to construct for " + nm);
4775
}
4776

4777
__time_get::~__time_get()
4778
{
4779
    freelocale(__loc_);
4780
}
4781
#if defined(__clang__)
4782
#pragma clang diagnostic ignored "-Wmissing-field-initializers"
4783
#endif
4784
#if defined(__GNUG__)
4785
#pragma GCC   diagnostic ignored "-Wmissing-field-initializers"
4786
#endif
4787

4788
template <>
4789
string
4790
__time_get_storage<char>::__analyze(char fmt, const ctype<char>& ct)
4791
{
4792
    tm t = {0};
4793
    t.tm_sec = 59;
4794
    t.tm_min = 55;
4795
    t.tm_hour = 23;
4796
    t.tm_mday = 31;
4797
    t.tm_mon = 11;
4798
    t.tm_year = 161;
4799
    t.tm_wday = 6;
4800
    t.tm_yday = 364;
4801
    t.tm_isdst = -1;
4802
    char buf[100];
4803
    char f[3] = {0};
4804
    f[0] = '%';
4805
    f[1] = fmt;
4806
    size_t n = strftime_l(buf, countof(buf), f, &t, __loc_);
4807
    char* bb = buf;
4808
    char* be = buf + n;
4809
    string result;
4810
    while (bb != be)
4811
    {
4812
        if (ct.is(ctype_base::space, *bb))
4813
        {
4814
            result.push_back(' ');
4815
            for (++bb; bb != be && ct.is(ctype_base::space, *bb); ++bb)
4816
                ;
4817
            continue;
4818
        }
4819
        char* w = bb;
4820
        ios_base::iostate err = ios_base::goodbit;
4821
        ptrdiff_t i = __scan_keyword(w, be, this->__weeks_, this->__weeks_+14,
4822
                               ct, err, false)
4823
                               - this->__weeks_;
4824
        if (i < 14)
4825
        {
4826
            result.push_back('%');
4827
            if (i < 7)
4828
                result.push_back('A');
4829
            else
4830
                result.push_back('a');
4831
            bb = w;
4832
            continue;
4833
        }
4834
        w = bb;
4835
        i = __scan_keyword(w, be, this->__months_, this->__months_+24,
4836
                           ct, err, false)
4837
                           - this->__months_;
4838
        if (i < 24)
4839
        {
4840
            result.push_back('%');
4841
            if (i < 12)
4842
                result.push_back('B');
4843
            else
4844
                result.push_back('b');
4845
            if (fmt == 'x' && ct.is(ctype_base::digit, this->__months_[i][0]))
4846
                result.back() = 'm';
4847
            bb = w;
4848
            continue;
4849
        }
4850
        if (this->__am_pm_[0].size() + this->__am_pm_[1].size() > 0)
4851
        {
4852
            w = bb;
4853
            i = __scan_keyword(w, be, this->__am_pm_, this->__am_pm_+2,
4854
                               ct, err, false) - this->__am_pm_;
4855
            if (i < 2)
4856
            {
4857
                result.push_back('%');
4858
                result.push_back('p');
4859
                bb = w;
4860
                continue;
4861
            }
4862
        }
4863
        w = bb;
4864
        if (ct.is(ctype_base::digit, *bb))
4865
        {
4866
            switch(__get_up_to_n_digits(bb, be, err, ct, 4))
4867
            {
4868
            case 6:
4869
                result.push_back('%');
4870
                result.push_back('w');
4871
                break;
4872
            case 7:
4873
                result.push_back('%');
4874
                result.push_back('u');
4875
                break;
4876
            case 11:
4877
                result.push_back('%');
4878
                result.push_back('I');
4879
                break;
4880
            case 12:
4881
                result.push_back('%');
4882
                result.push_back('m');
4883
                break;
4884
            case 23:
4885
                result.push_back('%');
4886
                result.push_back('H');
4887
                break;
4888
            case 31:
4889
                result.push_back('%');
4890
                result.push_back('d');
4891
                break;
4892
            case 55:
4893
                result.push_back('%');
4894
                result.push_back('M');
4895
                break;
4896
            case 59:
4897
                result.push_back('%');
4898
                result.push_back('S');
4899
                break;
4900
            case 61:
4901
                result.push_back('%');
4902
                result.push_back('y');
4903
                break;
4904
            case 364:
4905
                result.push_back('%');
4906
                result.push_back('j');
4907
                break;
4908
            case 2061:
4909
                result.push_back('%');
4910
                result.push_back('Y');
4911
                break;
4912
            default:
4913
                for (; w != bb; ++w)
4914
                    result.push_back(*w);
4915
                break;
4916
            }
4917
            continue;
4918
        }
4919
        if (*bb == '%')
4920
        {
4921
            result.push_back('%');
4922
            result.push_back('%');
4923
            ++bb;
4924
            continue;
4925
        }
4926
        result.push_back(*bb);
4927
        ++bb;
4928
    }
4929
    return result;
4930
}
4931

4932
#if defined(__clang__)
4933
#pragma clang diagnostic ignored "-Wmissing-braces"
4934
#endif
4935

4936
template <>
4937
wstring
4938
__time_get_storage<wchar_t>::__analyze(char fmt, const ctype<wchar_t>& ct)
4939
{
4940
    tm t = {0};
4941
    t.tm_sec = 59;
4942
    t.tm_min = 55;
4943
    t.tm_hour = 23;
4944
    t.tm_mday = 31;
4945
    t.tm_mon = 11;
4946
    t.tm_year = 161;
4947
    t.tm_wday = 6;
4948
    t.tm_yday = 364;
4949
    t.tm_isdst = -1;
4950
    char buf[100];
4951
    char f[3] = {0};
4952
    f[0] = '%';
4953
    f[1] = fmt;
4954
    strftime_l(buf, countof(buf), f, &t, __loc_);
4955
    wchar_t wbuf[100];
4956
    wchar_t* wbb = wbuf;
4957
    mbstate_t mb = {0};
4958
    const char* bb = buf;
4959
    size_t j = __libcpp_mbsrtowcs_l( wbb, &bb, countof(wbuf), &mb, __loc_);
4960
    if (j == size_t(-1))
4961
        __throw_runtime_error("locale not supported");
4962
    wchar_t* wbe = wbb + j;
4963
    wstring result;
4964
    while (wbb != wbe)
4965
    {
4966
        if (ct.is(ctype_base::space, *wbb))
4967
        {
4968
            result.push_back(L' ');
4969
            for (++wbb; wbb != wbe && ct.is(ctype_base::space, *wbb); ++wbb)
4970
                ;
4971
            continue;
4972
        }
4973
        wchar_t* w = wbb;
4974
        ios_base::iostate err = ios_base::goodbit;
4975
        ptrdiff_t i = __scan_keyword(w, wbe, this->__weeks_, this->__weeks_+14,
4976
                               ct, err, false)
4977
                               - this->__weeks_;
4978
        if (i < 14)
4979
        {
4980
            result.push_back(L'%');
4981
            if (i < 7)
4982
                result.push_back(L'A');
4983
            else
4984
                result.push_back(L'a');
4985
            wbb = w;
4986
            continue;
4987
        }
4988
        w = wbb;
4989
        i = __scan_keyword(w, wbe, this->__months_, this->__months_+24,
4990
                           ct, err, false)
4991
                           - this->__months_;
4992
        if (i < 24)
4993
        {
4994
            result.push_back(L'%');
4995
            if (i < 12)
4996
                result.push_back(L'B');
4997
            else
4998
                result.push_back(L'b');
4999
            if (fmt == 'x' && ct.is(ctype_base::digit, this->__months_[i][0]))
5000
                result.back() = L'm';
5001
            wbb = w;
5002
            continue;
5003
        }
5004
        if (this->__am_pm_[0].size() + this->__am_pm_[1].size() > 0)
5005
        {
5006
            w = wbb;
5007
            i = __scan_keyword(w, wbe, this->__am_pm_, this->__am_pm_+2,
5008
                               ct, err, false) - this->__am_pm_;
5009
            if (i < 2)
5010
            {
5011
                result.push_back(L'%');
5012
                result.push_back(L'p');
5013
                wbb = w;
5014
                continue;
5015
            }
5016
        }
5017
        w = wbb;
5018
        if (ct.is(ctype_base::digit, *wbb))
5019
        {
5020
            switch(__get_up_to_n_digits(wbb, wbe, err, ct, 4))
5021
            {
5022
            case 6:
5023
                result.push_back(L'%');
5024
                result.push_back(L'w');
5025
                break;
5026
            case 7:
5027
                result.push_back(L'%');
5028
                result.push_back(L'u');
5029
                break;
5030
            case 11:
5031
                result.push_back(L'%');
5032
                result.push_back(L'I');
5033
                break;
5034
            case 12:
5035
                result.push_back(L'%');
5036
                result.push_back(L'm');
5037
                break;
5038
            case 23:
5039
                result.push_back(L'%');
5040
                result.push_back(L'H');
5041
                break;
5042
            case 31:
5043
                result.push_back(L'%');
5044
                result.push_back(L'd');
5045
                break;
5046
            case 55:
5047
                result.push_back(L'%');
5048
                result.push_back(L'M');
5049
                break;
5050
            case 59:
5051
                result.push_back(L'%');
5052
                result.push_back(L'S');
5053
                break;
5054
            case 61:
5055
                result.push_back(L'%');
5056
                result.push_back(L'y');
5057
                break;
5058
            case 364:
5059
                result.push_back(L'%');
5060
                result.push_back(L'j');
5061
                break;
5062
            case 2061:
5063
                result.push_back(L'%');
5064
                result.push_back(L'Y');
5065
                break;
5066
            default:
5067
                for (; w != wbb; ++w)
5068
                    result.push_back(*w);
5069
                break;
5070
            }
5071
            continue;
5072
        }
5073
        if (ct.narrow(*wbb, 0) == '%')
5074
        {
5075
            result.push_back(L'%');
5076
            result.push_back(L'%');
5077
            ++wbb;
5078
            continue;
5079
        }
5080
        result.push_back(*wbb);
5081
        ++wbb;
5082
    }
5083
    return result;
5084
}
5085

5086
template <>
5087
void
5088
__time_get_storage<char>::init(const ctype<char>& ct)
5089
{
5090
    tm t = {0};
5091
    char buf[100];
5092
    // __weeks_
5093
    for (int i = 0; i < 7; ++i)
5094
    {
5095
        t.tm_wday = i;
5096
        strftime_l(buf, countof(buf), "%A", &t, __loc_);
5097
        __weeks_[i] = buf;
5098
        strftime_l(buf, countof(buf), "%a", &t, __loc_);
5099
        __weeks_[i+7] = buf;
5100
    }
5101
    // __months_
5102
    for (int i = 0; i < 12; ++i)
5103
    {
5104
        t.tm_mon = i;
5105
        strftime_l(buf, countof(buf), "%B", &t, __loc_);
5106
        __months_[i] = buf;
5107
        strftime_l(buf, countof(buf), "%b", &t, __loc_);
5108
        __months_[i+12] = buf;
5109
    }
5110
    // __am_pm_
5111
    t.tm_hour = 1;
5112
    strftime_l(buf, countof(buf), "%p", &t, __loc_);
5113
    __am_pm_[0] = buf;
5114
    t.tm_hour = 13;
5115
    strftime_l(buf, countof(buf), "%p", &t, __loc_);
5116
    __am_pm_[1] = buf;
5117
    __c_ = __analyze('c', ct);
5118
    __r_ = __analyze('r', ct);
5119
    __x_ = __analyze('x', ct);
5120
    __X_ = __analyze('X', ct);
5121
}
5122

5123
template <>
5124
void
5125
__time_get_storage<wchar_t>::init(const ctype<wchar_t>& ct)
5126
{
5127
    tm t = {0};
5128
    char buf[100];
5129
    wchar_t wbuf[100];
5130
    wchar_t* wbe;
5131
    mbstate_t mb = {0};
5132
    // __weeks_
5133
    for (int i = 0; i < 7; ++i)
5134
    {
5135
        t.tm_wday = i;
5136
        strftime_l(buf, countof(buf), "%A", &t, __loc_);
5137
        mb = mbstate_t();
5138
        const char* bb = buf;
5139
        size_t j = __libcpp_mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, __loc_);
5140
        if (j == size_t(-1))
5141
            __throw_runtime_error("locale not supported");
5142
        wbe = wbuf + j;
5143
        __weeks_[i].assign(wbuf, wbe);
5144
        strftime_l(buf, countof(buf), "%a", &t, __loc_);
5145
        mb = mbstate_t();
5146
        bb = buf;
5147
        j = __libcpp_mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, __loc_);
5148
        if (j == size_t(-1))
5149
            __throw_runtime_error("locale not supported");
5150
        wbe = wbuf + j;
5151
        __weeks_[i+7].assign(wbuf, wbe);
5152
    }
5153
    // __months_
5154
    for (int i = 0; i < 12; ++i)
5155
    {
5156
        t.tm_mon = i;
5157
        strftime_l(buf, countof(buf), "%B", &t, __loc_);
5158
        mb = mbstate_t();
5159
        const char* bb = buf;
5160
        size_t j = __libcpp_mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, __loc_);
5161
        if (j == size_t(-1))
5162
            __throw_runtime_error("locale not supported");
5163
        wbe = wbuf + j;
5164
        __months_[i].assign(wbuf, wbe);
5165
        strftime_l(buf, countof(buf), "%b", &t, __loc_);
5166
        mb = mbstate_t();
5167
        bb = buf;
5168
        j = __libcpp_mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, __loc_);
5169
        if (j == size_t(-1))
5170
            __throw_runtime_error("locale not supported");
5171
        wbe = wbuf + j;
5172
        __months_[i+12].assign(wbuf, wbe);
5173
    }
5174
    // __am_pm_
5175
    t.tm_hour = 1;
5176
    strftime_l(buf, countof(buf), "%p", &t, __loc_);
5177
    mb = mbstate_t();
5178
    const char* bb = buf;
5179
    size_t j = __libcpp_mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, __loc_);
5180
    if (j == size_t(-1))
5181
        __throw_runtime_error("locale not supported");
5182
    wbe = wbuf + j;
5183
    __am_pm_[0].assign(wbuf, wbe);
5184
    t.tm_hour = 13;
5185
    strftime_l(buf, countof(buf), "%p", &t, __loc_);
5186
    mb = mbstate_t();
5187
    bb = buf;
5188
    j = __libcpp_mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, __loc_);
5189
    if (j == size_t(-1))
5190
        __throw_runtime_error("locale not supported");
5191
    wbe = wbuf + j;
5192
    __am_pm_[1].assign(wbuf, wbe);
5193
    __c_ = __analyze('c', ct);
5194
    __r_ = __analyze('r', ct);
5195
    __x_ = __analyze('x', ct);
5196
    __X_ = __analyze('X', ct);
5197
}
5198

5199
template <class CharT>
5200
struct _LIBCPP_HIDDEN __time_get_temp
5201
    : public ctype_byname<CharT>
5202
{
5203
    explicit __time_get_temp(const char* nm)
5204
        : ctype_byname<CharT>(nm, 1) {}
5205
    explicit __time_get_temp(const string& nm)
5206
        : ctype_byname<CharT>(nm, 1) {}
5207
};
5208

5209
template <>
5210
__time_get_storage<char>::__time_get_storage(const char* __nm)
5211
    : __time_get(__nm)
5212
{
5213
    const __time_get_temp<char> ct(__nm);
5214
    init(ct);
5215
}
5216

5217
template <>
5218
__time_get_storage<char>::__time_get_storage(const string& __nm)
5219
    : __time_get(__nm)
5220
{
5221
    const __time_get_temp<char> ct(__nm);
5222
    init(ct);
5223
}
5224

5225
template <>
5226
__time_get_storage<wchar_t>::__time_get_storage(const char* __nm)
5227
    : __time_get(__nm)
5228
{
5229
    const __time_get_temp<wchar_t> ct(__nm);
5230
    init(ct);
5231
}
5232

5233
template <>
5234
__time_get_storage<wchar_t>::__time_get_storage(const string& __nm)
5235
    : __time_get(__nm)
5236
{
5237
    const __time_get_temp<wchar_t> ct(__nm);
5238
    init(ct);
5239
}
5240

5241
template <>
5242
time_base::dateorder
5243
__time_get_storage<char>::__do_date_order() const
5244
{
5245
    unsigned i;
5246
    for (i = 0; i < __x_.size(); ++i)
5247
        if (__x_[i] == '%')
5248
            break;
5249
    ++i;
5250
    switch (__x_[i])
5251
    {
5252
    case 'y':
5253
    case 'Y':
5254
        for (++i; i < __x_.size(); ++i)
5255
            if (__x_[i] == '%')
5256
                break;
5257
        if (i == __x_.size())
5258
            break;
5259
        ++i;
5260
        switch (__x_[i])
5261
        {
5262
        case 'm':
5263
            for (++i; i < __x_.size(); ++i)
5264
                if (__x_[i] == '%')
5265
                    break;
5266
            if (i == __x_.size())
5267
                break;
5268
            ++i;
5269
            if (__x_[i] == 'd')
5270
                return time_base::ymd;
5271
            break;
5272
        case 'd':
5273
            for (++i; i < __x_.size(); ++i)
5274
                if (__x_[i] == '%')
5275
                    break;
5276
            if (i == __x_.size())
5277
                break;
5278
            ++i;
5279
            if (__x_[i] == 'm')
5280
                return time_base::ydm;
5281
            break;
5282
        }
5283
        break;
5284
    case 'm':
5285
        for (++i; i < __x_.size(); ++i)
5286
            if (__x_[i] == '%')
5287
                break;
5288
        if (i == __x_.size())
5289
            break;
5290
        ++i;
5291
        if (__x_[i] == 'd')
5292
        {
5293
            for (++i; i < __x_.size(); ++i)
5294
                if (__x_[i] == '%')
5295
                    break;
5296
            if (i == __x_.size())
5297
                break;
5298
            ++i;
5299
            if (__x_[i] == 'y' || __x_[i] == 'Y')
5300
                return time_base::mdy;
5301
            break;
5302
        }
5303
        break;
5304
    case 'd':
5305
        for (++i; i < __x_.size(); ++i)
5306
            if (__x_[i] == '%')
5307
                break;
5308
        if (i == __x_.size())
5309
            break;
5310
        ++i;
5311
        if (__x_[i] == 'm')
5312
        {
5313
            for (++i; i < __x_.size(); ++i)
5314
                if (__x_[i] == '%')
5315
                    break;
5316
            if (i == __x_.size())
5317
                break;
5318
            ++i;
5319
            if (__x_[i] == 'y' || __x_[i] == 'Y')
5320
                return time_base::dmy;
5321
            break;
5322
        }
5323
        break;
5324
    }
5325
    return time_base::no_order;
5326
}
5327

5328
template <>
5329
time_base::dateorder
5330
__time_get_storage<wchar_t>::__do_date_order() const
5331
{
5332
    unsigned i;
5333
    for (i = 0; i < __x_.size(); ++i)
5334
        if (__x_[i] == L'%')
5335
            break;
5336
    ++i;
5337
    switch (__x_[i])
5338
    {
5339
    case L'y':
5340
    case L'Y':
5341
        for (++i; i < __x_.size(); ++i)
5342
            if (__x_[i] == L'%')
5343
                break;
5344
        if (i == __x_.size())
5345
            break;
5346
        ++i;
5347
        switch (__x_[i])
5348
        {
5349
        case L'm':
5350
            for (++i; i < __x_.size(); ++i)
5351
                if (__x_[i] == L'%')
5352
                    break;
5353
            if (i == __x_.size())
5354
                break;
5355
            ++i;
5356
            if (__x_[i] == L'd')
5357
                return time_base::ymd;
5358
            break;
5359
        case L'd':
5360
            for (++i; i < __x_.size(); ++i)
5361
                if (__x_[i] == L'%')
5362
                    break;
5363
            if (i == __x_.size())
5364
                break;
5365
            ++i;
5366
            if (__x_[i] == L'm')
5367
                return time_base::ydm;
5368
            break;
5369
        }
5370
        break;
5371
    case L'm':
5372
        for (++i; i < __x_.size(); ++i)
5373
            if (__x_[i] == L'%')
5374
                break;
5375
        if (i == __x_.size())
5376
            break;
5377
        ++i;
5378
        if (__x_[i] == L'd')
5379
        {
5380
            for (++i; i < __x_.size(); ++i)
5381
                if (__x_[i] == L'%')
5382
                    break;
5383
            if (i == __x_.size())
5384
                break;
5385
            ++i;
5386
            if (__x_[i] == L'y' || __x_[i] == L'Y')
5387
                return time_base::mdy;
5388
            break;
5389
        }
5390
        break;
5391
    case L'd':
5392
        for (++i; i < __x_.size(); ++i)
5393
            if (__x_[i] == L'%')
5394
                break;
5395
        if (i == __x_.size())
5396
            break;
5397
        ++i;
5398
        if (__x_[i] == L'm')
5399
        {
5400
            for (++i; i < __x_.size(); ++i)
5401
                if (__x_[i] == L'%')
5402
                    break;
5403
            if (i == __x_.size())
5404
                break;
5405
            ++i;
5406
            if (__x_[i] == L'y' || __x_[i] == L'Y')
5407
                return time_base::dmy;
5408
            break;
5409
        }
5410
        break;
5411
    }
5412
    return time_base::no_order;
5413
}
5414

5415
// time_put
5416

5417
__time_put::__time_put(const char* nm)
5418
    : __loc_(newlocale(LC_ALL_MASK, nm, 0))
5419
{
5420
    if (__loc_ == 0)
5421
        __throw_runtime_error("time_put_byname"
5422
                            " failed to construct for " + string(nm));
5423
}
5424

5425
__time_put::__time_put(const string& nm)
5426
    : __loc_(newlocale(LC_ALL_MASK, nm.c_str(), 0))
5427
{
5428
    if (__loc_ == 0)
5429
        __throw_runtime_error("time_put_byname"
5430
                            " failed to construct for " + nm);
5431
}
5432

5433
__time_put::~__time_put()
5434
{
5435
    if (__loc_ != _LIBCPP_GET_C_LOCALE)
5436
        freelocale(__loc_);
5437
}
5438

5439
void
5440
__time_put::__do_put(char* __nb, char*& __ne, const tm* __tm,
5441
                     char __fmt, char __mod) const
5442
{
5443
    char fmt[] = {'%', __fmt, __mod, 0};
5444
    if (__mod != 0)
5445
        swap(fmt[1], fmt[2]);
5446
    size_t n = strftime_l(__nb, countof(__nb, __ne), fmt, __tm, __loc_);
5447
    __ne = __nb + n;
5448
}
5449

5450
void
5451
__time_put::__do_put(wchar_t* __wb, wchar_t*& __we, const tm* __tm,
5452
                     char __fmt, char __mod) const
5453
{
5454
    char __nar[100];
5455
    char* __ne = __nar + 100;
5456
    __do_put(__nar, __ne, __tm, __fmt, __mod);
5457
    mbstate_t mb = {0};
5458
    const char* __nb = __nar;
5459
    size_t j = __libcpp_mbsrtowcs_l(__wb, &__nb, countof(__wb, __we), &mb, __loc_);
5460
    if (j == size_t(-1))
5461
        __throw_runtime_error("locale not supported");
5462
    __we = __wb + j;
5463
}
5464

5465
// moneypunct_byname
5466

5467
template <class charT>
5468
static
5469
void
5470
__init_pat(money_base::pattern& pat, basic_string<charT>& __curr_symbol_,
5471
           bool intl, char cs_precedes, char sep_by_space, char sign_posn,
5472
           charT space_char)
5473
{
5474
    const char sign = static_cast<char>(money_base::sign);
5475
    const char space = static_cast<char>(money_base::space);
5476
    const char none = static_cast<char>(money_base::none);
5477
    const char symbol = static_cast<char>(money_base::symbol);
5478
    const char value = static_cast<char>(money_base::value);
5479
    const bool symbol_contains_sep = intl && __curr_symbol_.size() == 4;
5480

5481
    // Comments on case branches reflect 'C11 7.11.2.1 The localeconv
5482
    // function'. "Space between sign and symbol or value" means that
5483
    // if the sign is adjacent to the symbol, there's a space between
5484
    // them, and otherwise there's a space between the sign and value.
5485
    //
5486
    // C11's localeconv specifies that the fourth character of an
5487
    // international curr_symbol is used to separate the sign and
5488
    // value when sep_by_space says to do so. C++ can't represent
5489
    // that, so we just use a space.  When sep_by_space says to
5490
    // separate the symbol and value-or-sign with a space, we rearrange the
5491
    // curr_symbol to put its spacing character on the correct side of
5492
    // the symbol.
5493
    //
5494
    // We also need to avoid adding an extra space between the sign
5495
    // and value when the currency symbol is suppressed (by not
5496
    // setting showbase).  We match glibc's strfmon by interpreting
5497
    // sep_by_space==1 as "omit the space when the currency symbol is
5498
    // absent".
5499
    //
5500
    // Users who want to get this right should use ICU instead.
5501

5502
    switch (cs_precedes)
5503
    {
5504
    case 0:  // value before curr_symbol
5505
        if (symbol_contains_sep) {
5506
            // Move the separator to before the symbol, to place it
5507
            // between the value and symbol.
5508
            rotate(__curr_symbol_.begin(), __curr_symbol_.begin() + 3,
5509
                   __curr_symbol_.end());
5510
        }
5511
        switch (sign_posn)
5512
        {
5513
        case 0:  // Parentheses surround the quantity and currency symbol.
5514
            pat.field[0] = sign;
5515
            pat.field[1] = value;
5516
            pat.field[2] = none;  // Any space appears in the symbol.
5517
            pat.field[3] = symbol;
5518
            switch (sep_by_space)
5519
            {
5520
            case 0:  // No space separates the currency symbol and value.
5521
                // This case may have changed between C99 and C11;
5522
                // assume the currency symbol matches the intention.
5523
            case 2:  // Space between sign and currency or value.
5524
                // The "sign" is two parentheses, so no space here either.
5525
                return;
5526
            case 1:  // Space between currency-and-sign or currency and value.
5527
                if (!symbol_contains_sep) {
5528
                    // We insert the space into the symbol instead of
5529
                    // setting pat.field[2]=space so that when
5530
                    // showbase is not set, the space goes away too.
5531
                    __curr_symbol_.insert(0, 1, space_char);
5532
                }
5533
                return;
5534
            default:
5535
                break;
5536
            }
5537
            break;
5538
        case 1:  // The sign string precedes the quantity and currency symbol.
5539
            pat.field[0] = sign;
5540
            pat.field[3] = symbol;
5541
            switch (sep_by_space)
5542
            {
5543
            case 0:  // No space separates the currency symbol and value.
5544
                pat.field[1] = value;
5545
                pat.field[2] = none;
5546
                return;
5547
            case 1:  // Space between currency-and-sign or currency and value.
5548
                pat.field[1] = value;
5549
                pat.field[2] = none;
5550
                if (!symbol_contains_sep) {
5551
                    // We insert the space into the symbol instead of
5552
                    // setting pat.field[2]=space so that when
5553
                    // showbase is not set, the space goes away too.
5554
                    __curr_symbol_.insert(0, 1, space_char);
5555
                }
5556
                return;
5557
            case 2:  // Space between sign and currency or value.
5558
                pat.field[1] = space;
5559
                pat.field[2] = value;
5560
                if (symbol_contains_sep) {
5561
                    // Remove the separator from the symbol, since it
5562
                    // has already appeared after the sign.
5563
                    __curr_symbol_.erase(__curr_symbol_.begin());
5564
                }
5565
                return;
5566
            default:
5567
                break;
5568
            }
5569
            break;
5570
        case 2:  // The sign string succeeds the quantity and currency symbol.
5571
            pat.field[0] = value;
5572
            pat.field[3] = sign;
5573
            switch (sep_by_space)
5574
            {
5575
            case 0:  // No space separates the currency symbol and value.
5576
                pat.field[1] = none;
5577
                pat.field[2] = symbol;
5578
                return;
5579
            case 1:  // Space between currency-and-sign or currency and value.
5580
                if (!symbol_contains_sep) {
5581
                    // We insert the space into the symbol instead of
5582
                    // setting pat.field[1]=space so that when
5583
                    // showbase is not set, the space goes away too.
5584
                    __curr_symbol_.insert(0, 1, space_char);
5585
                }
5586
                pat.field[1] = none;
5587
                pat.field[2] = symbol;
5588
                return;
5589
            case 2:  // Space between sign and currency or value.
5590
                pat.field[1] = symbol;
5591
                pat.field[2] = space;
5592
                if (symbol_contains_sep) {
5593
                    // Remove the separator from the symbol, since it
5594
                    // should not be removed if showbase is absent.
5595
                    __curr_symbol_.erase(__curr_symbol_.begin());
5596
                }
5597
                return;
5598
            default:
5599
                break;
5600
            }
5601
            break;
5602
        case 3:  // The sign string immediately precedes the currency symbol.
5603
            pat.field[0] = value;
5604
            pat.field[3] = symbol;
5605
            switch (sep_by_space)
5606
            {
5607
            case 0:  // No space separates the currency symbol and value.
5608
                pat.field[1] = none;
5609
                pat.field[2] = sign;
5610
                return;
5611
            case 1:  // Space between currency-and-sign or currency and value.
5612
                pat.field[1] = space;
5613
                pat.field[2] = sign;
5614
                if (symbol_contains_sep) {
5615
                    // Remove the separator from the symbol, since it
5616
                    // has already appeared before the sign.
5617
                    __curr_symbol_.erase(__curr_symbol_.begin());
5618
                }
5619
                return;
5620
            case 2:  // Space between sign and currency or value.
5621
                pat.field[1] = sign;
5622
                pat.field[2] = none;
5623
                if (!symbol_contains_sep) {
5624
                    // We insert the space into the symbol instead of
5625
                    // setting pat.field[2]=space so that when
5626
                    // showbase is not set, the space goes away too.
5627
                    __curr_symbol_.insert(0, 1, space_char);
5628
                }
5629
                return;
5630
            default:
5631
                break;
5632
            }
5633
            break;
5634
        case 4:  // The sign string immediately succeeds the currency symbol.
5635
            pat.field[0] = value;
5636
            pat.field[3] = sign;
5637
            switch (sep_by_space)
5638
            {
5639
            case 0:  // No space separates the currency symbol and value.
5640
                pat.field[1] = none;
5641
                pat.field[2] = symbol;
5642
                return;
5643
            case 1:  // Space between currency-and-sign or currency and value.
5644
                pat.field[1] = none;
5645
                pat.field[2] = symbol;
5646
                if (!symbol_contains_sep) {
5647
                    // We insert the space into the symbol instead of
5648
                    // setting pat.field[1]=space so that when
5649
                    // showbase is not set, the space goes away too.
5650
                    __curr_symbol_.insert(0, 1, space_char);
5651
                }
5652
                return;
5653
            case 2:  // Space between sign and currency or value.
5654
                pat.field[1] = symbol;
5655
                pat.field[2] = space;
5656
                if (symbol_contains_sep) {
5657
                    // Remove the separator from the symbol, since it
5658
                    // should not disappear when showbase is absent.
5659
                    __curr_symbol_.erase(__curr_symbol_.begin());
5660
                }
5661
                return;
5662
            default:
5663
                break;
5664
            }
5665
            break;
5666
        default:
5667
            break;
5668
        }
5669
        break;
5670
    case 1:  // curr_symbol before value
5671
        switch (sign_posn)
5672
        {
5673
        case 0:  // Parentheses surround the quantity and currency symbol.
5674
            pat.field[0] = sign;
5675
            pat.field[1] = symbol;
5676
            pat.field[2] = none;  // Any space appears in the symbol.
5677
            pat.field[3] = value;
5678
            switch (sep_by_space)
5679
            {
5680
            case 0:  // No space separates the currency symbol and value.
5681
                // This case may have changed between C99 and C11;
5682
                // assume the currency symbol matches the intention.
5683
            case 2:  // Space between sign and currency or value.
5684
                // The "sign" is two parentheses, so no space here either.
5685
                return;
5686
            case 1:  // Space between currency-and-sign or currency and value.
5687
                if (!symbol_contains_sep) {
5688
                    // We insert the space into the symbol instead of
5689
                    // setting pat.field[2]=space so that when
5690
                    // showbase is not set, the space goes away too.
5691
                    __curr_symbol_.insert(0, 1, space_char);
5692
                }
5693
                return;
5694
            default:
5695
                break;
5696
            }
5697
            break;
5698
        case 1:  // The sign string precedes the quantity and currency symbol.
5699
            pat.field[0] = sign;
5700
            pat.field[3] = value;
5701
            switch (sep_by_space)
5702
            {
5703
            case 0:  // No space separates the currency symbol and value.
5704
                pat.field[1] = symbol;
5705
                pat.field[2] = none;
5706
                return;
5707
            case 1:  // Space between currency-and-sign or currency and value.
5708
                pat.field[1] = symbol;
5709
                pat.field[2] = none;
5710
                if (!symbol_contains_sep) {
5711
                    // We insert the space into the symbol instead of
5712
                    // setting pat.field[2]=space so that when
5713
                    // showbase is not set, the space goes away too.
5714
                    __curr_symbol_.push_back(space_char);
5715
                }
5716
                return;
5717
            case 2:  // Space between sign and currency or value.
5718
                pat.field[1] = space;
5719
                pat.field[2] = symbol;
5720
                if (symbol_contains_sep) {
5721
                    // Remove the separator from the symbol, since it
5722
                    // has already appeared after the sign.
5723
                    __curr_symbol_.pop_back();
5724
                }
5725
                return;
5726
            default:
5727
                break;
5728
            }
5729
            break;
5730
        case 2:  // The sign string succeeds the quantity and currency symbol.
5731
            pat.field[0] = symbol;
5732
            pat.field[3] = sign;
5733
            switch (sep_by_space)
5734
            {
5735
            case 0:  // No space separates the currency symbol and value.
5736
                pat.field[1] = none;
5737
                pat.field[2] = value;
5738
                return;
5739
            case 1:  // Space between currency-and-sign or currency and value.
5740
                pat.field[1] = none;
5741
                pat.field[2] = value;
5742
                if (!symbol_contains_sep) {
5743
                    // We insert the space into the symbol instead of
5744
                    // setting pat.field[1]=space so that when
5745
                    // showbase is not set, the space goes away too.
5746
                    __curr_symbol_.push_back(space_char);
5747
                }
5748
                return;
5749
            case 2:  // Space between sign and currency or value.
5750
                pat.field[1] = value;
5751
                pat.field[2] = space;
5752
                if (symbol_contains_sep) {
5753
                    // Remove the separator from the symbol, since it
5754
                    // will appear before the sign.
5755
                    __curr_symbol_.pop_back();
5756
                }
5757
                return;
5758
            default:
5759
                break;
5760
            }
5761
            break;
5762
        case 3:  // The sign string immediately precedes the currency symbol.
5763
            pat.field[0] = sign;
5764
            pat.field[3] = value;
5765
            switch (sep_by_space)
5766
            {
5767
            case 0:  // No space separates the currency symbol and value.
5768
                pat.field[1] = symbol;
5769
                pat.field[2] = none;
5770
                return;
5771
            case 1:  // Space between currency-and-sign or currency and value.
5772
                pat.field[1] = symbol;
5773
                pat.field[2] = none;
5774
                if (!symbol_contains_sep) {
5775
                    // We insert the space into the symbol instead of
5776
                    // setting pat.field[2]=space so that when
5777
                    // showbase is not set, the space goes away too.
5778
                    __curr_symbol_.push_back(space_char);
5779
                }
5780
                return;
5781
            case 2:  // Space between sign and currency or value.
5782
                pat.field[1] = space;
5783
                pat.field[2] = symbol;
5784
                if (symbol_contains_sep) {
5785
                    // Remove the separator from the symbol, since it
5786
                    // has already appeared after the sign.
5787
                    __curr_symbol_.pop_back();
5788
                }
5789
                return;
5790
            default:
5791
                break;
5792
            }
5793
            break;
5794
        case 4:  // The sign string immediately succeeds the currency symbol.
5795
            pat.field[0] = symbol;
5796
            pat.field[3] = value;
5797
            switch (sep_by_space)
5798
            {
5799
            case 0:  // No space separates the currency symbol and value.
5800
                pat.field[1] = sign;
5801
                pat.field[2] = none;
5802
                return;
5803
            case 1:  // Space between currency-and-sign or currency and value.
5804
                pat.field[1] = sign;
5805
                pat.field[2] = space;
5806
                if (symbol_contains_sep) {
5807
                    // Remove the separator from the symbol, since it
5808
                    // should not disappear when showbase is absent.
5809
                    __curr_symbol_.pop_back();
5810
                }
5811
                return;
5812
            case 2:  // Space between sign and currency or value.
5813
                pat.field[1] = none;
5814
                pat.field[2] = sign;
5815
                if (!symbol_contains_sep) {
5816
                    // We insert the space into the symbol instead of
5817
                    // setting pat.field[1]=space so that when
5818
                    // showbase is not set, the space goes away too.
5819
                    __curr_symbol_.push_back(space_char);
5820
                }
5821
                return;
5822
           default:
5823
                break;
5824
            }
5825
            break;
5826
        default:
5827
            break;
5828
        }
5829
        break;
5830
    default:
5831
        break;
5832
    }
5833
    pat.field[0] = symbol;
5834
    pat.field[1] = sign;
5835
    pat.field[2] = none;
5836
    pat.field[3] = value;
5837
}
5838

5839
template<>
5840
void
5841
moneypunct_byname<char, false>::init(const char* nm)
5842
{
5843
    typedef moneypunct<char, false> base;
5844
    __libcpp_unique_locale loc(nm);
5845
    if (!loc)
5846
        __throw_runtime_error("moneypunct_byname"
5847
                            " failed to construct for " + string(nm));
5848

5849
    lconv* lc = __libcpp_localeconv_l(loc.get());
5850
    if (!checked_string_to_char_convert(__decimal_point_,
5851
                                        lc->mon_decimal_point,
5852
                                        loc.get()))
5853
      __decimal_point_ = base::do_decimal_point();
5854
    if (!checked_string_to_char_convert(__thousands_sep_,
5855
                                        lc->mon_thousands_sep,
5856
                                        loc.get()))
5857
      __thousands_sep_ = base::do_thousands_sep();
5858

5859
    __grouping_ = lc->mon_grouping;
5860
    __curr_symbol_ = lc->currency_symbol;
5861
    if (lc->frac_digits != CHAR_MAX)
5862
        __frac_digits_ = lc->frac_digits;
5863
    else
5864
        __frac_digits_ = base::do_frac_digits();
5865
    if (lc->p_sign_posn == 0)
5866
        __positive_sign_ = "()";
5867
    else
5868
        __positive_sign_ = lc->positive_sign;
5869
    if (lc->n_sign_posn == 0)
5870
        __negative_sign_ = "()";
5871
    else
5872
        __negative_sign_ = lc->negative_sign;
5873
    // Assume the positive and negative formats will want spaces in
5874
    // the same places in curr_symbol since there's no way to
5875
    // represent anything else.
5876
    string_type __dummy_curr_symbol = __curr_symbol_;
5877
    __init_pat(__pos_format_, __dummy_curr_symbol, false,
5878
               lc->p_cs_precedes, lc->p_sep_by_space, lc->p_sign_posn, ' ');
5879
    __init_pat(__neg_format_, __curr_symbol_, false,
5880
               lc->n_cs_precedes, lc->n_sep_by_space, lc->n_sign_posn, ' ');
5881
}
5882

5883
template<>
5884
void
5885
moneypunct_byname<char, true>::init(const char* nm)
5886
{
5887
    typedef moneypunct<char, true> base;
5888
    __libcpp_unique_locale loc(nm);
5889
    if (!loc)
5890
        __throw_runtime_error("moneypunct_byname"
5891
                            " failed to construct for " + string(nm));
5892

5893
    lconv* lc = __libcpp_localeconv_l(loc.get());
5894
    if (!checked_string_to_char_convert(__decimal_point_,
5895
                                        lc->mon_decimal_point,
5896
                                        loc.get()))
5897
      __decimal_point_ = base::do_decimal_point();
5898
    if (!checked_string_to_char_convert(__thousands_sep_,
5899
                                        lc->mon_thousands_sep,
5900
                                        loc.get()))
5901
      __thousands_sep_ = base::do_thousands_sep();
5902
    __grouping_ = lc->mon_grouping;
5903
    __curr_symbol_ = lc->int_curr_symbol;
5904
    if (lc->int_frac_digits != CHAR_MAX)
5905
        __frac_digits_ = lc->int_frac_digits;
5906
    else
5907
        __frac_digits_ = base::do_frac_digits();
5908
#if defined(_LIBCPP_MSVCRT) || defined(__MINGW32__)
5909
    if (lc->p_sign_posn == 0)
5910
#else // _LIBCPP_MSVCRT
5911
    if (lc->int_p_sign_posn == 0)
5912
#endif // !_LIBCPP_MSVCRT
5913
        __positive_sign_ = "()";
5914
    else
5915
        __positive_sign_ = lc->positive_sign;
5916
#if defined(_LIBCPP_MSVCRT) || defined(__MINGW32__)
5917
    if(lc->n_sign_posn == 0)
5918
#else // _LIBCPP_MSVCRT
5919
    if (lc->int_n_sign_posn == 0)
5920
#endif // !_LIBCPP_MSVCRT
5921
        __negative_sign_ = "()";
5922
    else
5923
        __negative_sign_ = lc->negative_sign;
5924
    // Assume the positive and negative formats will want spaces in
5925
    // the same places in curr_symbol since there's no way to
5926
    // represent anything else.
5927
    string_type __dummy_curr_symbol = __curr_symbol_;
5928
#if defined(_LIBCPP_MSVCRT) || defined(__MINGW32__)
5929
    __init_pat(__pos_format_, __dummy_curr_symbol, true,
5930
               lc->p_cs_precedes, lc->p_sep_by_space, lc->p_sign_posn, ' ');
5931
    __init_pat(__neg_format_, __curr_symbol_, true,
5932
               lc->n_cs_precedes, lc->n_sep_by_space, lc->n_sign_posn, ' ');
5933
#else // _LIBCPP_MSVCRT
5934
    __init_pat(__pos_format_, __dummy_curr_symbol, true,
5935
               lc->int_p_cs_precedes, lc->int_p_sep_by_space,
5936
               lc->int_p_sign_posn, ' ');
5937
    __init_pat(__neg_format_, __curr_symbol_, true,
5938
               lc->int_n_cs_precedes, lc->int_n_sep_by_space,
5939
               lc->int_n_sign_posn, ' ');
5940
#endif // !_LIBCPP_MSVCRT
5941
}
5942

5943
template<>
5944
void
5945
moneypunct_byname<wchar_t, false>::init(const char* nm)
5946
{
5947
    typedef moneypunct<wchar_t, false> base;
5948
    __libcpp_unique_locale loc(nm);
5949
    if (!loc)
5950
        __throw_runtime_error("moneypunct_byname"
5951
                            " failed to construct for " + string(nm));
5952
    lconv* lc = __libcpp_localeconv_l(loc.get());
5953
    if (!checked_string_to_wchar_convert(__decimal_point_,
5954
                                         lc->mon_decimal_point,
5955
                                         loc.get()))
5956
      __decimal_point_ = base::do_decimal_point();
5957
    if (!checked_string_to_wchar_convert(__thousands_sep_,
5958
                                         lc->mon_thousands_sep,
5959
                                         loc.get()))
5960
      __thousands_sep_ = base::do_thousands_sep();
5961
    __grouping_ = lc->mon_grouping;
5962
    wchar_t wbuf[100];
5963
    mbstate_t mb = {0};
5964
    const char* bb = lc->currency_symbol;
5965
    size_t j = __libcpp_mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, loc.get());
5966
    if (j == size_t(-1))
5967
        __throw_runtime_error("locale not supported");
5968
    wchar_t* wbe = wbuf + j;
5969
    __curr_symbol_.assign(wbuf, wbe);
5970
    if (lc->frac_digits != CHAR_MAX)
5971
        __frac_digits_ = lc->frac_digits;
5972
    else
5973
        __frac_digits_ = base::do_frac_digits();
5974
    if (lc->p_sign_posn == 0)
5975
        __positive_sign_ = L"()";
5976
    else
5977
    {
5978
        mb = mbstate_t();
5979
        bb = lc->positive_sign;
5980
        j = __libcpp_mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, loc.get());
5981
        if (j == size_t(-1))
5982
            __throw_runtime_error("locale not supported");
5983
        wbe = wbuf + j;
5984
        __positive_sign_.assign(wbuf, wbe);
5985
    }
5986
    if (lc->n_sign_posn == 0)
5987
        __negative_sign_ = L"()";
5988
    else
5989
    {
5990
        mb = mbstate_t();
5991
        bb = lc->negative_sign;
5992
        j = __libcpp_mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, loc.get());
5993
        if (j == size_t(-1))
5994
            __throw_runtime_error("locale not supported");
5995
        wbe = wbuf + j;
5996
        __negative_sign_.assign(wbuf, wbe);
5997
    }
5998
    // Assume the positive and negative formats will want spaces in
5999
    // the same places in curr_symbol since there's no way to
6000
    // represent anything else.
6001
    string_type __dummy_curr_symbol = __curr_symbol_;
6002
    __init_pat(__pos_format_, __dummy_curr_symbol, false,
6003
               lc->p_cs_precedes, lc->p_sep_by_space, lc->p_sign_posn, L' ');
6004
    __init_pat(__neg_format_, __curr_symbol_, false,
6005
               lc->n_cs_precedes, lc->n_sep_by_space, lc->n_sign_posn, L' ');
6006
}
6007

6008
template<>
6009
void
6010
moneypunct_byname<wchar_t, true>::init(const char* nm)
6011
{
6012
    typedef moneypunct<wchar_t, true> base;
6013
    __libcpp_unique_locale loc(nm);
6014
    if (!loc)
6015
        __throw_runtime_error("moneypunct_byname"
6016
                            " failed to construct for " + string(nm));
6017

6018
    lconv* lc = __libcpp_localeconv_l(loc.get());
6019
    if (!checked_string_to_wchar_convert(__decimal_point_,
6020
                                         lc->mon_decimal_point,
6021
                                         loc.get()))
6022
      __decimal_point_ = base::do_decimal_point();
6023
    if (!checked_string_to_wchar_convert(__thousands_sep_,
6024
                                         lc->mon_thousands_sep,
6025
                                         loc.get()))
6026
      __thousands_sep_ = base::do_thousands_sep();
6027
    __grouping_ = lc->mon_grouping;
6028
    wchar_t wbuf[100];
6029
    mbstate_t mb = {0};
6030
    const char* bb = lc->int_curr_symbol;
6031
    size_t j = __libcpp_mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, loc.get());
6032
    if (j == size_t(-1))
6033
        __throw_runtime_error("locale not supported");
6034
    wchar_t* wbe = wbuf + j;
6035
    __curr_symbol_.assign(wbuf, wbe);
6036
    if (lc->int_frac_digits != CHAR_MAX)
6037
        __frac_digits_ = lc->int_frac_digits;
6038
    else
6039
        __frac_digits_ = base::do_frac_digits();
6040
#if defined(_LIBCPP_MSVCRT) || defined(__MINGW32__)
6041
    if (lc->p_sign_posn == 0)
6042
#else // _LIBCPP_MSVCRT
6043
    if (lc->int_p_sign_posn == 0)
6044
#endif // !_LIBCPP_MSVCRT
6045
        __positive_sign_ = L"()";
6046
    else
6047
    {
6048
        mb = mbstate_t();
6049
        bb = lc->positive_sign;
6050
        j = __libcpp_mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, loc.get());
6051
        if (j == size_t(-1))
6052
            __throw_runtime_error("locale not supported");
6053
        wbe = wbuf + j;
6054
        __positive_sign_.assign(wbuf, wbe);
6055
    }
6056
#if defined(_LIBCPP_MSVCRT) || defined(__MINGW32__)
6057
    if (lc->n_sign_posn == 0)
6058
#else // _LIBCPP_MSVCRT
6059
    if (lc->int_n_sign_posn == 0)
6060
#endif // !_LIBCPP_MSVCRT
6061
        __negative_sign_ = L"()";
6062
    else
6063
    {
6064
        mb = mbstate_t();
6065
        bb = lc->negative_sign;
6066
        j = __libcpp_mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, loc.get());
6067
        if (j == size_t(-1))
6068
            __throw_runtime_error("locale not supported");
6069
        wbe = wbuf + j;
6070
        __negative_sign_.assign(wbuf, wbe);
6071
    }
6072
    // Assume the positive and negative formats will want spaces in
6073
    // the same places in curr_symbol since there's no way to
6074
    // represent anything else.
6075
    string_type __dummy_curr_symbol = __curr_symbol_;
6076
#if defined(_LIBCPP_MSVCRT) || defined(__MINGW32__)
6077
    __init_pat(__pos_format_, __dummy_curr_symbol, true,
6078
               lc->p_cs_precedes, lc->p_sep_by_space, lc->p_sign_posn, L' ');
6079
    __init_pat(__neg_format_, __curr_symbol_, true,
6080
               lc->n_cs_precedes, lc->n_sep_by_space, lc->n_sign_posn, L' ');
6081
#else // _LIBCPP_MSVCRT
6082
    __init_pat(__pos_format_, __dummy_curr_symbol, true,
6083
               lc->int_p_cs_precedes, lc->int_p_sep_by_space,
6084
               lc->int_p_sign_posn, L' ');
6085
    __init_pat(__neg_format_, __curr_symbol_, true,
6086
               lc->int_n_cs_precedes, lc->int_n_sep_by_space,
6087
               lc->int_n_sign_posn, L' ');
6088
#endif // !_LIBCPP_MSVCRT
6089
}
6090

6091
void __do_nothing(void*) {}
6092

6093
void __throw_runtime_error(const char* msg)
6094
{
6095
#ifndef _LIBCPP_NO_EXCEPTIONS
6096
    throw runtime_error(msg);
6097
#else
6098
    (void)msg;
6099
    _VSTD::abort();
6100
#endif
6101
}
6102

6103
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS collate<char>;
6104
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS collate<wchar_t>;
6105

6106
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS num_get<char>;
6107
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS num_get<wchar_t>;
6108

6109
template struct _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS __num_get<char>;
6110
template struct _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS __num_get<wchar_t>;
6111

6112
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS num_put<char>;
6113
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS num_put<wchar_t>;
6114

6115
template struct _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS __num_put<char>;
6116
template struct _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS __num_put<wchar_t>;
6117

6118
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS time_get<char>;
6119
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS time_get<wchar_t>;
6120

6121
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS time_get_byname<char>;
6122
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS time_get_byname<wchar_t>;
6123

6124
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS time_put<char>;
6125
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS time_put<wchar_t>;
6126

6127
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS time_put_byname<char>;
6128
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS time_put_byname<wchar_t>;
6129

6130
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS moneypunct<char, false>;
6131
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS moneypunct<char, true>;
6132
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS moneypunct<wchar_t, false>;
6133
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS moneypunct<wchar_t, true>;
6134

6135
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS moneypunct_byname<char, false>;
6136
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS moneypunct_byname<char, true>;
6137
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS moneypunct_byname<wchar_t, false>;
6138
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS moneypunct_byname<wchar_t, true>;
6139

6140
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS money_get<char>;
6141
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS money_get<wchar_t>;
6142

6143
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS __money_get<char>;
6144
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS __money_get<wchar_t>;
6145

6146
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS money_put<char>;
6147
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS money_put<wchar_t>;
6148

6149
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS __money_put<char>;
6150
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS __money_put<wchar_t>;
6151

6152
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS messages<char>;
6153
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS messages<wchar_t>;
6154

6155
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS messages_byname<char>;
6156
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS messages_byname<wchar_t>;
6157

6158
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS codecvt_byname<char, char, mbstate_t>;
6159
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS codecvt_byname<wchar_t, char, mbstate_t>;
6160
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS codecvt_byname<char16_t, char, mbstate_t>;
6161
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS codecvt_byname<char32_t, char, mbstate_t>;
6162

6163
_LIBCPP_END_NAMESPACE_STD
6164

6165
Product

Resources

Company
