llvm-project

locale.cpp
5717 строк · 187.7 Кб
Перенос по словам
1
//===----------------------------------------------------------------------===//
2
//
3
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4
// See https://llvm.org/LICENSE.txt for license information.
5
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6
//
7
//===----------------------------------------------------------------------===//
8

9
#include <__utility/no_destroy.h>
10
#include <algorithm>
11
#include <clocale>
12
#include <codecvt>
13
#include <cstddef>
14
#include <cstdio>
15
#include <cstdlib>
16
#include <cstring>
17
#include <locale>
18
#include <new>
19
#include <string>
20
#include <type_traits>
21
#include <typeinfo>
22
#include <utility>
23
#include <vector>
24

25
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
26
#  include <cwctype>
27
#endif
28

29
#if defined(_AIX)
30
#  include <sys/localedef.h> // for __lc_ctype_ptr
31
#endif
32

33
#if defined(_LIBCPP_MSVCRT)
34
#  define _CTYPE_DISABLE_MACROS
35
#endif
36

37
#if !defined(_LIBCPP_MSVCRT) && !defined(__MINGW32__) && !defined(__BIONIC__) && !defined(__NuttX__)
38
#  include <langinfo.h>
39
#endif
40

41
#include "include/atomic_support.h"
42
#include "include/sso_allocator.h"
43

44
// On Linux, wint_t and wchar_t have different signed-ness, and this causes
45
// lots of noise in the build log, but no bugs that I know of.
46
_LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wsign-conversion")
47

48
_LIBCPP_PUSH_MACROS
49
#include <__undef_macros>
50

51
_LIBCPP_BEGIN_NAMESPACE_STD
52

53
struct __libcpp_unique_locale {
54
  __libcpp_unique_locale(const char* nm) : __loc_(newlocale(LC_ALL_MASK, nm, 0)) {}
55

56
  ~__libcpp_unique_locale() {
57
    if (__loc_)
58
      freelocale(__loc_);
59
  }
60

61
  explicit operator bool() const { return __loc_; }
62

63
  locale_t& get() { return __loc_; }
64

65
  locale_t __loc_;
66

67
private:
68
  __libcpp_unique_locale(__libcpp_unique_locale const&);
69
  __libcpp_unique_locale& operator=(__libcpp_unique_locale const&);
70
};
71

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

82
namespace {
83

84
struct releaser {
85
  void operator()(locale::facet* p) { p->__release_shared(); }
86
};
87

88
template <class T, class... Args>
89
T& make(Args... args) {
90
  alignas(T) static std::byte buf[sizeof(T)];
91
  auto* obj = ::new (&buf) T(args...);
92
  return *obj;
93
}
94

95
template <typename T, size_t N>
96
inline constexpr size_t countof(const T (&)[N]) {
97
  return N;
98
}
99

100
template <typename T>
101
inline constexpr size_t countof(const T* const begin, const T* const end) {
102
  return static_cast<size_t>(end - begin);
103
}
104

105
string build_name(const string& other, const string& one, locale::category c) {
106
  if (other == "*" || one == "*")
107
    return "*";
108
  if (c == locale::none || other == one)
109
    return other;
110

111
  // FIXME: Handle the more complicated cases, such as when the locale has
112
  // different names for different categories.
113
  return "*";
114
}
115

116
} // namespace
117

118
const locale::category locale::none;
119
const locale::category locale::collate;
120
const locale::category locale::ctype;
121
const locale::category locale::monetary;
122
const locale::category locale::numeric;
123
const locale::category locale::time;
124
const locale::category locale::messages;
125
const locale::category locale::all;
126

127
class _LIBCPP_HIDDEN locale::__imp : public facet {
128
  enum { N = 30 };
129
  vector<facet*, __sso_allocator<facet*, N> > facets_;
130
  string name_;
131

132
public:
133
  explicit __imp(size_t refs = 0);
134
  explicit __imp(const string& name, size_t refs = 0);
135
  __imp(const __imp&);
136
  __imp(const __imp&, const string&, locale::category c);
137
  __imp(const __imp& other, const __imp& one, locale::category c);
138
  __imp(const __imp&, facet* f, long id);
139
  ~__imp();
140

141
  const string& name() const { return name_; }
142
  bool has_facet(long id) const { return static_cast<size_t>(id) < facets_.size() && facets_[static_cast<size_t>(id)]; }
143
  const locale::facet* use_facet(long id) const;
144

145
  void acquire();
146
  void release();
147
  static __no_destroy<__imp> classic_locale_imp_;
148

149
private:
150
  void install(facet* f, long id);
151
  template <class F>
152
  void install(F* f) {
153
    install(f, f->id.__get());
154
  }
155
  template <class F>
156
  void install_from(const __imp& other);
157
};
158

159
locale::__imp::__imp(size_t refs) : facet(refs), facets_(N), name_("C") {
160
  facets_.clear();
161
  install(&make<std::collate<char> >(1u));
162
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
163
  install(&make<std::collate<wchar_t> >(1u));
164
#endif
165
  install(&make<std::ctype<char> >(nullptr, false, 1u));
166
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
167
  install(&make<std::ctype<wchar_t> >(1u));
168
#endif
169
  install(&make<codecvt<char, char, mbstate_t> >(1u));
170
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
171
  install(&make<codecvt<wchar_t, char, mbstate_t> >(1u));
172
#endif
173
  _LIBCPP_SUPPRESS_DEPRECATED_PUSH
174
  install(&make<codecvt<char16_t, char, mbstate_t> >(1u));
175
  install(&make<codecvt<char32_t, char, mbstate_t> >(1u));
176
  _LIBCPP_SUPPRESS_DEPRECATED_POP
177
#ifndef _LIBCPP_HAS_NO_CHAR8_T
178
  install(&make<codecvt<char16_t, char8_t, mbstate_t> >(1u));
179
  install(&make<codecvt<char32_t, char8_t, mbstate_t> >(1u));
180
#endif
181
  install(&make<numpunct<char> >(1u));
182
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
183
  install(&make<numpunct<wchar_t> >(1u));
184
#endif
185
  install(&make<num_get<char> >(1u));
186
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
187
  install(&make<num_get<wchar_t> >(1u));
188
#endif
189
  install(&make<num_put<char> >(1u));
190
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
191
  install(&make<num_put<wchar_t> >(1u));
192
#endif
193
  install(&make<moneypunct<char, false> >(1u));
194
  install(&make<moneypunct<char, true> >(1u));
195
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
196
  install(&make<moneypunct<wchar_t, false> >(1u));
197
  install(&make<moneypunct<wchar_t, true> >(1u));
198
#endif
199
  install(&make<money_get<char> >(1u));
200
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
201
  install(&make<money_get<wchar_t> >(1u));
202
#endif
203
  install(&make<money_put<char> >(1u));
204
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
205
  install(&make<money_put<wchar_t> >(1u));
206
#endif
207
  install(&make<time_get<char> >(1u));
208
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
209
  install(&make<time_get<wchar_t> >(1u));
210
#endif
211
  install(&make<time_put<char> >(1u));
212
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
213
  install(&make<time_put<wchar_t> >(1u));
214
#endif
215
  install(&make<std::messages<char> >(1u));
216
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
217
  install(&make<std::messages<wchar_t> >(1u));
218
#endif
219
}
220

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

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

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

361
template <class F>
362
inline void locale::__imp::install_from(const locale::__imp& one) {
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), name_(build_name(other.name_, one.name_, c)) {
369
  facets_ = other.facets_;
370
  for (unsigned i = 0; i < facets_.size(); ++i)
371
    if (facets_[i])
372
      facets_[i]->__add_shared();
373
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
374
  try {
375
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
376
    if (c & locale::collate) {
377
      install_from<std::collate<char> >(one);
378
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
379
      install_from<std::collate<wchar_t> >(one);
380
#endif
381
    }
382
    if (c & locale::ctype) {
383
      install_from<std::ctype<char> >(one);
384
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
385
      install_from<std::ctype<wchar_t> >(one);
386
#endif
387
      install_from<std::codecvt<char, char, mbstate_t> >(one);
388
      _LIBCPP_SUPPRESS_DEPRECATED_PUSH
389
      install_from<std::codecvt<char16_t, char, mbstate_t> >(one);
390
      install_from<std::codecvt<char32_t, char, mbstate_t> >(one);
391
      _LIBCPP_SUPPRESS_DEPRECATED_POP
392
#ifndef _LIBCPP_HAS_NO_CHAR8_T
393
      install_from<std::codecvt<char16_t, char8_t, mbstate_t> >(one);
394
      install_from<std::codecvt<char32_t, char8_t, mbstate_t> >(one);
395
#endif
396
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
397
      install_from<std::codecvt<wchar_t, char, mbstate_t> >(one);
398
#endif
399
    }
400
    if (c & locale::monetary) {
401
      install_from<moneypunct<char, false> >(one);
402
      install_from<moneypunct<char, true> >(one);
403
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
404
      install_from<moneypunct<wchar_t, false> >(one);
405
      install_from<moneypunct<wchar_t, true> >(one);
406
#endif
407
      install_from<money_get<char> >(one);
408
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
409
      install_from<money_get<wchar_t> >(one);
410
#endif
411
      install_from<money_put<char> >(one);
412
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
413
      install_from<money_put<wchar_t> >(one);
414
#endif
415
    }
416
    if (c & locale::numeric) {
417
      install_from<numpunct<char> >(one);
418
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
419
      install_from<numpunct<wchar_t> >(one);
420
#endif
421
      install_from<num_get<char> >(one);
422
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
423
      install_from<num_get<wchar_t> >(one);
424
#endif
425
      install_from<num_put<char> >(one);
426
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
427
      install_from<num_put<wchar_t> >(one);
428
#endif
429
    }
430
    if (c & locale::time) {
431
      install_from<time_get<char> >(one);
432
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
433
      install_from<time_get<wchar_t> >(one);
434
#endif
435
      install_from<time_put<char> >(one);
436
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
437
      install_from<time_put<wchar_t> >(one);
438
#endif
439
    }
440
    if (c & locale::messages) {
441
      install_from<std::messages<char> >(one);
442
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
443
      install_from<std::messages<wchar_t> >(one);
444
#endif
445
    }
446
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
447
  } catch (...) {
448
    for (unsigned i = 0; i < facets_.size(); ++i)
449
      if (facets_[i])
450
        facets_[i]->__release_shared();
451
    throw;
452
  }
453
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
454
}
455

456
locale::__imp::__imp(const __imp& other, facet* f, long id)
457
    : facets_(max<size_t>(N, other.facets_.size() + 1)), name_("*") {
458
  f->__add_shared();
459
  unique_ptr<facet, releaser> hold(f);
460
  facets_ = other.facets_;
461
  for (unsigned i = 0; i < other.facets_.size(); ++i)
462
    if (facets_[i])
463
      facets_[i]->__add_shared();
464
  install(hold.get(), id);
465
}
466

467
locale::__imp::~__imp() {
468
  for (unsigned i = 0; i < facets_.size(); ++i)
469
    if (facets_[i])
470
      facets_[i]->__release_shared();
471
}
472

473
void locale::__imp::install(facet* f, long id) {
474
  f->__add_shared();
475
  unique_ptr<facet, releaser> hold(f);
476
  if (static_cast<size_t>(id) >= facets_.size())
477
    facets_.resize(static_cast<size_t>(id + 1));
478
  if (facets_[static_cast<size_t>(id)])
479
    facets_[static_cast<size_t>(id)]->__release_shared();
480
  facets_[static_cast<size_t>(id)] = hold.release();
481
}
482

483
const locale::facet* locale::__imp::use_facet(long id) const {
484
  if (!has_facet(id))
485
    __throw_bad_cast();
486
  return facets_[static_cast<size_t>(id)];
487
}
488

489
// locale
490

491
// We don't do reference counting on the classic locale.
492
// It's never destroyed anyway, but atomic reference counting may be very
493
// expensive in parallel applications. The classic locale is used by default
494
// in all streams. Note: if a new global locale is installed, then we lose
495
// the benefit of no reference counting.
496
constinit __no_destroy<locale::__imp>
497
    locale::__imp::classic_locale_imp_(__uninitialized_tag{}); // initialized below in classic()
498

499
const locale& locale::classic() {
500
  static const __no_destroy<locale> classic_locale(__private_constructor_tag{}, [] {
501
    // executed exactly once on first initialization of `classic_locale`
502
    locale::__imp::classic_locale_imp_.__emplace(1u);
503
    return &locale::__imp::classic_locale_imp_.__get();
504
  }());
505
  return classic_locale.__get();
506
}
507

508
locale& locale::__global() {
509
  static __no_destroy<locale> g(locale::classic());
510
  return g.__get();
511
}
512

513
void locale::__imp::acquire() {
514
  if (this != &locale::__imp::classic_locale_imp_.__get())
515
    __add_shared();
516
}
517

518
void locale::__imp::release() {
519
  if (this != &locale::__imp::classic_locale_imp_.__get())
520
    __release_shared();
521
}
522

523
locale::locale() noexcept : __locale_(__global().__locale_) { __locale_->acquire(); }
524

525
locale::locale(const locale& l) noexcept : __locale_(l.__locale_) { __locale_->acquire(); }
526

527
locale::~locale() { __locale_->release(); }
528

529
const locale& locale::operator=(const locale& other) noexcept {
530
  other.__locale_->acquire();
531
  __locale_->release();
532
  __locale_ = other.__locale_;
533
  return *this;
534
}
535

536
locale::locale(const char* name)
537
    : __locale_(name ? new __imp(name) : (__throw_runtime_error("locale constructed with null"), nullptr)) {
538
  __locale_->acquire();
539
}
540

541
locale::locale(const string& name) : __locale_(new __imp(name)) { __locale_->acquire(); }
542

543
locale::locale(const locale& other, const char* name, category c)
544
    : __locale_(name ? new __imp(*other.__locale_, name, c)
545
                     : (__throw_runtime_error("locale constructed with null"), nullptr)) {
546
  __locale_->acquire();
547
}
548

549
locale::locale(const locale& other, const string& name, category c) : __locale_(new __imp(*other.__locale_, name, c)) {
550
  __locale_->acquire();
551
}
552

553
locale::locale(const locale& other, const locale& one, category c)
554
    : __locale_(new __imp(*other.__locale_, *one.__locale_, c)) {
555
  __locale_->acquire();
556
}
557

558
string locale::name() const { return __locale_->name(); }
559

560
void locale::__install_ctor(const locale& other, facet* f, long facet_id) {
561
  if (f)
562
    __locale_ = new __imp(*other.__locale_, f, facet_id);
563
  else
564
    __locale_ = other.__locale_;
565
  __locale_->acquire();
566
}
567

568
locale locale::global(const locale& loc) {
569
  locale& g = __global();
570
  locale r  = g;
571
  g         = loc;
572
  if (g.name() != "*")
573
    setlocale(LC_ALL, g.name().c_str());
574
  return r;
575
}
576

577
bool locale::has_facet(id& x) const { return __locale_->has_facet(x.__get()); }
578

579
const locale::facet* locale::use_facet(id& x) const { return __locale_->use_facet(x.__get()); }
580

581
bool locale::operator==(const locale& y) const {
582
  return (__locale_ == y.__locale_) || (__locale_->name() != "*" && __locale_->name() == y.__locale_->name());
583
}
584

585
// locale::facet
586

587
locale::facet::~facet() {}
588

589
void locale::facet::__on_zero_shared() noexcept { delete this; }
590

591
// locale::id
592

593
constinit int32_t locale::id::__next_id = 0;
594

595
long locale::id::__get() {
596
  call_once(__flag_, [&] { __id_ = __libcpp_atomic_add(&__next_id, 1); });
597
  return __id_ - 1;
598
}
599

600
// template <> class collate_byname<char>
601

602
collate_byname<char>::collate_byname(const char* n, size_t refs)
603
    : collate<char>(refs), __l_(newlocale(LC_ALL_MASK, n, 0)) {
604
  if (__l_ == 0)
605
    __throw_runtime_error(
606
        ("collate_byname<char>::collate_byname"
607
         " failed to construct for " +
608
         string(n))
609
            .c_str());
610
}
611

612
collate_byname<char>::collate_byname(const string& name, size_t refs)
613
    : collate<char>(refs), __l_(newlocale(LC_ALL_MASK, name.c_str(), 0)) {
614
  if (__l_ == 0)
615
    __throw_runtime_error(
616
        ("collate_byname<char>::collate_byname"
617
         " failed to construct for " +
618
         name)
619
            .c_str());
620
}
621

622
collate_byname<char>::~collate_byname() { freelocale(__l_); }
623

624
int collate_byname<char>::do_compare(
625
    const char_type* __lo1, const char_type* __hi1, const char_type* __lo2, const char_type* __hi2) const {
626
  string_type lhs(__lo1, __hi1);
627
  string_type rhs(__lo2, __hi2);
628
  int r = strcoll_l(lhs.c_str(), rhs.c_str(), __l_);
629
  if (r < 0)
630
    return -1;
631
  if (r > 0)
632
    return 1;
633
  return r;
634
}
635

636
collate_byname<char>::string_type collate_byname<char>::do_transform(const char_type* lo, const char_type* hi) const {
637
  const string_type in(lo, hi);
638
  string_type out(strxfrm_l(0, in.c_str(), 0, __l_), char());
639
  strxfrm_l(const_cast<char*>(out.c_str()), in.c_str(), out.size() + 1, __l_);
640
  return out;
641
}
642

643
// template <> class collate_byname<wchar_t>
644

645
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
646
collate_byname<wchar_t>::collate_byname(const char* n, size_t refs)
647
    : collate<wchar_t>(refs), __l_(newlocale(LC_ALL_MASK, n, 0)) {
648
  if (__l_ == 0)
649
    __throw_runtime_error(
650
        ("collate_byname<wchar_t>::collate_byname(size_t refs)"
651
         " failed to construct for " +
652
         string(n))
653
            .c_str());
654
}
655

656
collate_byname<wchar_t>::collate_byname(const string& name, size_t refs)
657
    : collate<wchar_t>(refs), __l_(newlocale(LC_ALL_MASK, name.c_str(), 0)) {
658
  if (__l_ == 0)
659
    __throw_runtime_error(
660
        ("collate_byname<wchar_t>::collate_byname(size_t refs)"
661
         " failed to construct for " +
662
         name)
663
            .c_str());
664
}
665

666
collate_byname<wchar_t>::~collate_byname() { freelocale(__l_); }
667

668
int collate_byname<wchar_t>::do_compare(
669
    const char_type* __lo1, const char_type* __hi1, const char_type* __lo2, const char_type* __hi2) const {
670
  string_type lhs(__lo1, __hi1);
671
  string_type rhs(__lo2, __hi2);
672
  int r = wcscoll_l(lhs.c_str(), rhs.c_str(), __l_);
673
  if (r < 0)
674
    return -1;
675
  if (r > 0)
676
    return 1;
677
  return r;
678
}
679

680
collate_byname<wchar_t>::string_type
681
collate_byname<wchar_t>::do_transform(const char_type* lo, const char_type* hi) const {
682
  const string_type in(lo, hi);
683
  string_type out(wcsxfrm_l(0, in.c_str(), 0, __l_), wchar_t());
684
  wcsxfrm_l(const_cast<wchar_t*>(out.c_str()), in.c_str(), out.size() + 1, __l_);
685
  return out;
686
}
687
#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
688

689
const ctype_base::mask ctype_base::space;
690
const ctype_base::mask ctype_base::print;
691
const ctype_base::mask ctype_base::cntrl;
692
const ctype_base::mask ctype_base::upper;
693
const ctype_base::mask ctype_base::lower;
694
const ctype_base::mask ctype_base::alpha;
695
const ctype_base::mask ctype_base::digit;
696
const ctype_base::mask ctype_base::punct;
697
const ctype_base::mask ctype_base::xdigit;
698
const ctype_base::mask ctype_base::blank;
699
const ctype_base::mask ctype_base::alnum;
700
const ctype_base::mask ctype_base::graph;
701

702
// template <> class ctype<wchar_t>;
703

704
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
705
constinit locale::id ctype<wchar_t>::id;
706

707
ctype<wchar_t>::~ctype() {}
708

709
bool ctype<wchar_t>::do_is(mask m, char_type c) const {
710
  return isascii(c) ? (ctype<char>::classic_table()[c] & m) != 0 : false;
711
}
712

713
const wchar_t* ctype<wchar_t>::do_is(const char_type* low, const char_type* high, mask* vec) const {
714
  for (; low != high; ++low, ++vec)
715
    *vec = static_cast<mask>(isascii(*low) ? ctype<char>::classic_table()[*low] : 0);
716
  return low;
717
}
718

719
const wchar_t* ctype<wchar_t>::do_scan_is(mask m, const char_type* low, const char_type* high) const {
720
  for (; low != high; ++low)
721
    if (isascii(*low) && (ctype<char>::classic_table()[*low] & m))
722
      break;
723
  return low;
724
}
725

726
const wchar_t* ctype<wchar_t>::do_scan_not(mask m, const char_type* low, const char_type* high) const {
727
  for (; low != high; ++low)
728
    if (!(isascii(*low) && (ctype<char>::classic_table()[*low] & m)))
729
      break;
730
  return low;
731
}
732

733
wchar_t ctype<wchar_t>::do_toupper(char_type c) const {
734
#  ifdef _LIBCPP_HAS_DEFAULTRUNELOCALE
735
  return isascii(c) ? _DefaultRuneLocale.__mapupper[c] : c;
736
#  elif defined(__GLIBC__) || defined(__EMSCRIPTEN__) || defined(__NetBSD__) || defined(__MVS__)
737
  return isascii(c) ? ctype<char>::__classic_upper_table()[c] : c;
738
#  else
739
  return (isascii(c) && iswlower_l(c, _LIBCPP_GET_C_LOCALE)) ? c - L'a' + L'A' : c;
740
#  endif
741
}
742

743
const wchar_t* ctype<wchar_t>::do_toupper(char_type* low, const char_type* high) const {
744
  for (; low != high; ++low)
745
#  ifdef _LIBCPP_HAS_DEFAULTRUNELOCALE
746
    *low = isascii(*low) ? _DefaultRuneLocale.__mapupper[*low] : *low;
747
#  elif defined(__GLIBC__) || defined(__EMSCRIPTEN__) || defined(__NetBSD__) || defined(__MVS__)
748
    *low = isascii(*low) ? ctype<char>::__classic_upper_table()[*low] : *low;
749
#  else
750
    *low = (isascii(*low) && islower_l(*low, _LIBCPP_GET_C_LOCALE)) ? (*low - L'a' + L'A') : *low;
751
#  endif
752
  return low;
753
}
754

755
wchar_t ctype<wchar_t>::do_tolower(char_type c) const {
756
#  ifdef _LIBCPP_HAS_DEFAULTRUNELOCALE
757
  return isascii(c) ? _DefaultRuneLocale.__maplower[c] : c;
758
#  elif defined(__GLIBC__) || defined(__EMSCRIPTEN__) || defined(__NetBSD__) || defined(__MVS__)
759
  return isascii(c) ? ctype<char>::__classic_lower_table()[c] : c;
760
#  else
761
  return (isascii(c) && isupper_l(c, _LIBCPP_GET_C_LOCALE)) ? c - L'A' + 'a' : c;
762
#  endif
763
}
764

765
const wchar_t* ctype<wchar_t>::do_tolower(char_type* low, const char_type* high) const {
766
  for (; low != high; ++low)
767
#  ifdef _LIBCPP_HAS_DEFAULTRUNELOCALE
768
    *low = isascii(*low) ? _DefaultRuneLocale.__maplower[*low] : *low;
769
#  elif defined(__GLIBC__) || defined(__EMSCRIPTEN__) || defined(__NetBSD__) || defined(__MVS__)
770
    *low = isascii(*low) ? ctype<char>::__classic_lower_table()[*low] : *low;
771
#  else
772
    *low = (isascii(*low) && isupper_l(*low, _LIBCPP_GET_C_LOCALE)) ? *low - L'A' + L'a' : *low;
773
#  endif
774
  return low;
775
}
776

777
wchar_t ctype<wchar_t>::do_widen(char c) const { return c; }
778

779
const char* ctype<wchar_t>::do_widen(const char* low, const char* high, char_type* dest) const {
780
  for (; low != high; ++low, ++dest)
781
    *dest = *low;
782
  return low;
783
}
784

785
char ctype<wchar_t>::do_narrow(char_type c, char dfault) const {
786
  if (isascii(c))
787
    return static_cast<char>(c);
788
  return dfault;
789
}
790

791
const wchar_t* ctype<wchar_t>::do_narrow(const char_type* low, const char_type* high, char dfault, char* dest) const {
792
  for (; low != high; ++low, ++dest)
793
    if (isascii(*low))
794
      *dest = static_cast<char>(*low);
795
    else
796
      *dest = dfault;
797
  return low;
798
}
799
#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
800

801
// template <> class ctype<char>;
802

803
constinit locale::id ctype<char>::id;
804

805
const size_t ctype<char>::table_size;
806

807
ctype<char>::ctype(const mask* tab, bool del, size_t refs) : locale::facet(refs), __tab_(tab), __del_(del) {
808
  if (__tab_ == 0)
809
    __tab_ = classic_table();
810
}
811

812
ctype<char>::~ctype() {
813
  if (__tab_ && __del_)
814
    delete[] __tab_;
815
}
816

817
char ctype<char>::do_toupper(char_type c) const {
818
#ifdef _LIBCPP_HAS_DEFAULTRUNELOCALE
819
  return isascii(c) ? static_cast<char>(_DefaultRuneLocale.__mapupper[static_cast<ptrdiff_t>(c)]) : c;
820
#elif defined(__NetBSD__)
821
  return static_cast<char>(__classic_upper_table()[static_cast<unsigned char>(c)]);
822
#elif defined(__GLIBC__) || defined(__EMSCRIPTEN__) || defined(__MVS__)
823
  return isascii(c) ? static_cast<char>(__classic_upper_table()[static_cast<unsigned char>(c)]) : c;
824
#else
825
  return (isascii(c) && islower_l(c, _LIBCPP_GET_C_LOCALE)) ? c - 'a' + 'A' : c;
826
#endif
827
}
828

829
const char* ctype<char>::do_toupper(char_type* low, const char_type* high) const {
830
  for (; low != high; ++low)
831
#ifdef _LIBCPP_HAS_DEFAULTRUNELOCALE
832
    *low = isascii(*low) ? static_cast<char>(_DefaultRuneLocale.__mapupper[static_cast<ptrdiff_t>(*low)]) : *low;
833
#elif defined(__NetBSD__)
834
    *low = static_cast<char>(__classic_upper_table()[static_cast<unsigned char>(*low)]);
835
#elif defined(__GLIBC__) || defined(__EMSCRIPTEN__) || defined(__MVS__)
836
    *low = isascii(*low) ? static_cast<char>(__classic_upper_table()[static_cast<size_t>(*low)]) : *low;
837
#else
838
    *low = (isascii(*low) && islower_l(*low, _LIBCPP_GET_C_LOCALE)) ? *low - 'a' + 'A' : *low;
839
#endif
840
  return low;
841
}
842

843
char ctype<char>::do_tolower(char_type c) const {
844
#ifdef _LIBCPP_HAS_DEFAULTRUNELOCALE
845
  return isascii(c) ? static_cast<char>(_DefaultRuneLocale.__maplower[static_cast<ptrdiff_t>(c)]) : c;
846
#elif defined(__NetBSD__)
847
  return static_cast<char>(__classic_lower_table()[static_cast<unsigned char>(c)]);
848
#elif defined(__GLIBC__) || defined(__EMSCRIPTEN__) || defined(__MVS__)
849
  return isascii(c) ? static_cast<char>(__classic_lower_table()[static_cast<size_t>(c)]) : c;
850
#else
851
  return (isascii(c) && isupper_l(c, _LIBCPP_GET_C_LOCALE)) ? c - 'A' + 'a' : c;
852
#endif
853
}
854

855
const char* ctype<char>::do_tolower(char_type* low, const char_type* high) const {
856
  for (; low != high; ++low)
857
#ifdef _LIBCPP_HAS_DEFAULTRUNELOCALE
858
    *low = isascii(*low) ? static_cast<char>(_DefaultRuneLocale.__maplower[static_cast<ptrdiff_t>(*low)]) : *low;
859
#elif defined(__NetBSD__)
860
    *low = static_cast<char>(__classic_lower_table()[static_cast<unsigned char>(*low)]);
861
#elif defined(__GLIBC__) || defined(__EMSCRIPTEN__) || defined(__MVS__)
862
    *low = isascii(*low) ? static_cast<char>(__classic_lower_table()[static_cast<size_t>(*low)]) : *low;
863
#else
864
    *low = (isascii(*low) && isupper_l(*low, _LIBCPP_GET_C_LOCALE)) ? *low - 'A' + 'a' : *low;
865
#endif
866
  return low;
867
}
868

869
char ctype<char>::do_widen(char c) const { return c; }
870

871
const char* ctype<char>::do_widen(const char* low, const char* high, char_type* dest) const {
872
  for (; low != high; ++low, ++dest)
873
    *dest = *low;
874
  return low;
875
}
876

877
char ctype<char>::do_narrow(char_type c, char dfault) const {
878
  if (isascii(c))
879
    return static_cast<char>(c);
880
  return dfault;
881
}
882

883
const char* ctype<char>::do_narrow(const char_type* low, const char_type* high, char dfault, char* dest) const {
884
  for (; low != high; ++low, ++dest)
885
    if (isascii(*low))
886
      *dest = *low;
887
    else
888
      *dest = dfault;
889
  return low;
890
}
891

892
#if defined(__EMSCRIPTEN__)
893
extern "C" const unsigned short** __ctype_b_loc();
894
extern "C" const int** __ctype_tolower_loc();
895
extern "C" const int** __ctype_toupper_loc();
896
#endif
897

898
#ifdef _LIBCPP_PROVIDES_DEFAULT_RUNE_TABLE
899
const ctype<char>::mask* ctype<char>::classic_table() noexcept {
900
  // clang-format off
901
    static constexpr const ctype<char>::mask builtin_table[table_size] = {
902
        cntrl,                          cntrl,
903
        cntrl,                          cntrl,
904
        cntrl,                          cntrl,
905
        cntrl,                          cntrl,
906
        cntrl,                          cntrl | space | blank,
907
        cntrl | space,                  cntrl | space,
908
        cntrl | space,                  cntrl | space,
909
        cntrl,                          cntrl,
910
        cntrl,                          cntrl,
911
        cntrl,                          cntrl,
912
        cntrl,                          cntrl,
913
        cntrl,                          cntrl,
914
        cntrl,                          cntrl,
915
        cntrl,                          cntrl,
916
        cntrl,                          cntrl,
917
        cntrl,                          cntrl,
918
        space | blank | print,          punct | print,
919
        punct | print,                  punct | print,
920
        punct | print,                  punct | print,
921
        punct | print,                  punct | print,
922
        punct | print,                  punct | print,
923
        punct | print,                  punct | print,
924
        punct | print,                  punct | print,
925
        punct | print,                  punct | print,
926
        digit | print | xdigit,         digit | print | xdigit,
927
        digit | print | xdigit,         digit | print | xdigit,
928
        digit | print | xdigit,         digit | print | xdigit,
929
        digit | print | xdigit,         digit | print | xdigit,
930
        digit | print | xdigit,         digit | print | xdigit,
931
        punct | print,                  punct | print,
932
        punct | print,                  punct | print,
933
        punct | print,                  punct | print,
934
        punct | print,                  upper | xdigit | print | alpha,
935
        upper | xdigit | print | alpha, upper | xdigit | print | alpha,
936
        upper | xdigit | print | alpha, upper | xdigit | print | alpha,
937
        upper | xdigit | print | alpha, upper | print | alpha,
938
        upper | print | alpha,          upper | print | alpha,
939
        upper | print | alpha,          upper | print | alpha,
940
        upper | print | alpha,          upper | print | alpha,
941
        upper | print | alpha,          upper | print | alpha,
942
        upper | print | alpha,          upper | print | alpha,
943
        upper | print | alpha,          upper | print | alpha,
944
        upper | print | alpha,          upper | print | alpha,
945
        upper | print | alpha,          upper | print | alpha,
946
        upper | print | alpha,          upper | print | alpha,
947
        upper | print | alpha,          punct | print,
948
        punct | print,                  punct | print,
949
        punct | print,                  punct | print,
950
        punct | print,                  lower | xdigit | print | alpha,
951
        lower | xdigit | print | alpha, lower | xdigit | print | alpha,
952
        lower | xdigit | print | alpha, lower | xdigit | print | alpha,
953
        lower | xdigit | print | alpha, lower | print | alpha,
954
        lower | print | alpha,          lower | print | alpha,
955
        lower | print | alpha,          lower | print | alpha,
956
        lower | print | alpha,          lower | print | alpha,
957
        lower | print | alpha,          lower | print | alpha,
958
        lower | print | alpha,          lower | print | alpha,
959
        lower | print | alpha,          lower | print | alpha,
960
        lower | print | alpha,          lower | print | alpha,
961
        lower | print | alpha,          lower | print | alpha,
962
        lower | print | alpha,          lower | print | alpha,
963
        lower | print | alpha,          punct | print,
964
        punct | print,                  punct | print,
965
        punct | print,                  cntrl,
966
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
967
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
968
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
969
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
970
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
971
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
972
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
973
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
974
    };
975
  // clang-format on
976
  return builtin_table;
977
}
978
#else
979
const ctype<char>::mask* ctype<char>::classic_table() noexcept {
980
#  if defined(__APPLE__) || defined(__FreeBSD__)
981
  return _DefaultRuneLocale.__runetype;
982
#  elif defined(__NetBSD__)
983
  return _C_ctype_tab_ + 1;
984
#  elif defined(__GLIBC__)
985
  return _LIBCPP_GET_C_LOCALE->__ctype_b;
986
#  elif defined(_LIBCPP_MSVCRT) || defined(__MINGW32__)
987
  return __pctype_func();
988
#  elif defined(__EMSCRIPTEN__)
989
  return *__ctype_b_loc();
990
#  elif defined(_NEWLIB_VERSION)
991
  // Newlib has a 257-entry table in ctype_.c, where (char)0 starts at [1].
992
  return _ctype_ + 1;
993
#  elif defined(_AIX)
994
  return (const unsigned int*)__lc_ctype_ptr->obj->mask;
995
#  elif defined(__MVS__)
996
#    if defined(__NATIVE_ASCII_F)
997
  return const_cast<const ctype<char>::mask*>(__OBJ_DATA(__lc_ctype_a)->mask);
998
#    else
999
  return const_cast<const ctype<char>::mask*>(__ctypec);
1000
#    endif
1001
#  else
1002
  // Platform not supported: abort so the person doing the port knows what to
1003
  // fix
1004
#    warning ctype<char>::classic_table() is not implemented
1005
  printf("ctype<char>::classic_table() is not implemented\n");
1006
  abort();
1007
  return NULL;
1008
#  endif
1009
}
1010
#endif
1011

1012
#if defined(__GLIBC__)
1013
const int* ctype<char>::__classic_lower_table() noexcept { return _LIBCPP_GET_C_LOCALE->__ctype_tolower; }
1014

1015
const int* ctype<char>::__classic_upper_table() noexcept { return _LIBCPP_GET_C_LOCALE->__ctype_toupper; }
1016
#elif defined(__NetBSD__)
1017
const short* ctype<char>::__classic_lower_table() noexcept { return _C_tolower_tab_ + 1; }
1018

1019
const short* ctype<char>::__classic_upper_table() noexcept { return _C_toupper_tab_ + 1; }
1020

1021
#elif defined(__EMSCRIPTEN__)
1022
const int* ctype<char>::__classic_lower_table() noexcept { return *__ctype_tolower_loc(); }
1023

1024
const int* ctype<char>::__classic_upper_table() noexcept { return *__ctype_toupper_loc(); }
1025
#elif defined(__MVS__)
1026
const unsigned short* ctype<char>::__classic_lower_table() _NOEXCEPT {
1027
#  if defined(__NATIVE_ASCII_F)
1028
  return const_cast<const unsigned short*>(__OBJ_DATA(__lc_ctype_a)->lower);
1029
#  else
1030
  return const_cast<const unsigned short*>(__ctype + __TOLOWER_INDEX);
1031
#  endif
1032
}
1033
const unsigned short* ctype<char>::__classic_upper_table() _NOEXCEPT {
1034
#  if defined(__NATIVE_ASCII_F)
1035
  return const_cast<const unsigned short*>(__OBJ_DATA(__lc_ctype_a)->upper);
1036
#  else
1037
  return const_cast<const unsigned short*>(__ctype + __TOUPPER_INDEX);
1038
#  endif
1039
}
1040
#endif // __GLIBC__ || __NETBSD__ || __EMSCRIPTEN__ || __MVS__
1041

1042
// template <> class ctype_byname<char>
1043

1044
ctype_byname<char>::ctype_byname(const char* name, size_t refs)
1045
    : ctype<char>(0, false, refs), __l_(newlocale(LC_ALL_MASK, name, 0)) {
1046
  if (__l_ == 0)
1047
    __throw_runtime_error(
1048
        ("ctype_byname<char>::ctype_byname"
1049
         " failed to construct for " +
1050
         string(name))
1051
            .c_str());
1052
}
1053

1054
ctype_byname<char>::ctype_byname(const string& name, size_t refs)
1055
    : ctype<char>(0, false, refs), __l_(newlocale(LC_ALL_MASK, name.c_str(), 0)) {
1056
  if (__l_ == 0)
1057
    __throw_runtime_error(
1058
        ("ctype_byname<char>::ctype_byname"
1059
         " failed to construct for " +
1060
         name)
1061
            .c_str());
1062
}
1063

1064
ctype_byname<char>::~ctype_byname() { freelocale(__l_); }
1065

1066
char ctype_byname<char>::do_toupper(char_type c) const {
1067
  return static_cast<char>(toupper_l(static_cast<unsigned char>(c), __l_));
1068
}
1069

1070
const char* ctype_byname<char>::do_toupper(char_type* low, const char_type* high) const {
1071
  for (; low != high; ++low)
1072
    *low = static_cast<char>(toupper_l(static_cast<unsigned char>(*low), __l_));
1073
  return low;
1074
}
1075

1076
char ctype_byname<char>::do_tolower(char_type c) const {
1077
  return static_cast<char>(tolower_l(static_cast<unsigned char>(c), __l_));
1078
}
1079

1080
const char* ctype_byname<char>::do_tolower(char_type* low, const char_type* high) const {
1081
  for (; low != high; ++low)
1082
    *low = static_cast<char>(tolower_l(static_cast<unsigned char>(*low), __l_));
1083
  return low;
1084
}
1085

1086
// template <> class ctype_byname<wchar_t>
1087

1088
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
1089
ctype_byname<wchar_t>::ctype_byname(const char* name, size_t refs)
1090
    : ctype<wchar_t>(refs), __l_(newlocale(LC_ALL_MASK, name, 0)) {
1091
  if (__l_ == 0)
1092
    __throw_runtime_error(
1093
        ("ctype_byname<wchar_t>::ctype_byname"
1094
         " failed to construct for " +
1095
         string(name))
1096
            .c_str());
1097
}
1098

1099
ctype_byname<wchar_t>::ctype_byname(const string& name, size_t refs)
1100
    : ctype<wchar_t>(refs), __l_(newlocale(LC_ALL_MASK, name.c_str(), 0)) {
1101
  if (__l_ == 0)
1102
    __throw_runtime_error(
1103
        ("ctype_byname<wchar_t>::ctype_byname"
1104
         " failed to construct for " +
1105
         name)
1106
            .c_str());
1107
}
1108

1109
ctype_byname<wchar_t>::~ctype_byname() { freelocale(__l_); }
1110

1111
bool ctype_byname<wchar_t>::do_is(mask m, char_type c) const {
1112
#  ifdef _LIBCPP_WCTYPE_IS_MASK
1113
  return static_cast<bool>(iswctype_l(c, m, __l_));
1114
#  else
1115
  bool result = false;
1116
  wint_t ch   = static_cast<wint_t>(c);
1117
  if ((m & space) == space)
1118
    result |= (iswspace_l(ch, __l_) != 0);
1119
  if ((m & print) == print)
1120
    result |= (iswprint_l(ch, __l_) != 0);
1121
  if ((m & cntrl) == cntrl)
1122
    result |= (iswcntrl_l(ch, __l_) != 0);
1123
  if ((m & upper) == upper)
1124
    result |= (iswupper_l(ch, __l_) != 0);
1125
  if ((m & lower) == lower)
1126
    result |= (iswlower_l(ch, __l_) != 0);
1127
  if ((m & alpha) == alpha)
1128
    result |= (iswalpha_l(ch, __l_) != 0);
1129
  if ((m & digit) == digit)
1130
    result |= (iswdigit_l(ch, __l_) != 0);
1131
  if ((m & punct) == punct)
1132
    result |= (iswpunct_l(ch, __l_) != 0);
1133
  if ((m & xdigit) == xdigit)
1134
    result |= (iswxdigit_l(ch, __l_) != 0);
1135
  if ((m & blank) == blank)
1136
    result |= (iswblank_l(ch, __l_) != 0);
1137
  return result;
1138
#  endif
1139
}
1140

1141
const wchar_t* ctype_byname<wchar_t>::do_is(const char_type* low, const char_type* high, mask* vec) const {
1142
  for (; low != high; ++low, ++vec) {
1143
    if (isascii(*low))
1144
      *vec = static_cast<mask>(ctype<char>::classic_table()[*low]);
1145
    else {
1146
      *vec      = 0;
1147
      wint_t ch = static_cast<wint_t>(*low);
1148
      if (iswspace_l(ch, __l_))
1149
        *vec |= space;
1150
#  ifndef _LIBCPP_CTYPE_MASK_IS_COMPOSITE_PRINT
1151
      if (iswprint_l(ch, __l_))
1152
        *vec |= print;
1153
#  endif
1154
      if (iswcntrl_l(ch, __l_))
1155
        *vec |= cntrl;
1156
      if (iswupper_l(ch, __l_))
1157
        *vec |= upper;
1158
      if (iswlower_l(ch, __l_))
1159
        *vec |= lower;
1160
#  ifndef _LIBCPP_CTYPE_MASK_IS_COMPOSITE_ALPHA
1161
      if (iswalpha_l(ch, __l_))
1162
        *vec |= alpha;
1163
#  endif
1164
      if (iswdigit_l(ch, __l_))
1165
        *vec |= digit;
1166
      if (iswpunct_l(ch, __l_))
1167
        *vec |= punct;
1168
#  ifndef _LIBCPP_CTYPE_MASK_IS_COMPOSITE_XDIGIT
1169
      if (iswxdigit_l(ch, __l_))
1170
        *vec |= xdigit;
1171
#  endif
1172
      if (iswblank_l(ch, __l_))
1173
        *vec |= blank;
1174
    }
1175
  }
1176
  return low;
1177
}
1178

1179
const wchar_t* ctype_byname<wchar_t>::do_scan_is(mask m, const char_type* low, const char_type* high) const {
1180
  for (; low != high; ++low) {
1181
#  ifdef _LIBCPP_WCTYPE_IS_MASK
1182
    if (iswctype_l(*low, m, __l_))
1183
      break;
1184
#  else
1185
    wint_t ch = static_cast<wint_t>(*low);
1186
    if ((m & space) == space && iswspace_l(ch, __l_))
1187
      break;
1188
    if ((m & print) == print && iswprint_l(ch, __l_))
1189
      break;
1190
    if ((m & cntrl) == cntrl && iswcntrl_l(ch, __l_))
1191
      break;
1192
    if ((m & upper) == upper && iswupper_l(ch, __l_))
1193
      break;
1194
    if ((m & lower) == lower && iswlower_l(ch, __l_))
1195
      break;
1196
    if ((m & alpha) == alpha && iswalpha_l(ch, __l_))
1197
      break;
1198
    if ((m & digit) == digit && iswdigit_l(ch, __l_))
1199
      break;
1200
    if ((m & punct) == punct && iswpunct_l(ch, __l_))
1201
      break;
1202
    if ((m & xdigit) == xdigit && iswxdigit_l(ch, __l_))
1203
      break;
1204
    if ((m & blank) == blank && iswblank_l(ch, __l_))
1205
      break;
1206
#  endif
1207
  }
1208
  return low;
1209
}
1210

1211
const wchar_t* ctype_byname<wchar_t>::do_scan_not(mask m, const char_type* low, const char_type* high) const {
1212
  for (; low != high; ++low) {
1213
#  ifdef _LIBCPP_WCTYPE_IS_MASK
1214
    if (!iswctype_l(*low, m, __l_))
1215
      break;
1216
#  else
1217
    wint_t ch = static_cast<wint_t>(*low);
1218
    if ((m & space) == space && iswspace_l(ch, __l_))
1219
      continue;
1220
    if ((m & print) == print && iswprint_l(ch, __l_))
1221
      continue;
1222
    if ((m & cntrl) == cntrl && iswcntrl_l(ch, __l_))
1223
      continue;
1224
    if ((m & upper) == upper && iswupper_l(ch, __l_))
1225
      continue;
1226
    if ((m & lower) == lower && iswlower_l(ch, __l_))
1227
      continue;
1228
    if ((m & alpha) == alpha && iswalpha_l(ch, __l_))
1229
      continue;
1230
    if ((m & digit) == digit && iswdigit_l(ch, __l_))
1231
      continue;
1232
    if ((m & punct) == punct && iswpunct_l(ch, __l_))
1233
      continue;
1234
    if ((m & xdigit) == xdigit && iswxdigit_l(ch, __l_))
1235
      continue;
1236
    if ((m & blank) == blank && iswblank_l(ch, __l_))
1237
      continue;
1238
    break;
1239
#  endif
1240
  }
1241
  return low;
1242
}
1243

1244
wchar_t ctype_byname<wchar_t>::do_toupper(char_type c) const { return towupper_l(c, __l_); }
1245

1246
const wchar_t* ctype_byname<wchar_t>::do_toupper(char_type* low, const char_type* high) const {
1247
  for (; low != high; ++low)
1248
    *low = towupper_l(*low, __l_);
1249
  return low;
1250
}
1251

1252
wchar_t ctype_byname<wchar_t>::do_tolower(char_type c) const { return towlower_l(c, __l_); }
1253

1254
const wchar_t* ctype_byname<wchar_t>::do_tolower(char_type* low, const char_type* high) const {
1255
  for (; low != high; ++low)
1256
    *low = towlower_l(*low, __l_);
1257
  return low;
1258
}
1259

1260
wchar_t ctype_byname<wchar_t>::do_widen(char c) const { return __libcpp_btowc_l(c, __l_); }
1261

1262
const char* ctype_byname<wchar_t>::do_widen(const char* low, const char* high, char_type* dest) const {
1263
  for (; low != high; ++low, ++dest)
1264
    *dest = __libcpp_btowc_l(*low, __l_);
1265
  return low;
1266
}
1267

1268
char ctype_byname<wchar_t>::do_narrow(char_type c, char dfault) const {
1269
  int r = __libcpp_wctob_l(c, __l_);
1270
  return (r != EOF) ? static_cast<char>(r) : dfault;
1271
}
1272

1273
const wchar_t*
1274
ctype_byname<wchar_t>::do_narrow(const char_type* low, const char_type* high, char dfault, char* dest) const {
1275
  for (; low != high; ++low, ++dest) {
1276
    int r = __libcpp_wctob_l(*low, __l_);
1277
    *dest = (r != EOF) ? static_cast<char>(r) : dfault;
1278
  }
1279
  return low;
1280
}
1281
#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
1282

1283
// template <> class codecvt<char, char, mbstate_t>
1284

1285
constinit locale::id codecvt<char, char, mbstate_t>::id;
1286

1287
codecvt<char, char, mbstate_t>::~codecvt() {}
1288

1289
codecvt<char, char, mbstate_t>::result codecvt<char, char, mbstate_t>::do_out(
1290
    state_type&,
1291
    const intern_type* frm,
1292
    const intern_type*,
1293
    const intern_type*& frm_nxt,
1294
    extern_type* to,
1295
    extern_type*,
1296
    extern_type*& to_nxt) const {
1297
  frm_nxt = frm;
1298
  to_nxt  = to;
1299
  return noconv;
1300
}
1301

1302
codecvt<char, char, mbstate_t>::result codecvt<char, char, mbstate_t>::do_in(
1303
    state_type&,
1304
    const extern_type* frm,
1305
    const extern_type*,
1306
    const extern_type*& frm_nxt,
1307
    intern_type* to,
1308
    intern_type*,
1309
    intern_type*& to_nxt) const {
1310
  frm_nxt = frm;
1311
  to_nxt  = to;
1312
  return noconv;
1313
}
1314

1315
codecvt<char, char, mbstate_t>::result
1316
codecvt<char, char, mbstate_t>::do_unshift(state_type&, extern_type* to, extern_type*, extern_type*& to_nxt) const {
1317
  to_nxt = to;
1318
  return noconv;
1319
}
1320

1321
int codecvt<char, char, mbstate_t>::do_encoding() const noexcept { return 1; }
1322

1323
bool codecvt<char, char, mbstate_t>::do_always_noconv() const noexcept { return true; }
1324

1325
int codecvt<char, char, mbstate_t>::do_length(
1326
    state_type&, const extern_type* frm, const extern_type* end, size_t mx) const {
1327
  return static_cast<int>(min<size_t>(mx, static_cast<size_t>(end - frm)));
1328
}
1329

1330
int codecvt<char, char, mbstate_t>::do_max_length() const noexcept { return 1; }
1331

1332
// template <> class codecvt<wchar_t, char, mbstate_t>
1333

1334
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
1335
constinit locale::id codecvt<wchar_t, char, mbstate_t>::id;
1336

1337
codecvt<wchar_t, char, mbstate_t>::codecvt(size_t refs) : locale::facet(refs), __l_(_LIBCPP_GET_C_LOCALE) {}
1338

1339
codecvt<wchar_t, char, mbstate_t>::codecvt(const char* nm, size_t refs)
1340
    : locale::facet(refs), __l_(newlocale(LC_ALL_MASK, nm, 0)) {
1341
  if (__l_ == 0)
1342
    __throw_runtime_error(
1343
        ("codecvt_byname<wchar_t, char, mbstate_t>::codecvt_byname"
1344
         " failed to construct for " +
1345
         string(nm))
1346
            .c_str());
1347
}
1348

1349
codecvt<wchar_t, char, mbstate_t>::~codecvt() {
1350
  if (__l_ != _LIBCPP_GET_C_LOCALE)
1351
    freelocale(__l_);
1352
}
1353

1354
codecvt<wchar_t, char, mbstate_t>::result codecvt<wchar_t, char, mbstate_t>::do_out(
1355
    state_type& st,
1356
    const intern_type* frm,
1357
    const intern_type* frm_end,
1358
    const intern_type*& frm_nxt,
1359
    extern_type* to,
1360
    extern_type* to_end,
1361
    extern_type*& to_nxt) const {
1362
  // look for first internal null in frm
1363
  const intern_type* fend = frm;
1364
  for (; fend != frm_end; ++fend)
1365
    if (*fend == 0)
1366
      break;
1367
  // loop over all null-terminated sequences in frm
1368
  to_nxt = to;
1369
  for (frm_nxt = frm; frm != frm_end && to != to_end; frm = frm_nxt, to = to_nxt) {
1370
    // save state in case it is needed to recover to_nxt on error
1371
    mbstate_t save_state = st;
1372
    size_t n             = __libcpp_wcsnrtombs_l(
1373
        to, &frm_nxt, static_cast<size_t>(fend - frm), static_cast<size_t>(to_end - to), &st, __l_);
1374
    if (n == size_t(-1)) {
1375
      // need to recover to_nxt
1376
      for (to_nxt = to; frm != frm_nxt; ++frm) {
1377
        n = __libcpp_wcrtomb_l(to_nxt, *frm, &save_state, __l_);
1378
        if (n == size_t(-1))
1379
          break;
1380
        to_nxt += n;
1381
      }
1382
      frm_nxt = frm;
1383
      return error;
1384
    }
1385
    if (n == 0)
1386
      return partial;
1387
    to_nxt += n;
1388
    if (to_nxt == to_end)
1389
      break;
1390
    if (fend != frm_end) // set up next null terminated sequence
1391
    {
1392
      // Try to write the terminating null
1393
      extern_type tmp[MB_LEN_MAX];
1394
      n = __libcpp_wcrtomb_l(tmp, intern_type(), &st, __l_);
1395
      if (n == size_t(-1)) // on error
1396
        return error;
1397
      if (n > static_cast<size_t>(to_end - to_nxt)) // is there room?
1398
        return partial;
1399
      for (extern_type* p = tmp; n; --n) // write it
1400
        *to_nxt++ = *p++;
1401
      ++frm_nxt;
1402
      // look for next null in frm
1403
      for (fend = frm_nxt; fend != frm_end; ++fend)
1404
        if (*fend == 0)
1405
          break;
1406
    }
1407
  }
1408
  return frm_nxt == frm_end ? ok : partial;
1409
}
1410

1411
codecvt<wchar_t, char, mbstate_t>::result codecvt<wchar_t, char, mbstate_t>::do_in(
1412
    state_type& st,
1413
    const extern_type* frm,
1414
    const extern_type* frm_end,
1415
    const extern_type*& frm_nxt,
1416
    intern_type* to,
1417
    intern_type* to_end,
1418
    intern_type*& to_nxt) const {
1419
  // look for first internal null in frm
1420
  const extern_type* fend = frm;
1421
  for (; fend != frm_end; ++fend)
1422
    if (*fend == 0)
1423
      break;
1424
  // loop over all null-terminated sequences in frm
1425
  to_nxt = to;
1426
  for (frm_nxt = frm; frm != frm_end && to != to_end; frm = frm_nxt, to = to_nxt) {
1427
    // save state in case it is needed to recover to_nxt on error
1428
    mbstate_t save_state = st;
1429
    size_t n             = __libcpp_mbsnrtowcs_l(
1430
        to, &frm_nxt, static_cast<size_t>(fend - frm), static_cast<size_t>(to_end - to), &st, __l_);
1431
    if (n == size_t(-1)) {
1432
      // need to recover to_nxt
1433
      for (to_nxt = to; frm != frm_nxt; ++to_nxt) {
1434
        n = __libcpp_mbrtowc_l(to_nxt, frm, static_cast<size_t>(fend - frm), &save_state, __l_);
1435
        switch (n) {
1436
        case 0:
1437
          ++frm;
1438
          break;
1439
        case size_t(-1):
1440
          frm_nxt = frm;
1441
          return error;
1442
        case size_t(-2):
1443
          frm_nxt = frm;
1444
          return partial;
1445
        default:
1446
          frm += n;
1447
          break;
1448
        }
1449
      }
1450
      frm_nxt = frm;
1451
      return frm_nxt == frm_end ? ok : partial;
1452
    }
1453
    if (n == size_t(-1))
1454
      return error;
1455
    to_nxt += n;
1456
    if (to_nxt == to_end)
1457
      break;
1458
    if (fend != frm_end) // set up next null terminated sequence
1459
    {
1460
      // Try to write the terminating null
1461
      n = __libcpp_mbrtowc_l(to_nxt, frm_nxt, 1, &st, __l_);
1462
      if (n != 0) // on error
1463
        return error;
1464
      ++to_nxt;
1465
      ++frm_nxt;
1466
      // look for next null in frm
1467
      for (fend = frm_nxt; fend != frm_end; ++fend)
1468
        if (*fend == 0)
1469
          break;
1470
    }
1471
  }
1472
  return frm_nxt == frm_end ? ok : partial;
1473
}
1474

1475
codecvt<wchar_t, char, mbstate_t>::result codecvt<wchar_t, char, mbstate_t>::do_unshift(
1476
    state_type& st, extern_type* to, extern_type* to_end, extern_type*& to_nxt) const {
1477
  to_nxt = to;
1478
  extern_type tmp[MB_LEN_MAX];
1479
  size_t n = __libcpp_wcrtomb_l(tmp, intern_type(), &st, __l_);
1480
  if (n == size_t(-1) || n == 0) // on error
1481
    return error;
1482
  --n;
1483
  if (n > static_cast<size_t>(to_end - to_nxt)) // is there room?
1484
    return partial;
1485
  for (extern_type* p = tmp; n; --n) // write it
1486
    *to_nxt++ = *p++;
1487
  return ok;
1488
}
1489

1490
int codecvt<wchar_t, char, mbstate_t>::do_encoding() const noexcept {
1491
  if (__libcpp_mbtowc_l(nullptr, nullptr, MB_LEN_MAX, __l_) != 0)
1492
    return -1;
1493

1494
  // stateless encoding
1495
  if (__l_ == 0 || __libcpp_mb_cur_max_l(__l_) == 1) // there are no known constant length encodings
1496
    return 1;                                        // which take more than 1 char to form a wchar_t
1497
  return 0;
1498
}
1499

1500
bool codecvt<wchar_t, char, mbstate_t>::do_always_noconv() const noexcept { return false; }
1501

1502
int codecvt<wchar_t, char, mbstate_t>::do_length(
1503
    state_type& st, const extern_type* frm, const extern_type* frm_end, size_t mx) const {
1504
  int nbytes = 0;
1505
  for (size_t nwchar_t = 0; nwchar_t < mx && frm != frm_end; ++nwchar_t) {
1506
    size_t n = __libcpp_mbrlen_l(frm, static_cast<size_t>(frm_end - frm), &st, __l_);
1507
    switch (n) {
1508
    case 0:
1509
      ++nbytes;
1510
      ++frm;
1511
      break;
1512
    case size_t(-1):
1513
    case size_t(-2):
1514
      return nbytes;
1515
    default:
1516
      nbytes += n;
1517
      frm += n;
1518
      break;
1519
    }
1520
  }
1521
  return nbytes;
1522
}
1523

1524
int codecvt<wchar_t, char, mbstate_t>::do_max_length() const noexcept {
1525
  return __l_ == 0 ? 1 : static_cast<int>(__libcpp_mb_cur_max_l(__l_));
1526
}
1527
#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
1528

1529
//                                     Valid UTF ranges
1530
//     UTF-32               UTF-16                          UTF-8               # of code points
1531
//                     first      second       first   second    third   fourth
1532
// 000000 - 00007F  0000 - 007F               00 - 7F                                 127
1533
// 000080 - 0007FF  0080 - 07FF               C2 - DF, 80 - BF                       1920
1534
// 000800 - 000FFF  0800 - 0FFF               E0 - E0, A0 - BF, 80 - BF              2048
1535
// 001000 - 00CFFF  1000 - CFFF               E1 - EC, 80 - BF, 80 - BF             49152
1536
// 00D000 - 00D7FF  D000 - D7FF               ED - ED, 80 - 9F, 80 - BF              2048
1537
// 00D800 - 00DFFF                invalid
1538
// 00E000 - 00FFFF  E000 - FFFF               EE - EF, 80 - BF, 80 - BF              8192
1539
// 010000 - 03FFFF  D800 - D8BF, DC00 - DFFF  F0 - F0, 90 - BF, 80 - BF, 80 - BF   196608
1540
// 040000 - 0FFFFF  D8C0 - DBBF, DC00 - DFFF  F1 - F3, 80 - BF, 80 - BF, 80 - BF   786432
1541
// 100000 - 10FFFF  DBC0 - DBFF, DC00 - DFFF  F4 - F4, 80 - 8F, 80 - BF, 80 - BF    65536
1542

1543
_LIBCPP_SUPPRESS_DEPRECATED_PUSH
1544
static codecvt_base::result utf16_to_utf8(
1545
    const uint16_t* frm,
1546
    const uint16_t* frm_end,
1547
    const uint16_t*& frm_nxt,
1548
    uint8_t* to,
1549
    uint8_t* to_end,
1550
    uint8_t*& to_nxt,
1551
    unsigned long Maxcode = 0x10FFFF,
1552
    codecvt_mode mode     = codecvt_mode(0)) {
1553
  frm_nxt = frm;
1554
  to_nxt  = to;
1555
  if (mode & generate_header) {
1556
    if (to_end - to_nxt < 3)
1557
      return codecvt_base::partial;
1558
    *to_nxt++ = static_cast<uint8_t>(0xEF);
1559
    *to_nxt++ = static_cast<uint8_t>(0xBB);
1560
    *to_nxt++ = static_cast<uint8_t>(0xBF);
1561
  }
1562
  for (; frm_nxt < frm_end; ++frm_nxt) {
1563
    uint16_t wc1 = *frm_nxt;
1564
    if (wc1 > Maxcode)
1565
      return codecvt_base::error;
1566
    if (wc1 < 0x0080) {
1567
      if (to_end - to_nxt < 1)
1568
        return codecvt_base::partial;
1569
      *to_nxt++ = static_cast<uint8_t>(wc1);
1570
    } else if (wc1 < 0x0800) {
1571
      if (to_end - to_nxt < 2)
1572
        return codecvt_base::partial;
1573
      *to_nxt++ = static_cast<uint8_t>(0xC0 | (wc1 >> 6));
1574
      *to_nxt++ = static_cast<uint8_t>(0x80 | (wc1 & 0x03F));
1575
    } else if (wc1 < 0xD800) {
1576
      if (to_end - to_nxt < 3)
1577
        return codecvt_base::partial;
1578
      *to_nxt++ = static_cast<uint8_t>(0xE0 | (wc1 >> 12));
1579
      *to_nxt++ = static_cast<uint8_t>(0x80 | ((wc1 & 0x0FC0) >> 6));
1580
      *to_nxt++ = static_cast<uint8_t>(0x80 | (wc1 & 0x003F));
1581
    } else if (wc1 < 0xDC00) {
1582
      if (frm_end - frm_nxt < 2)
1583
        return codecvt_base::partial;
1584
      uint16_t wc2 = frm_nxt[1];
1585
      if ((wc2 & 0xFC00) != 0xDC00)
1586
        return codecvt_base::error;
1587
      if (to_end - to_nxt < 4)
1588
        return codecvt_base::partial;
1589
      if (((((wc1 & 0x03C0UL) >> 6) + 1) << 16) + ((wc1 & 0x003FUL) << 10) + (wc2 & 0x03FF) > Maxcode)
1590
        return codecvt_base::error;
1591
      ++frm_nxt;
1592
      uint8_t z = ((wc1 & 0x03C0) >> 6) + 1;
1593
      *to_nxt++ = static_cast<uint8_t>(0xF0 | (z >> 2));
1594
      *to_nxt++ = static_cast<uint8_t>(0x80 | ((z & 0x03) << 4) | ((wc1 & 0x003C) >> 2));
1595
      *to_nxt++ = static_cast<uint8_t>(0x80 | ((wc1 & 0x0003) << 4) | ((wc2 & 0x03C0) >> 6));
1596
      *to_nxt++ = static_cast<uint8_t>(0x80 | (wc2 & 0x003F));
1597
    } else if (wc1 < 0xE000) {
1598
      return codecvt_base::error;
1599
    } else {
1600
      if (to_end - to_nxt < 3)
1601
        return codecvt_base::partial;
1602
      *to_nxt++ = static_cast<uint8_t>(0xE0 | (wc1 >> 12));
1603
      *to_nxt++ = static_cast<uint8_t>(0x80 | ((wc1 & 0x0FC0) >> 6));
1604
      *to_nxt++ = static_cast<uint8_t>(0x80 | (wc1 & 0x003F));
1605
    }
1606
  }
1607
  return codecvt_base::ok;
1608
}
1609

1610
static codecvt_base::result utf16_to_utf8(
1611
    const uint32_t* frm,
1612
    const uint32_t* frm_end,
1613
    const uint32_t*& frm_nxt,
1614
    uint8_t* to,
1615
    uint8_t* to_end,
1616
    uint8_t*& to_nxt,
1617
    unsigned long Maxcode = 0x10FFFF,
1618
    codecvt_mode mode     = codecvt_mode(0)) {
1619
  frm_nxt = frm;
1620
  to_nxt  = to;
1621
  if (mode & generate_header) {
1622
    if (to_end - to_nxt < 3)
1623
      return codecvt_base::partial;
1624
    *to_nxt++ = static_cast<uint8_t>(0xEF);
1625
    *to_nxt++ = static_cast<uint8_t>(0xBB);
1626
    *to_nxt++ = static_cast<uint8_t>(0xBF);
1627
  }
1628
  for (; frm_nxt < frm_end; ++frm_nxt) {
1629
    uint16_t wc1 = static_cast<uint16_t>(*frm_nxt);
1630
    if (wc1 > Maxcode)
1631
      return codecvt_base::error;
1632
    if (wc1 < 0x0080) {
1633
      if (to_end - to_nxt < 1)
1634
        return codecvt_base::partial;
1635
      *to_nxt++ = static_cast<uint8_t>(wc1);
1636
    } else if (wc1 < 0x0800) {
1637
      if (to_end - to_nxt < 2)
1638
        return codecvt_base::partial;
1639
      *to_nxt++ = static_cast<uint8_t>(0xC0 | (wc1 >> 6));
1640
      *to_nxt++ = static_cast<uint8_t>(0x80 | (wc1 & 0x03F));
1641
    } else if (wc1 < 0xD800) {
1642
      if (to_end - to_nxt < 3)
1643
        return codecvt_base::partial;
1644
      *to_nxt++ = static_cast<uint8_t>(0xE0 | (wc1 >> 12));
1645
      *to_nxt++ = static_cast<uint8_t>(0x80 | ((wc1 & 0x0FC0) >> 6));
1646
      *to_nxt++ = static_cast<uint8_t>(0x80 | (wc1 & 0x003F));
1647
    } else if (wc1 < 0xDC00) {
1648
      if (frm_end - frm_nxt < 2)
1649
        return codecvt_base::partial;
1650
      uint16_t wc2 = static_cast<uint16_t>(frm_nxt[1]);
1651
      if ((wc2 & 0xFC00) != 0xDC00)
1652
        return codecvt_base::error;
1653
      if (to_end - to_nxt < 4)
1654
        return codecvt_base::partial;
1655
      if (((((wc1 & 0x03C0UL) >> 6) + 1) << 16) + ((wc1 & 0x003FUL) << 10) + (wc2 & 0x03FF) > Maxcode)
1656
        return codecvt_base::error;
1657
      ++frm_nxt;
1658
      uint8_t z = ((wc1 & 0x03C0) >> 6) + 1;
1659
      *to_nxt++ = static_cast<uint8_t>(0xF0 | (z >> 2));
1660
      *to_nxt++ = static_cast<uint8_t>(0x80 | ((z & 0x03) << 4) | ((wc1 & 0x003C) >> 2));
1661
      *to_nxt++ = static_cast<uint8_t>(0x80 | ((wc1 & 0x0003) << 4) | ((wc2 & 0x03C0) >> 6));
1662
      *to_nxt++ = static_cast<uint8_t>(0x80 | (wc2 & 0x003F));
1663
    } else if (wc1 < 0xE000) {
1664
      return codecvt_base::error;
1665
    } else {
1666
      if (to_end - to_nxt < 3)
1667
        return codecvt_base::partial;
1668
      *to_nxt++ = static_cast<uint8_t>(0xE0 | (wc1 >> 12));
1669
      *to_nxt++ = static_cast<uint8_t>(0x80 | ((wc1 & 0x0FC0) >> 6));
1670
      *to_nxt++ = static_cast<uint8_t>(0x80 | (wc1 & 0x003F));
1671
    }
1672
  }
1673
  return codecvt_base::ok;
1674
}
1675

1676
static codecvt_base::result utf8_to_utf16(
1677
    const uint8_t* frm,
1678
    const uint8_t* frm_end,
1679
    const uint8_t*& frm_nxt,
1680
    uint16_t* to,
1681
    uint16_t* to_end,
1682
    uint16_t*& to_nxt,
1683
    unsigned long Maxcode = 0x10FFFF,
1684
    codecvt_mode mode     = codecvt_mode(0)) {
1685
  frm_nxt = frm;
1686
  to_nxt  = to;
1687
  if (mode & consume_header) {
1688
    if (frm_end - frm_nxt >= 3 && frm_nxt[0] == 0xEF && frm_nxt[1] == 0xBB && frm_nxt[2] == 0xBF)
1689
      frm_nxt += 3;
1690
  }
1691
  for (; frm_nxt < frm_end && to_nxt < to_end; ++to_nxt) {
1692
    uint8_t c1 = *frm_nxt;
1693
    if (c1 > Maxcode)
1694
      return codecvt_base::error;
1695
    if (c1 < 0x80) {
1696
      *to_nxt = static_cast<uint16_t>(c1);
1697
      ++frm_nxt;
1698
    } else if (c1 < 0xC2) {
1699
      return codecvt_base::error;
1700
    } else if (c1 < 0xE0) {
1701
      if (frm_end - frm_nxt < 2)
1702
        return codecvt_base::partial;
1703
      uint8_t c2 = frm_nxt[1];
1704
      if ((c2 & 0xC0) != 0x80)
1705
        return codecvt_base::error;
1706
      uint16_t t = static_cast<uint16_t>(((c1 & 0x1F) << 6) | (c2 & 0x3F));
1707
      if (t > Maxcode)
1708
        return codecvt_base::error;
1709
      *to_nxt = t;
1710
      frm_nxt += 2;
1711
    } else if (c1 < 0xF0) {
1712
      if (frm_end - frm_nxt < 2)
1713
        return codecvt_base::partial;
1714
      uint8_t c2 = frm_nxt[1];
1715
      switch (c1) {
1716
      case 0xE0:
1717
        if ((c2 & 0xE0) != 0xA0)
1718
          return codecvt_base::error;
1719
        break;
1720
      case 0xED:
1721
        if ((c2 & 0xE0) != 0x80)
1722
          return codecvt_base::error;
1723
        break;
1724
      default:
1725
        if ((c2 & 0xC0) != 0x80)
1726
          return codecvt_base::error;
1727
        break;
1728
      }
1729
      if (frm_end - frm_nxt < 3)
1730
        return codecvt_base::partial;
1731
      uint8_t c3 = frm_nxt[2];
1732
      if ((c3 & 0xC0) != 0x80)
1733
        return codecvt_base::error;
1734
      uint16_t t = static_cast<uint16_t>(((c1 & 0x0F) << 12) | ((c2 & 0x3F) << 6) | (c3 & 0x3F));
1735
      if (t > Maxcode)
1736
        return codecvt_base::error;
1737
      *to_nxt = t;
1738
      frm_nxt += 3;
1739
    } else if (c1 < 0xF5) {
1740
      if (frm_end - frm_nxt < 2)
1741
        return codecvt_base::partial;
1742
      uint8_t c2 = frm_nxt[1];
1743
      switch (c1) {
1744
      case 0xF0:
1745
        if (!(0x90 <= c2 && c2 <= 0xBF))
1746
          return codecvt_base::error;
1747
        break;
1748
      case 0xF4:
1749
        if ((c2 & 0xF0) != 0x80)
1750
          return codecvt_base::error;
1751
        break;
1752
      default:
1753
        if ((c2 & 0xC0) != 0x80)
1754
          return codecvt_base::error;
1755
        break;
1756
      }
1757
      if (frm_end - frm_nxt < 3)
1758
        return codecvt_base::partial;
1759
      uint8_t c3 = frm_nxt[2];
1760
      if ((c3 & 0xC0) != 0x80)
1761
        return codecvt_base::error;
1762
      if (frm_end - frm_nxt < 4)
1763
        return codecvt_base::partial;
1764
      uint8_t c4 = frm_nxt[3];
1765
      if ((c4 & 0xC0) != 0x80)
1766
        return codecvt_base::error;
1767
      if (to_end - to_nxt < 2)
1768
        return codecvt_base::partial;
1769
      if ((((c1 & 7UL) << 18) + ((c2 & 0x3FUL) << 12) + ((c3 & 0x3FUL) << 6) + (c4 & 0x3F)) > Maxcode)
1770
        return codecvt_base::error;
1771
      *to_nxt = static_cast<uint16_t>(
1772
          0xD800 | (((((c1 & 0x07) << 2) | ((c2 & 0x30) >> 4)) - 1) << 6) | ((c2 & 0x0F) << 2) | ((c3 & 0x30) >> 4));
1773
      *++to_nxt = static_cast<uint16_t>(0xDC00 | ((c3 & 0x0F) << 6) | (c4 & 0x3F));
1774
      frm_nxt += 4;
1775
    } else {
1776
      return codecvt_base::error;
1777
    }
1778
  }
1779
  return frm_nxt < frm_end ? codecvt_base::partial : codecvt_base::ok;
1780
}
1781

1782
static codecvt_base::result utf8_to_utf16(
1783
    const uint8_t* frm,
1784
    const uint8_t* frm_end,
1785
    const uint8_t*& frm_nxt,
1786
    uint32_t* to,
1787
    uint32_t* to_end,
1788
    uint32_t*& to_nxt,
1789
    unsigned long Maxcode = 0x10FFFF,
1790
    codecvt_mode mode     = codecvt_mode(0)) {
1791
  frm_nxt = frm;
1792
  to_nxt  = to;
1793
  if (mode & consume_header) {
1794
    if (frm_end - frm_nxt >= 3 && frm_nxt[0] == 0xEF && frm_nxt[1] == 0xBB && frm_nxt[2] == 0xBF)
1795
      frm_nxt += 3;
1796
  }
1797
  for (; frm_nxt < frm_end && to_nxt < to_end; ++to_nxt) {
1798
    uint8_t c1 = *frm_nxt;
1799
    if (c1 > Maxcode)
1800
      return codecvt_base::error;
1801
    if (c1 < 0x80) {
1802
      *to_nxt = static_cast<uint32_t>(c1);
1803
      ++frm_nxt;
1804
    } else if (c1 < 0xC2) {
1805
      return codecvt_base::error;
1806
    } else if (c1 < 0xE0) {
1807
      if (frm_end - frm_nxt < 2)
1808
        return codecvt_base::partial;
1809
      uint8_t c2 = frm_nxt[1];
1810
      if ((c2 & 0xC0) != 0x80)
1811
        return codecvt_base::error;
1812
      uint16_t t = static_cast<uint16_t>(((c1 & 0x1F) << 6) | (c2 & 0x3F));
1813
      if (t > Maxcode)
1814
        return codecvt_base::error;
1815
      *to_nxt = static_cast<uint32_t>(t);
1816
      frm_nxt += 2;
1817
    } else if (c1 < 0xF0) {
1818
      if (frm_end - frm_nxt < 2)
1819
        return codecvt_base::partial;
1820
      uint8_t c2 = frm_nxt[1];
1821
      switch (c1) {
1822
      case 0xE0:
1823
        if ((c2 & 0xE0) != 0xA0)
1824
          return codecvt_base::error;
1825
        break;
1826
      case 0xED:
1827
        if ((c2 & 0xE0) != 0x80)
1828
          return codecvt_base::error;
1829
        break;
1830
      default:
1831
        if ((c2 & 0xC0) != 0x80)
1832
          return codecvt_base::error;
1833
        break;
1834
      }
1835
      if (frm_end - frm_nxt < 3)
1836
        return codecvt_base::partial;
1837
      uint8_t c3 = frm_nxt[2];
1838
      if ((c3 & 0xC0) != 0x80)
1839
        return codecvt_base::error;
1840
      uint16_t t = static_cast<uint16_t>(((c1 & 0x0F) << 12) | ((c2 & 0x3F) << 6) | (c3 & 0x3F));
1841
      if (t > Maxcode)
1842
        return codecvt_base::error;
1843
      *to_nxt = static_cast<uint32_t>(t);
1844
      frm_nxt += 3;
1845
    } else if (c1 < 0xF5) {
1846
      if (frm_end - frm_nxt < 2)
1847
        return codecvt_base::partial;
1848
      uint8_t c2 = frm_nxt[1];
1849
      switch (c1) {
1850
      case 0xF0:
1851
        if (!(0x90 <= c2 && c2 <= 0xBF))
1852
          return codecvt_base::error;
1853
        break;
1854
      case 0xF4:
1855
        if ((c2 & 0xF0) != 0x80)
1856
          return codecvt_base::error;
1857
        break;
1858
      default:
1859
        if ((c2 & 0xC0) != 0x80)
1860
          return codecvt_base::error;
1861
        break;
1862
      }
1863
      if (frm_end - frm_nxt < 3)
1864
        return codecvt_base::partial;
1865
      uint8_t c3 = frm_nxt[2];
1866
      if ((c3 & 0xC0) != 0x80)
1867
        return codecvt_base::error;
1868
      if (frm_end - frm_nxt < 4)
1869
        return codecvt_base::partial;
1870
      uint8_t c4 = frm_nxt[3];
1871
      if ((c4 & 0xC0) != 0x80)
1872
        return codecvt_base::error;
1873
      if (to_end - to_nxt < 2)
1874
        return codecvt_base::partial;
1875
      if ((((c1 & 7UL) << 18) + ((c2 & 0x3FUL) << 12) + ((c3 & 0x3FUL) << 6) + (c4 & 0x3F)) > Maxcode)
1876
        return codecvt_base::error;
1877
      *to_nxt = static_cast<uint32_t>(
1878
          0xD800 | (((((c1 & 0x07) << 2) | ((c2 & 0x30) >> 4)) - 1) << 6) | ((c2 & 0x0F) << 2) | ((c3 & 0x30) >> 4));
1879
      *++to_nxt = static_cast<uint32_t>(0xDC00 | ((c3 & 0x0F) << 6) | (c4 & 0x3F));
1880
      frm_nxt += 4;
1881
    } else {
1882
      return codecvt_base::error;
1883
    }
1884
  }
1885
  return frm_nxt < frm_end ? codecvt_base::partial : codecvt_base::ok;
1886
}
1887

1888
static int utf8_to_utf16_length(
1889
    const uint8_t* frm,
1890
    const uint8_t* frm_end,
1891
    size_t mx,
1892
    unsigned long Maxcode = 0x10FFFF,
1893
    codecvt_mode mode     = codecvt_mode(0)) {
1894
  const uint8_t* frm_nxt = frm;
1895
  if (mode & consume_header) {
1896
    if (frm_end - frm_nxt >= 3 && frm_nxt[0] == 0xEF && frm_nxt[1] == 0xBB && frm_nxt[2] == 0xBF)
1897
      frm_nxt += 3;
1898
  }
1899
  for (size_t nchar16_t = 0; frm_nxt < frm_end && nchar16_t < mx; ++nchar16_t) {
1900
    uint8_t c1 = *frm_nxt;
1901
    if (c1 > Maxcode)
1902
      break;
1903
    if (c1 < 0x80) {
1904
      ++frm_nxt;
1905
    } else if (c1 < 0xC2) {
1906
      break;
1907
    } else if (c1 < 0xE0) {
1908
      if ((frm_end - frm_nxt < 2) || (frm_nxt[1] & 0xC0) != 0x80)
1909
        break;
1910
      uint16_t t = static_cast<uint16_t>(((c1 & 0x1F) << 6) | (frm_nxt[1] & 0x3F));
1911
      if (t > Maxcode)
1912
        break;
1913
      frm_nxt += 2;
1914
    } else if (c1 < 0xF0) {
1915
      if (frm_end - frm_nxt < 3)
1916
        break;
1917
      uint8_t c2 = frm_nxt[1];
1918
      uint8_t c3 = frm_nxt[2];
1919
      switch (c1) {
1920
      case 0xE0:
1921
        if ((c2 & 0xE0) != 0xA0)
1922
          return static_cast<int>(frm_nxt - frm);
1923
        break;
1924
      case 0xED:
1925
        if ((c2 & 0xE0) != 0x80)
1926
          return static_cast<int>(frm_nxt - frm);
1927
        break;
1928
      default:
1929
        if ((c2 & 0xC0) != 0x80)
1930
          return static_cast<int>(frm_nxt - frm);
1931
        break;
1932
      }
1933
      if ((c3 & 0xC0) != 0x80)
1934
        break;
1935
      if ((((c1 & 0x0Fu) << 12) | ((c2 & 0x3Fu) << 6) | (c3 & 0x3Fu)) > Maxcode)
1936
        break;
1937
      frm_nxt += 3;
1938
    } else if (c1 < 0xF5) {
1939
      if (frm_end - frm_nxt < 4 || mx - nchar16_t < 2)
1940
        break;
1941
      uint8_t c2 = frm_nxt[1];
1942
      uint8_t c3 = frm_nxt[2];
1943
      uint8_t c4 = frm_nxt[3];
1944
      switch (c1) {
1945
      case 0xF0:
1946
        if (!(0x90 <= c2 && c2 <= 0xBF))
1947
          return static_cast<int>(frm_nxt - frm);
1948
        break;
1949
      case 0xF4:
1950
        if ((c2 & 0xF0) != 0x80)
1951
          return static_cast<int>(frm_nxt - frm);
1952
        break;
1953
      default:
1954
        if ((c2 & 0xC0) != 0x80)
1955
          return static_cast<int>(frm_nxt - frm);
1956
        break;
1957
      }
1958
      if ((c3 & 0xC0) != 0x80 || (c4 & 0xC0) != 0x80)
1959
        break;
1960
      if ((((c1 & 7UL) << 18) + ((c2 & 0x3FUL) << 12) + ((c3 & 0x3FUL) << 6) + (c4 & 0x3F)) > Maxcode)
1961
        break;
1962
      ++nchar16_t;
1963
      frm_nxt += 4;
1964
    } else {
1965
      break;
1966
    }
1967
  }
1968
  return static_cast<int>(frm_nxt - frm);
1969
}
1970

1971
static codecvt_base::result ucs4_to_utf8(
1972
    const uint32_t* frm,
1973
    const uint32_t* frm_end,
1974
    const uint32_t*& frm_nxt,
1975
    uint8_t* to,
1976
    uint8_t* to_end,
1977
    uint8_t*& to_nxt,
1978
    unsigned long Maxcode = 0x10FFFF,
1979
    codecvt_mode mode     = codecvt_mode(0)) {
1980
  frm_nxt = frm;
1981
  to_nxt  = to;
1982
  if (mode & generate_header) {
1983
    if (to_end - to_nxt < 3)
1984
      return codecvt_base::partial;
1985
    *to_nxt++ = static_cast<uint8_t>(0xEF);
1986
    *to_nxt++ = static_cast<uint8_t>(0xBB);
1987
    *to_nxt++ = static_cast<uint8_t>(0xBF);
1988
  }
1989
  for (; frm_nxt < frm_end; ++frm_nxt) {
1990
    uint32_t wc = *frm_nxt;
1991
    if ((wc & 0xFFFFF800) == 0x00D800 || wc > Maxcode)
1992
      return codecvt_base::error;
1993
    if (wc < 0x000080) {
1994
      if (to_end - to_nxt < 1)
1995
        return codecvt_base::partial;
1996
      *to_nxt++ = static_cast<uint8_t>(wc);
1997
    } else if (wc < 0x000800) {
1998
      if (to_end - to_nxt < 2)
1999
        return codecvt_base::partial;
2000
      *to_nxt++ = static_cast<uint8_t>(0xC0 | (wc >> 6));
2001
      *to_nxt++ = static_cast<uint8_t>(0x80 | (wc & 0x03F));
2002
    } else if (wc < 0x010000) {
2003
      if (to_end - to_nxt < 3)
2004
        return codecvt_base::partial;
2005
      *to_nxt++ = static_cast<uint8_t>(0xE0 | (wc >> 12));
2006
      *to_nxt++ = static_cast<uint8_t>(0x80 | ((wc & 0x0FC0) >> 6));
2007
      *to_nxt++ = static_cast<uint8_t>(0x80 | (wc & 0x003F));
2008
    } else // if (wc < 0x110000)
2009
    {
2010
      if (to_end - to_nxt < 4)
2011
        return codecvt_base::partial;
2012
      *to_nxt++ = static_cast<uint8_t>(0xF0 | (wc >> 18));
2013
      *to_nxt++ = static_cast<uint8_t>(0x80 | ((wc & 0x03F000) >> 12));
2014
      *to_nxt++ = static_cast<uint8_t>(0x80 | ((wc & 0x000FC0) >> 6));
2015
      *to_nxt++ = static_cast<uint8_t>(0x80 | (wc & 0x00003F));
2016
    }
2017
  }
2018
  return codecvt_base::ok;
2019
}
2020

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

2124
static int utf8_to_ucs4_length(
2125
    const uint8_t* frm,
2126
    const uint8_t* frm_end,
2127
    size_t mx,
2128
    unsigned long Maxcode = 0x10FFFF,
2129
    codecvt_mode mode     = codecvt_mode(0)) {
2130
  const uint8_t* frm_nxt = frm;
2131
  if (mode & consume_header) {
2132
    if (frm_end - frm_nxt >= 3 && frm_nxt[0] == 0xEF && frm_nxt[1] == 0xBB && frm_nxt[2] == 0xBF)
2133
      frm_nxt += 3;
2134
  }
2135
  for (size_t nchar32_t = 0; frm_nxt < frm_end && nchar32_t < mx; ++nchar32_t) {
2136
    uint8_t c1 = static_cast<uint8_t>(*frm_nxt);
2137
    if (c1 < 0x80) {
2138
      if (c1 > Maxcode)
2139
        break;
2140
      ++frm_nxt;
2141
    } else if (c1 < 0xC2) {
2142
      break;
2143
    } else if (c1 < 0xE0) {
2144
      if ((frm_end - frm_nxt < 2) || ((frm_nxt[1] & 0xC0) != 0x80))
2145
        break;
2146
      if ((((c1 & 0x1Fu) << 6) | (frm_nxt[1] & 0x3Fu)) > Maxcode)
2147
        break;
2148
      frm_nxt += 2;
2149
    } else if (c1 < 0xF0) {
2150
      if (frm_end - frm_nxt < 3)
2151
        break;
2152
      uint8_t c2 = frm_nxt[1];
2153
      uint8_t c3 = frm_nxt[2];
2154
      switch (c1) {
2155
      case 0xE0:
2156
        if ((c2 & 0xE0) != 0xA0)
2157
          return static_cast<int>(frm_nxt - frm);
2158
        break;
2159
      case 0xED:
2160
        if ((c2 & 0xE0) != 0x80)
2161
          return static_cast<int>(frm_nxt - frm);
2162
        break;
2163
      default:
2164
        if ((c2 & 0xC0) != 0x80)
2165
          return static_cast<int>(frm_nxt - frm);
2166
        break;
2167
      }
2168
      if ((c3 & 0xC0) != 0x80)
2169
        break;
2170
      if ((((c1 & 0x0Fu) << 12) | ((c2 & 0x3Fu) << 6) | (c3 & 0x3Fu)) > Maxcode)
2171
        break;
2172
      frm_nxt += 3;
2173
    } else if (c1 < 0xF5) {
2174
      if (frm_end - frm_nxt < 4)
2175
        break;
2176
      uint8_t c2 = frm_nxt[1];
2177
      uint8_t c3 = frm_nxt[2];
2178
      uint8_t c4 = frm_nxt[3];
2179
      switch (c1) {
2180
      case 0xF0:
2181
        if (!(0x90 <= c2 && c2 <= 0xBF))
2182
          return static_cast<int>(frm_nxt - frm);
2183
        break;
2184
      case 0xF4:
2185
        if ((c2 & 0xF0) != 0x80)
2186
          return static_cast<int>(frm_nxt - frm);
2187
        break;
2188
      default:
2189
        if ((c2 & 0xC0) != 0x80)
2190
          return static_cast<int>(frm_nxt - frm);
2191
        break;
2192
      }
2193
      if ((c3 & 0xC0) != 0x80 || (c4 & 0xC0) != 0x80)
2194
        break;
2195
      if ((((c1 & 0x07u) << 18) | ((c2 & 0x3Fu) << 12) | ((c3 & 0x3Fu) << 6) | (c4 & 0x3Fu)) > Maxcode)
2196
        break;
2197
      frm_nxt += 4;
2198
    } else {
2199
      break;
2200
    }
2201
  }
2202
  return static_cast<int>(frm_nxt - frm);
2203
}
2204

2205
static codecvt_base::result ucs2_to_utf8(
2206
    const uint16_t* frm,
2207
    const uint16_t* frm_end,
2208
    const uint16_t*& frm_nxt,
2209
    uint8_t* to,
2210
    uint8_t* to_end,
2211
    uint8_t*& to_nxt,
2212
    unsigned long Maxcode = 0x10FFFF,
2213
    codecvt_mode mode     = codecvt_mode(0)) {
2214
  frm_nxt = frm;
2215
  to_nxt  = to;
2216
  if (mode & generate_header) {
2217
    if (to_end - to_nxt < 3)
2218
      return codecvt_base::partial;
2219
    *to_nxt++ = static_cast<uint8_t>(0xEF);
2220
    *to_nxt++ = static_cast<uint8_t>(0xBB);
2221
    *to_nxt++ = static_cast<uint8_t>(0xBF);
2222
  }
2223
  for (; frm_nxt < frm_end; ++frm_nxt) {
2224
    uint16_t wc = *frm_nxt;
2225
    if ((wc & 0xF800) == 0xD800 || wc > Maxcode)
2226
      return codecvt_base::error;
2227
    if (wc < 0x0080) {
2228
      if (to_end - to_nxt < 1)
2229
        return codecvt_base::partial;
2230
      *to_nxt++ = static_cast<uint8_t>(wc);
2231
    } else if (wc < 0x0800) {
2232
      if (to_end - to_nxt < 2)
2233
        return codecvt_base::partial;
2234
      *to_nxt++ = static_cast<uint8_t>(0xC0 | (wc >> 6));
2235
      *to_nxt++ = static_cast<uint8_t>(0x80 | (wc & 0x03F));
2236
    } else // if (wc <= 0xFFFF)
2237
    {
2238
      if (to_end - to_nxt < 3)
2239
        return codecvt_base::partial;
2240
      *to_nxt++ = static_cast<uint8_t>(0xE0 | (wc >> 12));
2241
      *to_nxt++ = static_cast<uint8_t>(0x80 | ((wc & 0x0FC0) >> 6));
2242
      *to_nxt++ = static_cast<uint8_t>(0x80 | (wc & 0x003F));
2243
    }
2244
  }
2245
  return codecvt_base::ok;
2246
}
2247

2248
static codecvt_base::result utf8_to_ucs2(
2249
    const uint8_t* frm,
2250
    const uint8_t* frm_end,
2251
    const uint8_t*& frm_nxt,
2252
    uint16_t* to,
2253
    uint16_t* to_end,
2254
    uint16_t*& to_nxt,
2255
    unsigned long Maxcode = 0x10FFFF,
2256
    codecvt_mode mode     = codecvt_mode(0)) {
2257
  frm_nxt = frm;
2258
  to_nxt  = to;
2259
  if (mode & consume_header) {
2260
    if (frm_end - frm_nxt >= 3 && frm_nxt[0] == 0xEF && frm_nxt[1] == 0xBB && frm_nxt[2] == 0xBF)
2261
      frm_nxt += 3;
2262
  }
2263
  for (; frm_nxt < frm_end && to_nxt < to_end; ++to_nxt) {
2264
    uint8_t c1 = static_cast<uint8_t>(*frm_nxt);
2265
    if (c1 < 0x80) {
2266
      if (c1 > Maxcode)
2267
        return codecvt_base::error;
2268
      *to_nxt = static_cast<uint16_t>(c1);
2269
      ++frm_nxt;
2270
    } else if (c1 < 0xC2) {
2271
      return codecvt_base::error;
2272
    } else if (c1 < 0xE0) {
2273
      if (frm_end - frm_nxt < 2)
2274
        return codecvt_base::partial;
2275
      uint8_t c2 = frm_nxt[1];
2276
      if ((c2 & 0xC0) != 0x80)
2277
        return codecvt_base::error;
2278
      uint16_t t = static_cast<uint16_t>(((c1 & 0x1F) << 6) | (c2 & 0x3F));
2279
      if (t > Maxcode)
2280
        return codecvt_base::error;
2281
      *to_nxt = t;
2282
      frm_nxt += 2;
2283
    } else if (c1 < 0xF0) {
2284
      if (frm_end - frm_nxt < 2)
2285
        return codecvt_base::partial;
2286
      uint8_t c2 = frm_nxt[1];
2287
      switch (c1) {
2288
      case 0xE0:
2289
        if ((c2 & 0xE0) != 0xA0)
2290
          return codecvt_base::error;
2291
        break;
2292
      case 0xED:
2293
        if ((c2 & 0xE0) != 0x80)
2294
          return codecvt_base::error;
2295
        break;
2296
      default:
2297
        if ((c2 & 0xC0) != 0x80)
2298
          return codecvt_base::error;
2299
        break;
2300
      }
2301
      if (frm_end - frm_nxt < 3)
2302
        return codecvt_base::partial;
2303
      uint8_t c3 = frm_nxt[2];
2304
      if ((c3 & 0xC0) != 0x80)
2305
        return codecvt_base::error;
2306
      uint16_t t = static_cast<uint16_t>(((c1 & 0x0F) << 12) | ((c2 & 0x3F) << 6) | (c3 & 0x3F));
2307
      if (t > Maxcode)
2308
        return codecvt_base::error;
2309
      *to_nxt = t;
2310
      frm_nxt += 3;
2311
    } else {
2312
      return codecvt_base::error;
2313
    }
2314
  }
2315
  return frm_nxt < frm_end ? codecvt_base::partial : codecvt_base::ok;
2316
}
2317

2318
static int utf8_to_ucs2_length(
2319
    const uint8_t* frm,
2320
    const uint8_t* frm_end,
2321
    size_t mx,
2322
    unsigned long Maxcode = 0x10FFFF,
2323
    codecvt_mode mode     = codecvt_mode(0)) {
2324
  const uint8_t* frm_nxt = frm;
2325
  if (mode & consume_header) {
2326
    if (frm_end - frm_nxt >= 3 && frm_nxt[0] == 0xEF && frm_nxt[1] == 0xBB && frm_nxt[2] == 0xBF)
2327
      frm_nxt += 3;
2328
  }
2329
  for (size_t nchar32_t = 0; frm_nxt < frm_end && nchar32_t < mx; ++nchar32_t) {
2330
    uint8_t c1 = static_cast<uint8_t>(*frm_nxt);
2331
    if (c1 < 0x80) {
2332
      if (c1 > Maxcode)
2333
        break;
2334
      ++frm_nxt;
2335
    } else if (c1 < 0xC2) {
2336
      break;
2337
    } else if (c1 < 0xE0) {
2338
      if ((frm_end - frm_nxt < 2) || ((frm_nxt[1] & 0xC0) != 0x80))
2339
        break;
2340
      if ((((c1 & 0x1Fu) << 6) | (frm_nxt[1] & 0x3Fu)) > Maxcode)
2341
        break;
2342
      frm_nxt += 2;
2343
    } else if (c1 < 0xF0) {
2344
      if (frm_end - frm_nxt < 3)
2345
        break;
2346
      uint8_t c2 = frm_nxt[1];
2347
      uint8_t c3 = frm_nxt[2];
2348
      switch (c1) {
2349
      case 0xE0:
2350
        if ((c2 & 0xE0) != 0xA0)
2351
          return static_cast<int>(frm_nxt - frm);
2352
        break;
2353
      case 0xED:
2354
        if ((c2 & 0xE0) != 0x80)
2355
          return static_cast<int>(frm_nxt - frm);
2356
        break;
2357
      default:
2358
        if ((c2 & 0xC0) != 0x80)
2359
          return static_cast<int>(frm_nxt - frm);
2360
        break;
2361
      }
2362
      if ((c3 & 0xC0) != 0x80)
2363
        break;
2364
      if ((((c1 & 0x0Fu) << 12) | ((c2 & 0x3Fu) << 6) | (c3 & 0x3Fu)) > Maxcode)
2365
        break;
2366
      frm_nxt += 3;
2367
    } else {
2368
      break;
2369
    }
2370
  }
2371
  return static_cast<int>(frm_nxt - frm);
2372
}
2373

2374
static codecvt_base::result ucs4_to_utf16be(
2375
    const uint32_t* frm,
2376
    const uint32_t* frm_end,
2377
    const uint32_t*& frm_nxt,
2378
    uint8_t* to,
2379
    uint8_t* to_end,
2380
    uint8_t*& to_nxt,
2381
    unsigned long Maxcode = 0x10FFFF,
2382
    codecvt_mode mode     = codecvt_mode(0)) {
2383
  frm_nxt = frm;
2384
  to_nxt  = to;
2385
  if (mode & generate_header) {
2386
    if (to_end - to_nxt < 2)
2387
      return codecvt_base::partial;
2388
    *to_nxt++ = static_cast<uint8_t>(0xFE);
2389
    *to_nxt++ = static_cast<uint8_t>(0xFF);
2390
  }
2391
  for (; frm_nxt < frm_end; ++frm_nxt) {
2392
    uint32_t wc = *frm_nxt;
2393
    if ((wc & 0xFFFFF800) == 0x00D800 || wc > Maxcode)
2394
      return codecvt_base::error;
2395
    if (wc < 0x010000) {
2396
      if (to_end - to_nxt < 2)
2397
        return codecvt_base::partial;
2398
      *to_nxt++ = static_cast<uint8_t>(wc >> 8);
2399
      *to_nxt++ = static_cast<uint8_t>(wc);
2400
    } else {
2401
      if (to_end - to_nxt < 4)
2402
        return codecvt_base::partial;
2403
      uint16_t t = static_cast<uint16_t>(0xD800 | ((((wc & 0x1F0000) >> 16) - 1) << 6) | ((wc & 0x00FC00) >> 10));
2404
      *to_nxt++  = static_cast<uint8_t>(t >> 8);
2405
      *to_nxt++  = static_cast<uint8_t>(t);
2406
      t          = static_cast<uint16_t>(0xDC00 | (wc & 0x03FF));
2407
      *to_nxt++  = static_cast<uint8_t>(t >> 8);
2408
      *to_nxt++  = static_cast<uint8_t>(t);
2409
    }
2410
  }
2411
  return codecvt_base::ok;
2412
}
2413

2414
static codecvt_base::result utf16be_to_ucs4(
2415
    const uint8_t* frm,
2416
    const uint8_t* frm_end,
2417
    const uint8_t*& frm_nxt,
2418
    uint32_t* to,
2419
    uint32_t* to_end,
2420
    uint32_t*& to_nxt,
2421
    unsigned long Maxcode = 0x10FFFF,
2422
    codecvt_mode mode     = codecvt_mode(0)) {
2423
  frm_nxt = frm;
2424
  to_nxt  = to;
2425
  if (mode & consume_header) {
2426
    if (frm_end - frm_nxt >= 2 && frm_nxt[0] == 0xFE && frm_nxt[1] == 0xFF)
2427
      frm_nxt += 2;
2428
  }
2429
  for (; frm_nxt < frm_end - 1 && to_nxt < to_end; ++to_nxt) {
2430
    uint16_t c1 = static_cast<uint16_t>(frm_nxt[0] << 8 | frm_nxt[1]);
2431
    if ((c1 & 0xFC00) == 0xDC00)
2432
      return codecvt_base::error;
2433
    if ((c1 & 0xFC00) != 0xD800) {
2434
      if (c1 > Maxcode)
2435
        return codecvt_base::error;
2436
      *to_nxt = static_cast<uint32_t>(c1);
2437
      frm_nxt += 2;
2438
    } else {
2439
      if (frm_end - frm_nxt < 4)
2440
        return codecvt_base::partial;
2441
      uint16_t c2 = static_cast<uint16_t>(frm_nxt[2] << 8 | frm_nxt[3]);
2442
      if ((c2 & 0xFC00) != 0xDC00)
2443
        return codecvt_base::error;
2444
      uint32_t t = static_cast<uint32_t>(((((c1 & 0x03C0) >> 6) + 1) << 16) | ((c1 & 0x003F) << 10) | (c2 & 0x03FF));
2445
      if (t > Maxcode)
2446
        return codecvt_base::error;
2447
      *to_nxt = t;
2448
      frm_nxt += 4;
2449
    }
2450
  }
2451
  return frm_nxt < frm_end ? codecvt_base::partial : codecvt_base::ok;
2452
}
2453

2454
static int utf16be_to_ucs4_length(
2455
    const uint8_t* frm,
2456
    const uint8_t* frm_end,
2457
    size_t mx,
2458
    unsigned long Maxcode = 0x10FFFF,
2459
    codecvt_mode mode     = codecvt_mode(0)) {
2460
  const uint8_t* frm_nxt = frm;
2461
  if (mode & consume_header) {
2462
    if (frm_end - frm_nxt >= 2 && frm_nxt[0] == 0xFE && frm_nxt[1] == 0xFF)
2463
      frm_nxt += 2;
2464
  }
2465
  for (size_t nchar32_t = 0; frm_nxt < frm_end - 1 && nchar32_t < mx; ++nchar32_t) {
2466
    uint16_t c1 = static_cast<uint16_t>(frm_nxt[0] << 8 | frm_nxt[1]);
2467
    if ((c1 & 0xFC00) == 0xDC00)
2468
      break;
2469
    if ((c1 & 0xFC00) != 0xD800) {
2470
      if (c1 > Maxcode)
2471
        break;
2472
      frm_nxt += 2;
2473
    } else {
2474
      if (frm_end - frm_nxt < 4)
2475
        break;
2476
      uint16_t c2 = static_cast<uint16_t>(frm_nxt[2] << 8 | frm_nxt[3]);
2477
      if ((c2 & 0xFC00) != 0xDC00)
2478
        break;
2479
      uint32_t t = static_cast<uint32_t>(((((c1 & 0x03C0) >> 6) + 1) << 16) | ((c1 & 0x003F) << 10) | (c2 & 0x03FF));
2480
      if (t > Maxcode)
2481
        break;
2482
      frm_nxt += 4;
2483
    }
2484
  }
2485
  return static_cast<int>(frm_nxt - frm);
2486
}
2487

2488
static codecvt_base::result ucs4_to_utf16le(
2489
    const uint32_t* frm,
2490
    const uint32_t* frm_end,
2491
    const uint32_t*& frm_nxt,
2492
    uint8_t* to,
2493
    uint8_t* to_end,
2494
    uint8_t*& to_nxt,
2495
    unsigned long Maxcode = 0x10FFFF,
2496
    codecvt_mode mode     = codecvt_mode(0)) {
2497
  frm_nxt = frm;
2498
  to_nxt  = to;
2499
  if (mode & generate_header) {
2500
    if (to_end - to_nxt < 2)
2501
      return codecvt_base::partial;
2502
    *to_nxt++ = static_cast<uint8_t>(0xFF);
2503
    *to_nxt++ = static_cast<uint8_t>(0xFE);
2504
  }
2505
  for (; frm_nxt < frm_end; ++frm_nxt) {
2506
    uint32_t wc = *frm_nxt;
2507
    if ((wc & 0xFFFFF800) == 0x00D800 || wc > Maxcode)
2508
      return codecvt_base::error;
2509
    if (wc < 0x010000) {
2510
      if (to_end - to_nxt < 2)
2511
        return codecvt_base::partial;
2512
      *to_nxt++ = static_cast<uint8_t>(wc);
2513
      *to_nxt++ = static_cast<uint8_t>(wc >> 8);
2514
    } else {
2515
      if (to_end - to_nxt < 4)
2516
        return codecvt_base::partial;
2517
      uint16_t t = static_cast<uint16_t>(0xD800 | ((((wc & 0x1F0000) >> 16) - 1) << 6) | ((wc & 0x00FC00) >> 10));
2518
      *to_nxt++  = static_cast<uint8_t>(t);
2519
      *to_nxt++  = static_cast<uint8_t>(t >> 8);
2520
      t          = static_cast<uint16_t>(0xDC00 | (wc & 0x03FF));
2521
      *to_nxt++  = static_cast<uint8_t>(t);
2522
      *to_nxt++  = static_cast<uint8_t>(t >> 8);
2523
    }
2524
  }
2525
  return codecvt_base::ok;
2526
}
2527

2528
static codecvt_base::result utf16le_to_ucs4(
2529
    const uint8_t* frm,
2530
    const uint8_t* frm_end,
2531
    const uint8_t*& frm_nxt,
2532
    uint32_t* to,
2533
    uint32_t* to_end,
2534
    uint32_t*& to_nxt,
2535
    unsigned long Maxcode = 0x10FFFF,
2536
    codecvt_mode mode     = codecvt_mode(0)) {
2537
  frm_nxt = frm;
2538
  to_nxt  = to;
2539
  if (mode & consume_header) {
2540
    if (frm_end - frm_nxt >= 2 && frm_nxt[0] == 0xFF && frm_nxt[1] == 0xFE)
2541
      frm_nxt += 2;
2542
  }
2543
  for (; frm_nxt < frm_end - 1 && to_nxt < to_end; ++to_nxt) {
2544
    uint16_t c1 = static_cast<uint16_t>(frm_nxt[1] << 8 | frm_nxt[0]);
2545
    if ((c1 & 0xFC00) == 0xDC00)
2546
      return codecvt_base::error;
2547
    if ((c1 & 0xFC00) != 0xD800) {
2548
      if (c1 > Maxcode)
2549
        return codecvt_base::error;
2550
      *to_nxt = static_cast<uint32_t>(c1);
2551
      frm_nxt += 2;
2552
    } else {
2553
      if (frm_end - frm_nxt < 4)
2554
        return codecvt_base::partial;
2555
      uint16_t c2 = static_cast<uint16_t>(frm_nxt[3] << 8 | frm_nxt[2]);
2556
      if ((c2 & 0xFC00) != 0xDC00)
2557
        return codecvt_base::error;
2558
      uint32_t t = static_cast<uint32_t>(((((c1 & 0x03C0) >> 6) + 1) << 16) | ((c1 & 0x003F) << 10) | (c2 & 0x03FF));
2559
      if (t > Maxcode)
2560
        return codecvt_base::error;
2561
      *to_nxt = t;
2562
      frm_nxt += 4;
2563
    }
2564
  }
2565
  return frm_nxt < frm_end ? codecvt_base::partial : codecvt_base::ok;
2566
}
2567

2568
static int utf16le_to_ucs4_length(
2569
    const uint8_t* frm,
2570
    const uint8_t* frm_end,
2571
    size_t mx,
2572
    unsigned long Maxcode = 0x10FFFF,
2573
    codecvt_mode mode     = codecvt_mode(0)) {
2574
  const uint8_t* frm_nxt = frm;
2575
  if (mode & consume_header) {
2576
    if (frm_end - frm_nxt >= 2 && frm_nxt[0] == 0xFF && frm_nxt[1] == 0xFE)
2577
      frm_nxt += 2;
2578
  }
2579
  for (size_t nchar32_t = 0; frm_nxt < frm_end - 1 && nchar32_t < mx; ++nchar32_t) {
2580
    uint16_t c1 = static_cast<uint16_t>(frm_nxt[1] << 8 | frm_nxt[0]);
2581
    if ((c1 & 0xFC00) == 0xDC00)
2582
      break;
2583
    if ((c1 & 0xFC00) != 0xD800) {
2584
      if (c1 > Maxcode)
2585
        break;
2586
      frm_nxt += 2;
2587
    } else {
2588
      if (frm_end - frm_nxt < 4)
2589
        break;
2590
      uint16_t c2 = static_cast<uint16_t>(frm_nxt[3] << 8 | frm_nxt[2]);
2591
      if ((c2 & 0xFC00) != 0xDC00)
2592
        break;
2593
      uint32_t t = static_cast<uint32_t>(((((c1 & 0x03C0) >> 6) + 1) << 16) | ((c1 & 0x003F) << 10) | (c2 & 0x03FF));
2594
      if (t > Maxcode)
2595
        break;
2596
      frm_nxt += 4;
2597
    }
2598
  }
2599
  return static_cast<int>(frm_nxt - frm);
2600
}
2601

2602
static codecvt_base::result ucs2_to_utf16be(
2603
    const uint16_t* frm,
2604
    const uint16_t* frm_end,
2605
    const uint16_t*& frm_nxt,
2606
    uint8_t* to,
2607
    uint8_t* to_end,
2608
    uint8_t*& to_nxt,
2609
    unsigned long Maxcode = 0x10FFFF,
2610
    codecvt_mode mode     = codecvt_mode(0)) {
2611
  frm_nxt = frm;
2612
  to_nxt  = to;
2613
  if (mode & generate_header) {
2614
    if (to_end - to_nxt < 2)
2615
      return codecvt_base::partial;
2616
    *to_nxt++ = static_cast<uint8_t>(0xFE);
2617
    *to_nxt++ = static_cast<uint8_t>(0xFF);
2618
  }
2619
  for (; frm_nxt < frm_end; ++frm_nxt) {
2620
    uint16_t wc = *frm_nxt;
2621
    if ((wc & 0xF800) == 0xD800 || wc > Maxcode)
2622
      return codecvt_base::error;
2623
    if (to_end - to_nxt < 2)
2624
      return codecvt_base::partial;
2625
    *to_nxt++ = static_cast<uint8_t>(wc >> 8);
2626
    *to_nxt++ = static_cast<uint8_t>(wc);
2627
  }
2628
  return codecvt_base::ok;
2629
}
2630

2631
static codecvt_base::result utf16be_to_ucs2(
2632
    const uint8_t* frm,
2633
    const uint8_t* frm_end,
2634
    const uint8_t*& frm_nxt,
2635
    uint16_t* to,
2636
    uint16_t* to_end,
2637
    uint16_t*& to_nxt,
2638
    unsigned long Maxcode = 0x10FFFF,
2639
    codecvt_mode mode     = codecvt_mode(0)) {
2640
  frm_nxt = frm;
2641
  to_nxt  = to;
2642
  if (mode & consume_header) {
2643
    if (frm_end - frm_nxt >= 2 && frm_nxt[0] == 0xFE && frm_nxt[1] == 0xFF)
2644
      frm_nxt += 2;
2645
  }
2646
  for (; frm_nxt < frm_end - 1 && to_nxt < to_end; ++to_nxt) {
2647
    uint16_t c1 = static_cast<uint16_t>(frm_nxt[0] << 8 | frm_nxt[1]);
2648
    if ((c1 & 0xF800) == 0xD800 || c1 > Maxcode)
2649
      return codecvt_base::error;
2650
    *to_nxt = c1;
2651
    frm_nxt += 2;
2652
  }
2653
  return frm_nxt < frm_end ? codecvt_base::partial : codecvt_base::ok;
2654
}
2655

2656
static int utf16be_to_ucs2_length(
2657
    const uint8_t* frm,
2658
    const uint8_t* frm_end,
2659
    size_t mx,
2660
    unsigned long Maxcode = 0x10FFFF,
2661
    codecvt_mode mode     = codecvt_mode(0)) {
2662
  const uint8_t* frm_nxt = frm;
2663
  if (mode & consume_header) {
2664
    if (frm_end - frm_nxt >= 2 && frm_nxt[0] == 0xFE && frm_nxt[1] == 0xFF)
2665
      frm_nxt += 2;
2666
  }
2667
  for (size_t nchar16_t = 0; frm_nxt < frm_end - 1 && nchar16_t < mx; ++nchar16_t) {
2668
    uint16_t c1 = static_cast<uint16_t>(frm_nxt[0] << 8 | frm_nxt[1]);
2669
    if ((c1 & 0xF800) == 0xD800 || c1 > Maxcode)
2670
      break;
2671
    frm_nxt += 2;
2672
  }
2673
  return static_cast<int>(frm_nxt - frm);
2674
}
2675

2676
static codecvt_base::result ucs2_to_utf16le(
2677
    const uint16_t* frm,
2678
    const uint16_t* frm_end,
2679
    const uint16_t*& frm_nxt,
2680
    uint8_t* to,
2681
    uint8_t* to_end,
2682
    uint8_t*& to_nxt,
2683
    unsigned long Maxcode = 0x10FFFF,
2684
    codecvt_mode mode     = codecvt_mode(0)) {
2685
  frm_nxt = frm;
2686
  to_nxt  = to;
2687
  if (mode & generate_header) {
2688
    if (to_end - to_nxt < 2)
2689
      return codecvt_base::partial;
2690
    *to_nxt++ = static_cast<uint8_t>(0xFF);
2691
    *to_nxt++ = static_cast<uint8_t>(0xFE);
2692
  }
2693
  for (; frm_nxt < frm_end; ++frm_nxt) {
2694
    uint16_t wc = *frm_nxt;
2695
    if ((wc & 0xF800) == 0xD800 || wc > Maxcode)
2696
      return codecvt_base::error;
2697
    if (to_end - to_nxt < 2)
2698
      return codecvt_base::partial;
2699
    *to_nxt++ = static_cast<uint8_t>(wc);
2700
    *to_nxt++ = static_cast<uint8_t>(wc >> 8);
2701
  }
2702
  return codecvt_base::ok;
2703
}
2704

2705
static codecvt_base::result utf16le_to_ucs2(
2706
    const uint8_t* frm,
2707
    const uint8_t* frm_end,
2708
    const uint8_t*& frm_nxt,
2709
    uint16_t* to,
2710
    uint16_t* to_end,
2711
    uint16_t*& to_nxt,
2712
    unsigned long Maxcode = 0x10FFFF,
2713
    codecvt_mode mode     = codecvt_mode(0)) {
2714
  frm_nxt = frm;
2715
  to_nxt  = to;
2716
  if (mode & consume_header) {
2717
    if (frm_end - frm_nxt >= 2 && frm_nxt[0] == 0xFF && frm_nxt[1] == 0xFE)
2718
      frm_nxt += 2;
2719
  }
2720
  for (; frm_nxt < frm_end - 1 && to_nxt < to_end; ++to_nxt) {
2721
    uint16_t c1 = static_cast<uint16_t>(frm_nxt[1] << 8 | frm_nxt[0]);
2722
    if ((c1 & 0xF800) == 0xD800 || c1 > Maxcode)
2723
      return codecvt_base::error;
2724
    *to_nxt = c1;
2725
    frm_nxt += 2;
2726
  }
2727
  return frm_nxt < frm_end ? codecvt_base::partial : codecvt_base::ok;
2728
}
2729

2730
static int utf16le_to_ucs2_length(
2731
    const uint8_t* frm,
2732
    const uint8_t* frm_end,
2733
    size_t mx,
2734
    unsigned long Maxcode = 0x10FFFF,
2735
    codecvt_mode mode     = codecvt_mode(0)) {
2736
  const uint8_t* frm_nxt = frm;
2737
  frm_nxt                = frm;
2738
  if (mode & consume_header) {
2739
    if (frm_end - frm_nxt >= 2 && frm_nxt[0] == 0xFF && frm_nxt[1] == 0xFE)
2740
      frm_nxt += 2;
2741
  }
2742
  for (size_t nchar16_t = 0; frm_nxt < frm_end - 1 && nchar16_t < mx; ++nchar16_t) {
2743
    uint16_t c1 = static_cast<uint16_t>(frm_nxt[1] << 8 | frm_nxt[0]);
2744
    if ((c1 & 0xF800) == 0xD800 || c1 > Maxcode)
2745
      break;
2746
    frm_nxt += 2;
2747
  }
2748
  return static_cast<int>(frm_nxt - frm);
2749
}
2750

2751
_LIBCPP_SUPPRESS_DEPRECATED_POP
2752

2753
// template <> class codecvt<char16_t, char, mbstate_t>
2754

2755
constinit locale::id codecvt<char16_t, char, mbstate_t>::id;
2756

2757
codecvt<char16_t, char, mbstate_t>::~codecvt() {}
2758

2759
codecvt<char16_t, char, mbstate_t>::result codecvt<char16_t, char, mbstate_t>::do_out(
2760
    state_type&,
2761
    const intern_type* frm,
2762
    const intern_type* frm_end,
2763
    const intern_type*& frm_nxt,
2764
    extern_type* to,
2765
    extern_type* to_end,
2766
    extern_type*& to_nxt) const {
2767
  const uint16_t* _frm     = reinterpret_cast<const uint16_t*>(frm);
2768
  const uint16_t* _frm_end = reinterpret_cast<const uint16_t*>(frm_end);
2769
  const uint16_t* _frm_nxt = _frm;
2770
  uint8_t* _to             = reinterpret_cast<uint8_t*>(to);
2771
  uint8_t* _to_end         = reinterpret_cast<uint8_t*>(to_end);
2772
  uint8_t* _to_nxt         = _to;
2773
  result r                 = utf16_to_utf8(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt);
2774
  frm_nxt                  = frm + (_frm_nxt - _frm);
2775
  to_nxt                   = to + (_to_nxt - _to);
2776
  return r;
2777
}
2778

2779
codecvt<char16_t, char, mbstate_t>::result codecvt<char16_t, char, mbstate_t>::do_in(
2780
    state_type&,
2781
    const extern_type* frm,
2782
    const extern_type* frm_end,
2783
    const extern_type*& frm_nxt,
2784
    intern_type* to,
2785
    intern_type* to_end,
2786
    intern_type*& to_nxt) const {
2787
  const uint8_t* _frm     = reinterpret_cast<const uint8_t*>(frm);
2788
  const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
2789
  const uint8_t* _frm_nxt = _frm;
2790
  uint16_t* _to           = reinterpret_cast<uint16_t*>(to);
2791
  uint16_t* _to_end       = reinterpret_cast<uint16_t*>(to_end);
2792
  uint16_t* _to_nxt       = _to;
2793
  result r                = utf8_to_utf16(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt);
2794
  frm_nxt                 = frm + (_frm_nxt - _frm);
2795
  to_nxt                  = to + (_to_nxt - _to);
2796
  return r;
2797
}
2798

2799
codecvt<char16_t, char, mbstate_t>::result
2800
codecvt<char16_t, char, mbstate_t>::do_unshift(state_type&, extern_type* to, extern_type*, extern_type*& to_nxt) const {
2801
  to_nxt = to;
2802
  return noconv;
2803
}
2804

2805
int codecvt<char16_t, char, mbstate_t>::do_encoding() const noexcept { return 0; }
2806

2807
bool codecvt<char16_t, char, mbstate_t>::do_always_noconv() const noexcept { return false; }
2808

2809
int codecvt<char16_t, char, mbstate_t>::do_length(
2810
    state_type&, const extern_type* frm, const extern_type* frm_end, size_t mx) const {
2811
  const uint8_t* _frm     = reinterpret_cast<const uint8_t*>(frm);
2812
  const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
2813
  return utf8_to_utf16_length(_frm, _frm_end, mx);
2814
}
2815

2816
int codecvt<char16_t, char, mbstate_t>::do_max_length() const noexcept { return 4; }
2817

2818
#ifndef _LIBCPP_HAS_NO_CHAR8_T
2819

2820
// template <> class codecvt<char16_t, char8_t, mbstate_t>
2821

2822
constinit locale::id codecvt<char16_t, char8_t, mbstate_t>::id;
2823

2824
codecvt<char16_t, char8_t, mbstate_t>::~codecvt() {}
2825

2826
codecvt<char16_t, char8_t, mbstate_t>::result codecvt<char16_t, char8_t, mbstate_t>::do_out(
2827
    state_type&,
2828
    const intern_type* frm,
2829
    const intern_type* frm_end,
2830
    const intern_type*& frm_nxt,
2831
    extern_type* to,
2832
    extern_type* to_end,
2833
    extern_type*& to_nxt) const {
2834
  const uint16_t* _frm     = reinterpret_cast<const uint16_t*>(frm);
2835
  const uint16_t* _frm_end = reinterpret_cast<const uint16_t*>(frm_end);
2836
  const uint16_t* _frm_nxt = _frm;
2837
  uint8_t* _to             = reinterpret_cast<uint8_t*>(to);
2838
  uint8_t* _to_end         = reinterpret_cast<uint8_t*>(to_end);
2839
  uint8_t* _to_nxt         = _to;
2840
  result r                 = utf16_to_utf8(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt);
2841
  frm_nxt                  = frm + (_frm_nxt - _frm);
2842
  to_nxt                   = to + (_to_nxt - _to);
2843
  return r;
2844
}
2845

2846
codecvt<char16_t, char8_t, mbstate_t>::result codecvt<char16_t, char8_t, mbstate_t>::do_in(
2847
    state_type&,
2848
    const extern_type* frm,
2849
    const extern_type* frm_end,
2850
    const extern_type*& frm_nxt,
2851
    intern_type* to,
2852
    intern_type* to_end,
2853
    intern_type*& to_nxt) const {
2854
  const uint8_t* _frm     = reinterpret_cast<const uint8_t*>(frm);
2855
  const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
2856
  const uint8_t* _frm_nxt = _frm;
2857
  uint16_t* _to           = reinterpret_cast<uint16_t*>(to);
2858
  uint16_t* _to_end       = reinterpret_cast<uint16_t*>(to_end);
2859
  uint16_t* _to_nxt       = _to;
2860
  result r                = utf8_to_utf16(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt);
2861
  frm_nxt                 = frm + (_frm_nxt - _frm);
2862
  to_nxt                  = to + (_to_nxt - _to);
2863
  return r;
2864
}
2865

2866
codecvt<char16_t, char8_t, mbstate_t>::result codecvt<char16_t, char8_t, mbstate_t>::do_unshift(
2867
    state_type&, extern_type* to, extern_type*, extern_type*& to_nxt) const {
2868
  to_nxt = to;
2869
  return noconv;
2870
}
2871

2872
int codecvt<char16_t, char8_t, mbstate_t>::do_encoding() const noexcept { return 0; }
2873

2874
bool codecvt<char16_t, char8_t, mbstate_t>::do_always_noconv() const noexcept { return false; }
2875

2876
int codecvt<char16_t, char8_t, mbstate_t>::do_length(
2877
    state_type&, const extern_type* frm, const extern_type* frm_end, size_t mx) const {
2878
  const uint8_t* _frm     = reinterpret_cast<const uint8_t*>(frm);
2879
  const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
2880
  return utf8_to_utf16_length(_frm, _frm_end, mx);
2881
}
2882

2883
int codecvt<char16_t, char8_t, mbstate_t>::do_max_length() const noexcept { return 4; }
2884

2885
#endif
2886

2887
// template <> class codecvt<char32_t, char, mbstate_t>
2888

2889
constinit locale::id codecvt<char32_t, char, mbstate_t>::id;
2890

2891
codecvt<char32_t, char, mbstate_t>::~codecvt() {}
2892

2893
codecvt<char32_t, char, mbstate_t>::result codecvt<char32_t, char, mbstate_t>::do_out(
2894
    state_type&,
2895
    const intern_type* frm,
2896
    const intern_type* frm_end,
2897
    const intern_type*& frm_nxt,
2898
    extern_type* to,
2899
    extern_type* to_end,
2900
    extern_type*& to_nxt) const {
2901
  const uint32_t* _frm     = reinterpret_cast<const uint32_t*>(frm);
2902
  const uint32_t* _frm_end = reinterpret_cast<const uint32_t*>(frm_end);
2903
  const uint32_t* _frm_nxt = _frm;
2904
  uint8_t* _to             = reinterpret_cast<uint8_t*>(to);
2905
  uint8_t* _to_end         = reinterpret_cast<uint8_t*>(to_end);
2906
  uint8_t* _to_nxt         = _to;
2907
  result r                 = ucs4_to_utf8(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt);
2908
  frm_nxt                  = frm + (_frm_nxt - _frm);
2909
  to_nxt                   = to + (_to_nxt - _to);
2910
  return r;
2911
}
2912

2913
codecvt<char32_t, char, mbstate_t>::result codecvt<char32_t, char, mbstate_t>::do_in(
2914
    state_type&,
2915
    const extern_type* frm,
2916
    const extern_type* frm_end,
2917
    const extern_type*& frm_nxt,
2918
    intern_type* to,
2919
    intern_type* to_end,
2920
    intern_type*& to_nxt) const {
2921
  const uint8_t* _frm     = reinterpret_cast<const uint8_t*>(frm);
2922
  const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
2923
  const uint8_t* _frm_nxt = _frm;
2924
  uint32_t* _to           = reinterpret_cast<uint32_t*>(to);
2925
  uint32_t* _to_end       = reinterpret_cast<uint32_t*>(to_end);
2926
  uint32_t* _to_nxt       = _to;
2927
  result r                = utf8_to_ucs4(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt);
2928
  frm_nxt                 = frm + (_frm_nxt - _frm);
2929
  to_nxt                  = to + (_to_nxt - _to);
2930
  return r;
2931
}
2932

2933
codecvt<char32_t, char, mbstate_t>::result
2934
codecvt<char32_t, char, mbstate_t>::do_unshift(state_type&, extern_type* to, extern_type*, extern_type*& to_nxt) const {
2935
  to_nxt = to;
2936
  return noconv;
2937
}
2938

2939
int codecvt<char32_t, char, mbstate_t>::do_encoding() const noexcept { return 0; }
2940

2941
bool codecvt<char32_t, char, mbstate_t>::do_always_noconv() const noexcept { return false; }
2942

2943
int codecvt<char32_t, char, mbstate_t>::do_length(
2944
    state_type&, const extern_type* frm, const extern_type* frm_end, size_t mx) const {
2945
  const uint8_t* _frm     = reinterpret_cast<const uint8_t*>(frm);
2946
  const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
2947
  return utf8_to_ucs4_length(_frm, _frm_end, mx);
2948
}
2949

2950
int codecvt<char32_t, char, mbstate_t>::do_max_length() const noexcept { return 4; }
2951

2952
#ifndef _LIBCPP_HAS_NO_CHAR8_T
2953

2954
// template <> class codecvt<char32_t, char8_t, mbstate_t>
2955

2956
constinit locale::id codecvt<char32_t, char8_t, mbstate_t>::id;
2957

2958
codecvt<char32_t, char8_t, mbstate_t>::~codecvt() {}
2959

2960
codecvt<char32_t, char8_t, mbstate_t>::result codecvt<char32_t, char8_t, mbstate_t>::do_out(
2961
    state_type&,
2962
    const intern_type* frm,
2963
    const intern_type* frm_end,
2964
    const intern_type*& frm_nxt,
2965
    extern_type* to,
2966
    extern_type* to_end,
2967
    extern_type*& to_nxt) const {
2968
  const uint32_t* _frm     = reinterpret_cast<const uint32_t*>(frm);
2969
  const uint32_t* _frm_end = reinterpret_cast<const uint32_t*>(frm_end);
2970
  const uint32_t* _frm_nxt = _frm;
2971
  uint8_t* _to             = reinterpret_cast<uint8_t*>(to);
2972
  uint8_t* _to_end         = reinterpret_cast<uint8_t*>(to_end);
2973
  uint8_t* _to_nxt         = _to;
2974
  result r                 = ucs4_to_utf8(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt);
2975
  frm_nxt                  = frm + (_frm_nxt - _frm);
2976
  to_nxt                   = to + (_to_nxt - _to);
2977
  return r;
2978
}
2979

2980
codecvt<char32_t, char8_t, mbstate_t>::result codecvt<char32_t, char8_t, mbstate_t>::do_in(
2981
    state_type&,
2982
    const extern_type* frm,
2983
    const extern_type* frm_end,
2984
    const extern_type*& frm_nxt,
2985
    intern_type* to,
2986
    intern_type* to_end,
2987
    intern_type*& to_nxt) const {
2988
  const uint8_t* _frm     = reinterpret_cast<const uint8_t*>(frm);
2989
  const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
2990
  const uint8_t* _frm_nxt = _frm;
2991
  uint32_t* _to           = reinterpret_cast<uint32_t*>(to);
2992
  uint32_t* _to_end       = reinterpret_cast<uint32_t*>(to_end);
2993
  uint32_t* _to_nxt       = _to;
2994
  result r                = utf8_to_ucs4(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt);
2995
  frm_nxt                 = frm + (_frm_nxt - _frm);
2996
  to_nxt                  = to + (_to_nxt - _to);
2997
  return r;
2998
}
2999

3000
codecvt<char32_t, char8_t, mbstate_t>::result codecvt<char32_t, char8_t, mbstate_t>::do_unshift(
3001
    state_type&, extern_type* to, extern_type*, extern_type*& to_nxt) const {
3002
  to_nxt = to;
3003
  return noconv;
3004
}
3005

3006
int codecvt<char32_t, char8_t, mbstate_t>::do_encoding() const noexcept { return 0; }
3007

3008
bool codecvt<char32_t, char8_t, mbstate_t>::do_always_noconv() const noexcept { return false; }
3009

3010
int codecvt<char32_t, char8_t, mbstate_t>::do_length(
3011
    state_type&, const extern_type* frm, const extern_type* frm_end, size_t mx) const {
3012
  const uint8_t* _frm     = reinterpret_cast<const uint8_t*>(frm);
3013
  const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
3014
  return utf8_to_ucs4_length(_frm, _frm_end, mx);
3015
}
3016

3017
int codecvt<char32_t, char8_t, mbstate_t>::do_max_length() const noexcept { return 4; }
3018

3019
#endif
3020

3021
// __codecvt_utf8<wchar_t>
3022

3023
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
3024
__codecvt_utf8<wchar_t>::result __codecvt_utf8<wchar_t>::do_out(
3025
    state_type&,
3026
    const intern_type* frm,
3027
    const intern_type* frm_end,
3028
    const intern_type*& frm_nxt,
3029
    extern_type* to,
3030
    extern_type* to_end,
3031
    extern_type*& to_nxt) const {
3032
#  if defined(_LIBCPP_SHORT_WCHAR)
3033
  const uint16_t* _frm     = reinterpret_cast<const uint16_t*>(frm);
3034
  const uint16_t* _frm_end = reinterpret_cast<const uint16_t*>(frm_end);
3035
  const uint16_t* _frm_nxt = _frm;
3036
#  else
3037
  const uint32_t* _frm     = reinterpret_cast<const uint32_t*>(frm);
3038
  const uint32_t* _frm_end = reinterpret_cast<const uint32_t*>(frm_end);
3039
  const uint32_t* _frm_nxt = _frm;
3040
#  endif
3041
  uint8_t* _to     = reinterpret_cast<uint8_t*>(to);
3042
  uint8_t* _to_end = reinterpret_cast<uint8_t*>(to_end);
3043
  uint8_t* _to_nxt = _to;
3044
#  if defined(_LIBCPP_SHORT_WCHAR)
3045
  result r = ucs2_to_utf8(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt, __maxcode_, __mode_);
3046
#  else
3047
  result r = ucs4_to_utf8(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt, __maxcode_, __mode_);
3048
#  endif
3049
  frm_nxt = frm + (_frm_nxt - _frm);
3050
  to_nxt  = to + (_to_nxt - _to);
3051
  return r;
3052
}
3053

3054
__codecvt_utf8<wchar_t>::result __codecvt_utf8<wchar_t>::do_in(
3055
    state_type&,
3056
    const extern_type* frm,
3057
    const extern_type* frm_end,
3058
    const extern_type*& frm_nxt,
3059
    intern_type* to,
3060
    intern_type* to_end,
3061
    intern_type*& to_nxt) const {
3062
  const uint8_t* _frm     = reinterpret_cast<const uint8_t*>(frm);
3063
  const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
3064
  const uint8_t* _frm_nxt = _frm;
3065
#  if defined(_LIBCPP_SHORT_WCHAR)
3066
  uint16_t* _to     = reinterpret_cast<uint16_t*>(to);
3067
  uint16_t* _to_end = reinterpret_cast<uint16_t*>(to_end);
3068
  uint16_t* _to_nxt = _to;
3069
  result r          = utf8_to_ucs2(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt, __maxcode_, __mode_);
3070
#  else
3071
  uint32_t* _to     = reinterpret_cast<uint32_t*>(to);
3072
  uint32_t* _to_end = reinterpret_cast<uint32_t*>(to_end);
3073
  uint32_t* _to_nxt = _to;
3074
  result r          = utf8_to_ucs4(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt, __maxcode_, __mode_);
3075
#  endif
3076
  frm_nxt = frm + (_frm_nxt - _frm);
3077
  to_nxt  = to + (_to_nxt - _to);
3078
  return r;
3079
}
3080

3081
__codecvt_utf8<wchar_t>::result
3082
__codecvt_utf8<wchar_t>::do_unshift(state_type&, extern_type* to, extern_type*, extern_type*& to_nxt) const {
3083
  to_nxt = to;
3084
  return noconv;
3085
}
3086

3087
int __codecvt_utf8<wchar_t>::do_encoding() const noexcept { return 0; }
3088

3089
bool __codecvt_utf8<wchar_t>::do_always_noconv() const noexcept { return false; }
3090

3091
int __codecvt_utf8<wchar_t>::do_length(
3092
    state_type&, const extern_type* frm, const extern_type* frm_end, size_t mx) const {
3093
  const uint8_t* _frm     = reinterpret_cast<const uint8_t*>(frm);
3094
  const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
3095
#  if defined(_LIBCPP_SHORT_WCHAR)
3096
  return utf8_to_ucs2_length(_frm, _frm_end, mx, __maxcode_, __mode_);
3097
#  else
3098
  return utf8_to_ucs4_length(_frm, _frm_end, mx, __maxcode_, __mode_);
3099
#  endif
3100
}
3101

3102
_LIBCPP_SUPPRESS_DEPRECATED_PUSH
3103
int __codecvt_utf8<wchar_t>::do_max_length() const noexcept {
3104
#  if defined(_LIBCPP_SHORT_WCHAR)
3105
  if (__mode_ & consume_header)
3106
    return 6;
3107
  return 3;
3108
#  else
3109
  if (__mode_ & consume_header)
3110
    return 7;
3111
  return 4;
3112
#  endif
3113
}
3114
#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
3115

3116
// __codecvt_utf8<char16_t>
3117

3118
__codecvt_utf8<char16_t>::result __codecvt_utf8<char16_t>::do_out(
3119
    state_type&,
3120
    const intern_type* frm,
3121
    const intern_type* frm_end,
3122
    const intern_type*& frm_nxt,
3123
    extern_type* to,
3124
    extern_type* to_end,
3125
    extern_type*& to_nxt) const {
3126
  const uint16_t* _frm     = reinterpret_cast<const uint16_t*>(frm);
3127
  const uint16_t* _frm_end = reinterpret_cast<const uint16_t*>(frm_end);
3128
  const uint16_t* _frm_nxt = _frm;
3129
  uint8_t* _to             = reinterpret_cast<uint8_t*>(to);
3130
  uint8_t* _to_end         = reinterpret_cast<uint8_t*>(to_end);
3131
  uint8_t* _to_nxt         = _to;
3132
  result r                 = ucs2_to_utf8(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt, __maxcode_, __mode_);
3133
  frm_nxt                  = frm + (_frm_nxt - _frm);
3134
  to_nxt                   = to + (_to_nxt - _to);
3135
  return r;
3136
}
3137

3138
__codecvt_utf8<char16_t>::result __codecvt_utf8<char16_t>::do_in(
3139
    state_type&,
3140
    const extern_type* frm,
3141
    const extern_type* frm_end,
3142
    const extern_type*& frm_nxt,
3143
    intern_type* to,
3144
    intern_type* to_end,
3145
    intern_type*& to_nxt) const {
3146
  const uint8_t* _frm     = reinterpret_cast<const uint8_t*>(frm);
3147
  const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
3148
  const uint8_t* _frm_nxt = _frm;
3149
  uint16_t* _to           = reinterpret_cast<uint16_t*>(to);
3150
  uint16_t* _to_end       = reinterpret_cast<uint16_t*>(to_end);
3151
  uint16_t* _to_nxt       = _to;
3152
  result r                = utf8_to_ucs2(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt, __maxcode_, __mode_);
3153
  frm_nxt                 = frm + (_frm_nxt - _frm);
3154
  to_nxt                  = to + (_to_nxt - _to);
3155
  return r;
3156
}
3157

3158
__codecvt_utf8<char16_t>::result
3159
__codecvt_utf8<char16_t>::do_unshift(state_type&, extern_type* to, extern_type*, extern_type*& to_nxt) const {
3160
  to_nxt = to;
3161
  return noconv;
3162
}
3163

3164
int __codecvt_utf8<char16_t>::do_encoding() const noexcept { return 0; }
3165

3166
bool __codecvt_utf8<char16_t>::do_always_noconv() const noexcept { return false; }
3167

3168
int __codecvt_utf8<char16_t>::do_length(
3169
    state_type&, const extern_type* frm, const extern_type* frm_end, size_t mx) const {
3170
  const uint8_t* _frm     = reinterpret_cast<const uint8_t*>(frm);
3171
  const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
3172
  return utf8_to_ucs2_length(_frm, _frm_end, mx, __maxcode_, __mode_);
3173
}
3174

3175
_LIBCPP_SUPPRESS_DEPRECATED_PUSH
3176
int __codecvt_utf8<char16_t>::do_max_length() const noexcept {
3177
  if (__mode_ & consume_header)
3178
    return 6;
3179
  return 3;
3180
}
3181
_LIBCPP_SUPPRESS_DEPRECATED_POP
3182

3183
// __codecvt_utf8<char32_t>
3184

3185
__codecvt_utf8<char32_t>::result __codecvt_utf8<char32_t>::do_out(
3186
    state_type&,
3187
    const intern_type* frm,
3188
    const intern_type* frm_end,
3189
    const intern_type*& frm_nxt,
3190
    extern_type* to,
3191
    extern_type* to_end,
3192
    extern_type*& to_nxt) const {
3193
  const uint32_t* _frm     = reinterpret_cast<const uint32_t*>(frm);
3194
  const uint32_t* _frm_end = reinterpret_cast<const uint32_t*>(frm_end);
3195
  const uint32_t* _frm_nxt = _frm;
3196
  uint8_t* _to             = reinterpret_cast<uint8_t*>(to);
3197
  uint8_t* _to_end         = reinterpret_cast<uint8_t*>(to_end);
3198
  uint8_t* _to_nxt         = _to;
3199
  result r                 = ucs4_to_utf8(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt, __maxcode_, __mode_);
3200
  frm_nxt                  = frm + (_frm_nxt - _frm);
3201
  to_nxt                   = to + (_to_nxt - _to);
3202
  return r;
3203
}
3204

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

3225
__codecvt_utf8<char32_t>::result
3226
__codecvt_utf8<char32_t>::do_unshift(state_type&, extern_type* to, extern_type*, extern_type*& to_nxt) const {
3227
  to_nxt = to;
3228
  return noconv;
3229
}
3230

3231
int __codecvt_utf8<char32_t>::do_encoding() const noexcept { return 0; }
3232

3233
bool __codecvt_utf8<char32_t>::do_always_noconv() const noexcept { return false; }
3234

3235
int __codecvt_utf8<char32_t>::do_length(
3236
    state_type&, const extern_type* frm, const extern_type* frm_end, size_t mx) const {
3237
  const uint8_t* _frm     = reinterpret_cast<const uint8_t*>(frm);
3238
  const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
3239
  return utf8_to_ucs4_length(_frm, _frm_end, mx, __maxcode_, __mode_);
3240
}
3241

3242
_LIBCPP_SUPPRESS_DEPRECATED_PUSH
3243
int __codecvt_utf8<char32_t>::do_max_length() const noexcept {
3244
  if (__mode_ & consume_header)
3245
    return 7;
3246
  return 4;
3247
}
3248
_LIBCPP_SUPPRESS_DEPRECATED_POP
3249

3250
// __codecvt_utf16<wchar_t, false>
3251

3252
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
3253
__codecvt_utf16<wchar_t, false>::result __codecvt_utf16<wchar_t, false>::do_out(
3254
    state_type&,
3255
    const intern_type* frm,
3256
    const intern_type* frm_end,
3257
    const intern_type*& frm_nxt,
3258
    extern_type* to,
3259
    extern_type* to_end,
3260
    extern_type*& to_nxt) const {
3261
#  if defined(_LIBCPP_SHORT_WCHAR)
3262
  const uint16_t* _frm     = reinterpret_cast<const uint16_t*>(frm);
3263
  const uint16_t* _frm_end = reinterpret_cast<const uint16_t*>(frm_end);
3264
  const uint16_t* _frm_nxt = _frm;
3265
#  else
3266
  const uint32_t* _frm     = reinterpret_cast<const uint32_t*>(frm);
3267
  const uint32_t* _frm_end = reinterpret_cast<const uint32_t*>(frm_end);
3268
  const uint32_t* _frm_nxt = _frm;
3269
#  endif
3270
  uint8_t* _to     = reinterpret_cast<uint8_t*>(to);
3271
  uint8_t* _to_end = reinterpret_cast<uint8_t*>(to_end);
3272
  uint8_t* _to_nxt = _to;
3273
#  if defined(_LIBCPP_SHORT_WCHAR)
3274
  result r = ucs2_to_utf16be(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt, __maxcode_, __mode_);
3275
#  else
3276
  result r = ucs4_to_utf16be(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt, __maxcode_, __mode_);
3277
#  endif
3278
  frm_nxt = frm + (_frm_nxt - _frm);
3279
  to_nxt  = to + (_to_nxt - _to);
3280
  return r;
3281
}
3282

3283
__codecvt_utf16<wchar_t, false>::result __codecvt_utf16<wchar_t, false>::do_in(
3284
    state_type&,
3285
    const extern_type* frm,
3286
    const extern_type* frm_end,
3287
    const extern_type*& frm_nxt,
3288
    intern_type* to,
3289
    intern_type* to_end,
3290
    intern_type*& to_nxt) const {
3291
  const uint8_t* _frm     = reinterpret_cast<const uint8_t*>(frm);
3292
  const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
3293
  const uint8_t* _frm_nxt = _frm;
3294
#  if defined(_LIBCPP_SHORT_WCHAR)
3295
  uint16_t* _to     = reinterpret_cast<uint16_t*>(to);
3296
  uint16_t* _to_end = reinterpret_cast<uint16_t*>(to_end);
3297
  uint16_t* _to_nxt = _to;
3298
  result r          = utf16be_to_ucs2(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt, __maxcode_, __mode_);
3299
#  else
3300
  uint32_t* _to     = reinterpret_cast<uint32_t*>(to);
3301
  uint32_t* _to_end = reinterpret_cast<uint32_t*>(to_end);
3302
  uint32_t* _to_nxt = _to;
3303
  result r          = utf16be_to_ucs4(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt, __maxcode_, __mode_);
3304
#  endif
3305
  frm_nxt = frm + (_frm_nxt - _frm);
3306
  to_nxt  = to + (_to_nxt - _to);
3307
  return r;
3308
}
3309

3310
__codecvt_utf16<wchar_t, false>::result
3311
__codecvt_utf16<wchar_t, false>::do_unshift(state_type&, extern_type* to, extern_type*, extern_type*& to_nxt) const {
3312
  to_nxt = to;
3313
  return noconv;
3314
}
3315

3316
int __codecvt_utf16<wchar_t, false>::do_encoding() const noexcept { return 0; }
3317

3318
bool __codecvt_utf16<wchar_t, false>::do_always_noconv() const noexcept { return false; }
3319

3320
int __codecvt_utf16<wchar_t, false>::do_length(
3321
    state_type&, const extern_type* frm, const extern_type* frm_end, size_t mx) const {
3322
  const uint8_t* _frm     = reinterpret_cast<const uint8_t*>(frm);
3323
  const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
3324
#  if defined(_LIBCPP_SHORT_WCHAR)
3325
  return utf16be_to_ucs2_length(_frm, _frm_end, mx, __maxcode_, __mode_);
3326
#  else
3327
  return utf16be_to_ucs4_length(_frm, _frm_end, mx, __maxcode_, __mode_);
3328
#  endif
3329
}
3330

3331
int __codecvt_utf16<wchar_t, false>::do_max_length() const noexcept {
3332
#  if defined(_LIBCPP_SHORT_WCHAR)
3333
  if (__mode_ & consume_header)
3334
    return 4;
3335
  return 2;
3336
#  else
3337
  if (__mode_ & consume_header)
3338
    return 6;
3339
  return 4;
3340
#  endif
3341
}
3342

3343
// __codecvt_utf16<wchar_t, true>
3344

3345
__codecvt_utf16<wchar_t, true>::result __codecvt_utf16<wchar_t, true>::do_out(
3346
    state_type&,
3347
    const intern_type* frm,
3348
    const intern_type* frm_end,
3349
    const intern_type*& frm_nxt,
3350
    extern_type* to,
3351
    extern_type* to_end,
3352
    extern_type*& to_nxt) const {
3353
#  if defined(_LIBCPP_SHORT_WCHAR)
3354
  const uint16_t* _frm     = reinterpret_cast<const uint16_t*>(frm);
3355
  const uint16_t* _frm_end = reinterpret_cast<const uint16_t*>(frm_end);
3356
  const uint16_t* _frm_nxt = _frm;
3357
#  else
3358
  const uint32_t* _frm     = reinterpret_cast<const uint32_t*>(frm);
3359
  const uint32_t* _frm_end = reinterpret_cast<const uint32_t*>(frm_end);
3360
  const uint32_t* _frm_nxt = _frm;
3361
#  endif
3362
  uint8_t* _to     = reinterpret_cast<uint8_t*>(to);
3363
  uint8_t* _to_end = reinterpret_cast<uint8_t*>(to_end);
3364
  uint8_t* _to_nxt = _to;
3365
#  if defined(_LIBCPP_SHORT_WCHAR)
3366
  result r = ucs2_to_utf16le(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt, __maxcode_, __mode_);
3367
#  else
3368
  result r = ucs4_to_utf16le(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt, __maxcode_, __mode_);
3369
#  endif
3370
  frm_nxt = frm + (_frm_nxt - _frm);
3371
  to_nxt  = to + (_to_nxt - _to);
3372
  return r;
3373
}
3374

3375
__codecvt_utf16<wchar_t, true>::result __codecvt_utf16<wchar_t, true>::do_in(
3376
    state_type&,
3377
    const extern_type* frm,
3378
    const extern_type* frm_end,
3379
    const extern_type*& frm_nxt,
3380
    intern_type* to,
3381
    intern_type* to_end,
3382
    intern_type*& to_nxt) const {
3383
  const uint8_t* _frm     = reinterpret_cast<const uint8_t*>(frm);
3384
  const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
3385
  const uint8_t* _frm_nxt = _frm;
3386
#  if defined(_LIBCPP_SHORT_WCHAR)
3387
  uint16_t* _to     = reinterpret_cast<uint16_t*>(to);
3388
  uint16_t* _to_end = reinterpret_cast<uint16_t*>(to_end);
3389
  uint16_t* _to_nxt = _to;
3390
  result r          = utf16le_to_ucs2(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt, __maxcode_, __mode_);
3391
#  else
3392
  uint32_t* _to     = reinterpret_cast<uint32_t*>(to);
3393
  uint32_t* _to_end = reinterpret_cast<uint32_t*>(to_end);
3394
  uint32_t* _to_nxt = _to;
3395
  result r          = utf16le_to_ucs4(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt, __maxcode_, __mode_);
3396
#  endif
3397
  frm_nxt = frm + (_frm_nxt - _frm);
3398
  to_nxt  = to + (_to_nxt - _to);
3399
  return r;
3400
}
3401

3402
__codecvt_utf16<wchar_t, true>::result
3403
__codecvt_utf16<wchar_t, true>::do_unshift(state_type&, extern_type* to, extern_type*, extern_type*& to_nxt) const {
3404
  to_nxt = to;
3405
  return noconv;
3406
}
3407

3408
int __codecvt_utf16<wchar_t, true>::do_encoding() const noexcept { return 0; }
3409

3410
bool __codecvt_utf16<wchar_t, true>::do_always_noconv() const noexcept { return false; }
3411

3412
int __codecvt_utf16<wchar_t, true>::do_length(
3413
    state_type&, const extern_type* frm, const extern_type* frm_end, size_t mx) const {
3414
  const uint8_t* _frm     = reinterpret_cast<const uint8_t*>(frm);
3415
  const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
3416
#  if defined(_LIBCPP_SHORT_WCHAR)
3417
  return utf16le_to_ucs2_length(_frm, _frm_end, mx, __maxcode_, __mode_);
3418
#  else
3419
  return utf16le_to_ucs4_length(_frm, _frm_end, mx, __maxcode_, __mode_);
3420
#  endif
3421
}
3422

3423
int __codecvt_utf16<wchar_t, true>::do_max_length() const noexcept {
3424
#  if defined(_LIBCPP_SHORT_WCHAR)
3425
  if (__mode_ & consume_header)
3426
    return 4;
3427
  return 2;
3428
#  else
3429
  if (__mode_ & consume_header)
3430
    return 6;
3431
  return 4;
3432
#  endif
3433
}
3434
#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
3435

3436
// __codecvt_utf16<char16_t, false>
3437

3438
__codecvt_utf16<char16_t, false>::result __codecvt_utf16<char16_t, false>::do_out(
3439
    state_type&,
3440
    const intern_type* frm,
3441
    const intern_type* frm_end,
3442
    const intern_type*& frm_nxt,
3443
    extern_type* to,
3444
    extern_type* to_end,
3445
    extern_type*& to_nxt) const {
3446
  const uint16_t* _frm     = reinterpret_cast<const uint16_t*>(frm);
3447
  const uint16_t* _frm_end = reinterpret_cast<const uint16_t*>(frm_end);
3448
  const uint16_t* _frm_nxt = _frm;
3449
  uint8_t* _to             = reinterpret_cast<uint8_t*>(to);
3450
  uint8_t* _to_end         = reinterpret_cast<uint8_t*>(to_end);
3451
  uint8_t* _to_nxt         = _to;
3452
  result r                 = ucs2_to_utf16be(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt, __maxcode_, __mode_);
3453
  frm_nxt                  = frm + (_frm_nxt - _frm);
3454
  to_nxt                   = to + (_to_nxt - _to);
3455
  return r;
3456
}
3457

3458
__codecvt_utf16<char16_t, false>::result __codecvt_utf16<char16_t, false>::do_in(
3459
    state_type&,
3460
    const extern_type* frm,
3461
    const extern_type* frm_end,
3462
    const extern_type*& frm_nxt,
3463
    intern_type* to,
3464
    intern_type* to_end,
3465
    intern_type*& to_nxt) const {
3466
  const uint8_t* _frm     = reinterpret_cast<const uint8_t*>(frm);
3467
  const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
3468
  const uint8_t* _frm_nxt = _frm;
3469
  uint16_t* _to           = reinterpret_cast<uint16_t*>(to);
3470
  uint16_t* _to_end       = reinterpret_cast<uint16_t*>(to_end);
3471
  uint16_t* _to_nxt       = _to;
3472
  result r                = utf16be_to_ucs2(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt, __maxcode_, __mode_);
3473
  frm_nxt                 = frm + (_frm_nxt - _frm);
3474
  to_nxt                  = to + (_to_nxt - _to);
3475
  return r;
3476
}
3477

3478
__codecvt_utf16<char16_t, false>::result
3479
__codecvt_utf16<char16_t, false>::do_unshift(state_type&, extern_type* to, extern_type*, extern_type*& to_nxt) const {
3480
  to_nxt = to;
3481
  return noconv;
3482
}
3483

3484
int __codecvt_utf16<char16_t, false>::do_encoding() const noexcept { return 0; }
3485

3486
bool __codecvt_utf16<char16_t, false>::do_always_noconv() const noexcept { return false; }
3487

3488
int __codecvt_utf16<char16_t, false>::do_length(
3489
    state_type&, const extern_type* frm, const extern_type* frm_end, size_t mx) const {
3490
  const uint8_t* _frm     = reinterpret_cast<const uint8_t*>(frm);
3491
  const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
3492
  return utf16be_to_ucs2_length(_frm, _frm_end, mx, __maxcode_, __mode_);
3493
}
3494

3495
_LIBCPP_SUPPRESS_DEPRECATED_PUSH
3496
int __codecvt_utf16<char16_t, false>::do_max_length() const noexcept {
3497
  if (__mode_ & consume_header)
3498
    return 4;
3499
  return 2;
3500
}
3501
_LIBCPP_SUPPRESS_DEPRECATED_POP
3502

3503
// __codecvt_utf16<char16_t, true>
3504

3505
__codecvt_utf16<char16_t, true>::result __codecvt_utf16<char16_t, true>::do_out(
3506
    state_type&,
3507
    const intern_type* frm,
3508
    const intern_type* frm_end,
3509
    const intern_type*& frm_nxt,
3510
    extern_type* to,
3511
    extern_type* to_end,
3512
    extern_type*& to_nxt) const {
3513
  const uint16_t* _frm     = reinterpret_cast<const uint16_t*>(frm);
3514
  const uint16_t* _frm_end = reinterpret_cast<const uint16_t*>(frm_end);
3515
  const uint16_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                 = ucs2_to_utf16le(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt, __maxcode_, __mode_);
3520
  frm_nxt                  = frm + (_frm_nxt - _frm);
3521
  to_nxt                   = to + (_to_nxt - _to);
3522
  return r;
3523
}
3524

3525
__codecvt_utf16<char16_t, true>::result __codecvt_utf16<char16_t, true>::do_in(
3526
    state_type&,
3527
    const extern_type* frm,
3528
    const extern_type* frm_end,
3529
    const extern_type*& frm_nxt,
3530
    intern_type* to,
3531
    intern_type* to_end,
3532
    intern_type*& to_nxt) const {
3533
  const uint8_t* _frm     = reinterpret_cast<const uint8_t*>(frm);
3534
  const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
3535
  const uint8_t* _frm_nxt = _frm;
3536
  uint16_t* _to           = reinterpret_cast<uint16_t*>(to);
3537
  uint16_t* _to_end       = reinterpret_cast<uint16_t*>(to_end);
3538
  uint16_t* _to_nxt       = _to;
3539
  result r                = utf16le_to_ucs2(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt, __maxcode_, __mode_);
3540
  frm_nxt                 = frm + (_frm_nxt - _frm);
3541
  to_nxt                  = to + (_to_nxt - _to);
3542
  return r;
3543
}
3544

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

3551
int __codecvt_utf16<char16_t, true>::do_encoding() const noexcept { return 0; }
3552

3553
bool __codecvt_utf16<char16_t, true>::do_always_noconv() const noexcept { return false; }
3554

3555
int __codecvt_utf16<char16_t, true>::do_length(
3556
    state_type&, const extern_type* frm, const extern_type* frm_end, size_t mx) const {
3557
  const uint8_t* _frm     = reinterpret_cast<const uint8_t*>(frm);
3558
  const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
3559
  return utf16le_to_ucs2_length(_frm, _frm_end, mx, __maxcode_, __mode_);
3560
}
3561

3562
_LIBCPP_SUPPRESS_DEPRECATED_PUSH
3563
int __codecvt_utf16<char16_t, true>::do_max_length() const noexcept {
3564
  if (__mode_ & consume_header)
3565
    return 4;
3566
  return 2;
3567
}
3568
_LIBCPP_SUPPRESS_DEPRECATED_POP
3569

3570
// __codecvt_utf16<char32_t, false>
3571

3572
__codecvt_utf16<char32_t, false>::result __codecvt_utf16<char32_t, false>::do_out(
3573
    state_type&,
3574
    const intern_type* frm,
3575
    const intern_type* frm_end,
3576
    const intern_type*& frm_nxt,
3577
    extern_type* to,
3578
    extern_type* to_end,
3579
    extern_type*& to_nxt) const {
3580
  const uint32_t* _frm     = reinterpret_cast<const uint32_t*>(frm);
3581
  const uint32_t* _frm_end = reinterpret_cast<const uint32_t*>(frm_end);
3582
  const uint32_t* _frm_nxt = _frm;
3583
  uint8_t* _to             = reinterpret_cast<uint8_t*>(to);
3584
  uint8_t* _to_end         = reinterpret_cast<uint8_t*>(to_end);
3585
  uint8_t* _to_nxt         = _to;
3586
  result r                 = ucs4_to_utf16be(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt, __maxcode_, __mode_);
3587
  frm_nxt                  = frm + (_frm_nxt - _frm);
3588
  to_nxt                   = to + (_to_nxt - _to);
3589
  return r;
3590
}
3591

3592
__codecvt_utf16<char32_t, false>::result __codecvt_utf16<char32_t, false>::do_in(
3593
    state_type&,
3594
    const extern_type* frm,
3595
    const extern_type* frm_end,
3596
    const extern_type*& frm_nxt,
3597
    intern_type* to,
3598
    intern_type* to_end,
3599
    intern_type*& to_nxt) const {
3600
  const uint8_t* _frm     = reinterpret_cast<const uint8_t*>(frm);
3601
  const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
3602
  const uint8_t* _frm_nxt = _frm;
3603
  uint32_t* _to           = reinterpret_cast<uint32_t*>(to);
3604
  uint32_t* _to_end       = reinterpret_cast<uint32_t*>(to_end);
3605
  uint32_t* _to_nxt       = _to;
3606
  result r                = utf16be_to_ucs4(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt, __maxcode_, __mode_);
3607
  frm_nxt                 = frm + (_frm_nxt - _frm);
3608
  to_nxt                  = to + (_to_nxt - _to);
3609
  return r;
3610
}
3611

3612
__codecvt_utf16<char32_t, false>::result
3613
__codecvt_utf16<char32_t, false>::do_unshift(state_type&, extern_type* to, extern_type*, extern_type*& to_nxt) const {
3614
  to_nxt = to;
3615
  return noconv;
3616
}
3617

3618
int __codecvt_utf16<char32_t, false>::do_encoding() const noexcept { return 0; }
3619

3620
bool __codecvt_utf16<char32_t, false>::do_always_noconv() const noexcept { return false; }
3621

3622
int __codecvt_utf16<char32_t, false>::do_length(
3623
    state_type&, const extern_type* frm, const extern_type* frm_end, size_t mx) const {
3624
  const uint8_t* _frm     = reinterpret_cast<const uint8_t*>(frm);
3625
  const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
3626
  return utf16be_to_ucs4_length(_frm, _frm_end, mx, __maxcode_, __mode_);
3627
}
3628

3629
_LIBCPP_SUPPRESS_DEPRECATED_PUSH
3630
int __codecvt_utf16<char32_t, false>::do_max_length() const noexcept {
3631
  if (__mode_ & consume_header)
3632
    return 6;
3633
  return 4;
3634
}
3635
_LIBCPP_SUPPRESS_DEPRECATED_POP
3636

3637
// __codecvt_utf16<char32_t, true>
3638

3639
__codecvt_utf16<char32_t, true>::result __codecvt_utf16<char32_t, true>::do_out(
3640
    state_type&,
3641
    const intern_type* frm,
3642
    const intern_type* frm_end,
3643
    const intern_type*& frm_nxt,
3644
    extern_type* to,
3645
    extern_type* to_end,
3646
    extern_type*& to_nxt) const {
3647
  const uint32_t* _frm     = reinterpret_cast<const uint32_t*>(frm);
3648
  const uint32_t* _frm_end = reinterpret_cast<const uint32_t*>(frm_end);
3649
  const uint32_t* _frm_nxt = _frm;
3650
  uint8_t* _to             = reinterpret_cast<uint8_t*>(to);
3651
  uint8_t* _to_end         = reinterpret_cast<uint8_t*>(to_end);
3652
  uint8_t* _to_nxt         = _to;
3653
  result r                 = ucs4_to_utf16le(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt, __maxcode_, __mode_);
3654
  frm_nxt                  = frm + (_frm_nxt - _frm);
3655
  to_nxt                   = to + (_to_nxt - _to);
3656
  return r;
3657
}
3658

3659
__codecvt_utf16<char32_t, true>::result __codecvt_utf16<char32_t, true>::do_in(
3660
    state_type&,
3661
    const extern_type* frm,
3662
    const extern_type* frm_end,
3663
    const extern_type*& frm_nxt,
3664
    intern_type* to,
3665
    intern_type* to_end,
3666
    intern_type*& to_nxt) const {
3667
  const uint8_t* _frm     = reinterpret_cast<const uint8_t*>(frm);
3668
  const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
3669
  const uint8_t* _frm_nxt = _frm;
3670
  uint32_t* _to           = reinterpret_cast<uint32_t*>(to);
3671
  uint32_t* _to_end       = reinterpret_cast<uint32_t*>(to_end);
3672
  uint32_t* _to_nxt       = _to;
3673
  result r                = utf16le_to_ucs4(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt, __maxcode_, __mode_);
3674
  frm_nxt                 = frm + (_frm_nxt - _frm);
3675
  to_nxt                  = to + (_to_nxt - _to);
3676
  return r;
3677
}
3678

3679
__codecvt_utf16<char32_t, true>::result
3680
__codecvt_utf16<char32_t, true>::do_unshift(state_type&, extern_type* to, extern_type*, extern_type*& to_nxt) const {
3681
  to_nxt = to;
3682
  return noconv;
3683
}
3684

3685
int __codecvt_utf16<char32_t, true>::do_encoding() const noexcept { return 0; }
3686

3687
bool __codecvt_utf16<char32_t, true>::do_always_noconv() const noexcept { return false; }
3688

3689
int __codecvt_utf16<char32_t, true>::do_length(
3690
    state_type&, const extern_type* frm, const extern_type* frm_end, size_t mx) const {
3691
  const uint8_t* _frm     = reinterpret_cast<const uint8_t*>(frm);
3692
  const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
3693
  return utf16le_to_ucs4_length(_frm, _frm_end, mx, __maxcode_, __mode_);
3694
}
3695

3696
_LIBCPP_SUPPRESS_DEPRECATED_PUSH
3697
int __codecvt_utf16<char32_t, true>::do_max_length() const noexcept {
3698
  if (__mode_ & consume_header)
3699
    return 6;
3700
  return 4;
3701
}
3702
_LIBCPP_SUPPRESS_DEPRECATED_POP
3703

3704
// __codecvt_utf8_utf16<wchar_t>
3705

3706
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
3707
__codecvt_utf8_utf16<wchar_t>::result __codecvt_utf8_utf16<wchar_t>::do_out(
3708
    state_type&,
3709
    const intern_type* frm,
3710
    const intern_type* frm_end,
3711
    const intern_type*& frm_nxt,
3712
    extern_type* to,
3713
    extern_type* to_end,
3714
    extern_type*& to_nxt) const {
3715
#  if defined(_LIBCPP_SHORT_WCHAR)
3716
  const uint16_t* _frm     = reinterpret_cast<const uint16_t*>(frm);
3717
  const uint16_t* _frm_end = reinterpret_cast<const uint16_t*>(frm_end);
3718
  const uint16_t* _frm_nxt = _frm;
3719
#  else
3720
  const uint32_t* _frm     = reinterpret_cast<const uint32_t*>(frm);
3721
  const uint32_t* _frm_end = reinterpret_cast<const uint32_t*>(frm_end);
3722
  const uint32_t* _frm_nxt = _frm;
3723
#  endif
3724
  uint8_t* _to     = reinterpret_cast<uint8_t*>(to);
3725
  uint8_t* _to_end = reinterpret_cast<uint8_t*>(to_end);
3726
  uint8_t* _to_nxt = _to;
3727
  result r         = utf16_to_utf8(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt, __maxcode_, __mode_);
3728
  frm_nxt          = frm + (_frm_nxt - _frm);
3729
  to_nxt           = to + (_to_nxt - _to);
3730
  return r;
3731
}
3732

3733
__codecvt_utf8_utf16<wchar_t>::result __codecvt_utf8_utf16<wchar_t>::do_in(
3734
    state_type&,
3735
    const extern_type* frm,
3736
    const extern_type* frm_end,
3737
    const extern_type*& frm_nxt,
3738
    intern_type* to,
3739
    intern_type* to_end,
3740
    intern_type*& to_nxt) const {
3741
  const uint8_t* _frm     = reinterpret_cast<const uint8_t*>(frm);
3742
  const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
3743
  const uint8_t* _frm_nxt = _frm;
3744
#  if defined(_LIBCPP_SHORT_WCHAR)
3745
  uint16_t* _to     = reinterpret_cast<uint16_t*>(to);
3746
  uint16_t* _to_end = reinterpret_cast<uint16_t*>(to_end);
3747
  uint16_t* _to_nxt = _to;
3748
#  else
3749
  uint32_t* _to     = reinterpret_cast<uint32_t*>(to);
3750
  uint32_t* _to_end = reinterpret_cast<uint32_t*>(to_end);
3751
  uint32_t* _to_nxt = _to;
3752
#  endif
3753
  result r = utf8_to_utf16(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt, __maxcode_, __mode_);
3754
  frm_nxt  = frm + (_frm_nxt - _frm);
3755
  to_nxt   = to + (_to_nxt - _to);
3756
  return r;
3757
}
3758

3759
__codecvt_utf8_utf16<wchar_t>::result
3760
__codecvt_utf8_utf16<wchar_t>::do_unshift(state_type&, extern_type* to, extern_type*, extern_type*& to_nxt) const {
3761
  to_nxt = to;
3762
  return noconv;
3763
}
3764

3765
int __codecvt_utf8_utf16<wchar_t>::do_encoding() const noexcept { return 0; }
3766

3767
bool __codecvt_utf8_utf16<wchar_t>::do_always_noconv() const noexcept { return false; }
3768

3769
int __codecvt_utf8_utf16<wchar_t>::do_length(
3770
    state_type&, const extern_type* frm, const extern_type* frm_end, size_t mx) const {
3771
  const uint8_t* _frm     = reinterpret_cast<const uint8_t*>(frm);
3772
  const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
3773
  return utf8_to_utf16_length(_frm, _frm_end, mx, __maxcode_, __mode_);
3774
}
3775

3776
int __codecvt_utf8_utf16<wchar_t>::do_max_length() const noexcept {
3777
  if (__mode_ & consume_header)
3778
    return 7;
3779
  return 4;
3780
}
3781
#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
3782

3783
// __codecvt_utf8_utf16<char16_t>
3784

3785
__codecvt_utf8_utf16<char16_t>::result __codecvt_utf8_utf16<char16_t>::do_out(
3786
    state_type&,
3787
    const intern_type* frm,
3788
    const intern_type* frm_end,
3789
    const intern_type*& frm_nxt,
3790
    extern_type* to,
3791
    extern_type* to_end,
3792
    extern_type*& to_nxt) const {
3793
  const uint16_t* _frm     = reinterpret_cast<const uint16_t*>(frm);
3794
  const uint16_t* _frm_end = reinterpret_cast<const uint16_t*>(frm_end);
3795
  const uint16_t* _frm_nxt = _frm;
3796
  uint8_t* _to             = reinterpret_cast<uint8_t*>(to);
3797
  uint8_t* _to_end         = reinterpret_cast<uint8_t*>(to_end);
3798
  uint8_t* _to_nxt         = _to;
3799
  result r                 = utf16_to_utf8(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt, __maxcode_, __mode_);
3800
  frm_nxt                  = frm + (_frm_nxt - _frm);
3801
  to_nxt                   = to + (_to_nxt - _to);
3802
  return r;
3803
}
3804

3805
__codecvt_utf8_utf16<char16_t>::result __codecvt_utf8_utf16<char16_t>::do_in(
3806
    state_type&,
3807
    const extern_type* frm,
3808
    const extern_type* frm_end,
3809
    const extern_type*& frm_nxt,
3810
    intern_type* to,
3811
    intern_type* to_end,
3812
    intern_type*& to_nxt) const {
3813
  const uint8_t* _frm     = reinterpret_cast<const uint8_t*>(frm);
3814
  const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
3815
  const uint8_t* _frm_nxt = _frm;
3816
  uint16_t* _to           = reinterpret_cast<uint16_t*>(to);
3817
  uint16_t* _to_end       = reinterpret_cast<uint16_t*>(to_end);
3818
  uint16_t* _to_nxt       = _to;
3819
  result r                = utf8_to_utf16(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt, __maxcode_, __mode_);
3820
  frm_nxt                 = frm + (_frm_nxt - _frm);
3821
  to_nxt                  = to + (_to_nxt - _to);
3822
  return r;
3823
}
3824

3825
__codecvt_utf8_utf16<char16_t>::result
3826
__codecvt_utf8_utf16<char16_t>::do_unshift(state_type&, extern_type* to, extern_type*, extern_type*& to_nxt) const {
3827
  to_nxt = to;
3828
  return noconv;
3829
}
3830

3831
int __codecvt_utf8_utf16<char16_t>::do_encoding() const noexcept { return 0; }
3832

3833
bool __codecvt_utf8_utf16<char16_t>::do_always_noconv() const noexcept { return false; }
3834

3835
int __codecvt_utf8_utf16<char16_t>::do_length(
3836
    state_type&, const extern_type* frm, const extern_type* frm_end, size_t mx) const {
3837
  const uint8_t* _frm     = reinterpret_cast<const uint8_t*>(frm);
3838
  const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
3839
  return utf8_to_utf16_length(_frm, _frm_end, mx, __maxcode_, __mode_);
3840
}
3841

3842
_LIBCPP_SUPPRESS_DEPRECATED_PUSH
3843
int __codecvt_utf8_utf16<char16_t>::do_max_length() const noexcept {
3844
  if (__mode_ & consume_header)
3845
    return 7;
3846
  return 4;
3847
}
3848
_LIBCPP_SUPPRESS_DEPRECATED_POP
3849

3850
// __codecvt_utf8_utf16<char32_t>
3851

3852
__codecvt_utf8_utf16<char32_t>::result __codecvt_utf8_utf16<char32_t>::do_out(
3853
    state_type&,
3854
    const intern_type* frm,
3855
    const intern_type* frm_end,
3856
    const intern_type*& frm_nxt,
3857
    extern_type* to,
3858
    extern_type* to_end,
3859
    extern_type*& to_nxt) const {
3860
  const uint32_t* _frm     = reinterpret_cast<const uint32_t*>(frm);
3861
  const uint32_t* _frm_end = reinterpret_cast<const uint32_t*>(frm_end);
3862
  const uint32_t* _frm_nxt = _frm;
3863
  uint8_t* _to             = reinterpret_cast<uint8_t*>(to);
3864
  uint8_t* _to_end         = reinterpret_cast<uint8_t*>(to_end);
3865
  uint8_t* _to_nxt         = _to;
3866
  result r                 = utf16_to_utf8(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt, __maxcode_, __mode_);
3867
  frm_nxt                  = frm + (_frm_nxt - _frm);
3868
  to_nxt                   = to + (_to_nxt - _to);
3869
  return r;
3870
}
3871

3872
__codecvt_utf8_utf16<char32_t>::result __codecvt_utf8_utf16<char32_t>::do_in(
3873
    state_type&,
3874
    const extern_type* frm,
3875
    const extern_type* frm_end,
3876
    const extern_type*& frm_nxt,
3877
    intern_type* to,
3878
    intern_type* to_end,
3879
    intern_type*& to_nxt) const {
3880
  const uint8_t* _frm     = reinterpret_cast<const uint8_t*>(frm);
3881
  const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
3882
  const uint8_t* _frm_nxt = _frm;
3883
  uint32_t* _to           = reinterpret_cast<uint32_t*>(to);
3884
  uint32_t* _to_end       = reinterpret_cast<uint32_t*>(to_end);
3885
  uint32_t* _to_nxt       = _to;
3886
  result r                = utf8_to_utf16(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt, __maxcode_, __mode_);
3887
  frm_nxt                 = frm + (_frm_nxt - _frm);
3888
  to_nxt                  = to + (_to_nxt - _to);
3889
  return r;
3890
}
3891

3892
__codecvt_utf8_utf16<char32_t>::result
3893
__codecvt_utf8_utf16<char32_t>::do_unshift(state_type&, extern_type* to, extern_type*, extern_type*& to_nxt) const {
3894
  to_nxt = to;
3895
  return noconv;
3896
}
3897

3898
int __codecvt_utf8_utf16<char32_t>::do_encoding() const noexcept { return 0; }
3899

3900
bool __codecvt_utf8_utf16<char32_t>::do_always_noconv() const noexcept { return false; }
3901

3902
int __codecvt_utf8_utf16<char32_t>::do_length(
3903
    state_type&, const extern_type* frm, const extern_type* frm_end, size_t mx) const {
3904
  const uint8_t* _frm     = reinterpret_cast<const uint8_t*>(frm);
3905
  const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
3906
  return utf8_to_utf16_length(_frm, _frm_end, mx, __maxcode_, __mode_);
3907
}
3908

3909
_LIBCPP_SUPPRESS_DEPRECATED_PUSH
3910
int __codecvt_utf8_utf16<char32_t>::do_max_length() const noexcept {
3911
  if (__mode_ & consume_header)
3912
    return 7;
3913
  return 4;
3914
}
3915
_LIBCPP_SUPPRESS_DEPRECATED_POP
3916

3917
// __narrow_to_utf8<16>
3918

3919
__narrow_to_utf8<16>::~__narrow_to_utf8() {}
3920

3921
// __narrow_to_utf8<32>
3922

3923
__narrow_to_utf8<32>::~__narrow_to_utf8() {}
3924

3925
// __widen_from_utf8<16>
3926

3927
__widen_from_utf8<16>::~__widen_from_utf8() {}
3928

3929
// __widen_from_utf8<32>
3930

3931
__widen_from_utf8<32>::~__widen_from_utf8() {}
3932

3933
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
3934
static bool checked_string_to_wchar_convert(wchar_t& dest, const char* ptr, locale_t loc) {
3935
  if (*ptr == '\0')
3936
    return false;
3937
  mbstate_t mb = {};
3938
  wchar_t out;
3939
  size_t ret = __libcpp_mbrtowc_l(&out, ptr, strlen(ptr), &mb, loc);
3940
  if (ret == static_cast<size_t>(-1) || ret == static_cast<size_t>(-2)) {
3941
    return false;
3942
  }
3943
  dest = out;
3944
  return true;
3945
}
3946
#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
3947

3948
#ifdef _LIBCPP_HAS_NO_WIDE_CHARACTERS
3949
static bool is_narrow_non_breaking_space(const char* ptr) {
3950
  // https://www.fileformat.info/info/unicode/char/202f/index.htm
3951
  return ptr[0] == '\xe2' && ptr[1] == '\x80' && ptr[2] == '\xaf';
3952
}
3953

3954
static bool is_non_breaking_space(const char* ptr) {
3955
  // https://www.fileformat.info/info/unicode/char/0a/index.htm
3956
  return ptr[0] == '\xc2' && ptr[1] == '\xa0';
3957
}
3958
#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
3959

3960
static bool checked_string_to_char_convert(char& dest, const char* ptr, locale_t __loc) {
3961
  if (*ptr == '\0')
3962
    return false;
3963
  if (!ptr[1]) {
3964
    dest = *ptr;
3965
    return true;
3966
  }
3967

3968
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
3969
  // First convert the MBS into a wide char then attempt to narrow it using
3970
  // wctob_l.
3971
  wchar_t wout;
3972
  if (!checked_string_to_wchar_convert(wout, ptr, __loc))
3973
    return false;
3974
  int res;
3975
  if ((res = __libcpp_wctob_l(wout, __loc)) != char_traits<char>::eof()) {
3976
    dest = res;
3977
    return true;
3978
  }
3979
  // FIXME: Work around specific multibyte sequences that we can reasonably
3980
  // translate into a different single byte.
3981
  switch (wout) {
3982
  case L'\u202F': // narrow non-breaking space
3983
  case L'\u00A0': // non-breaking space
3984
    dest = ' ';
3985
    return true;
3986
  default:
3987
    return false;
3988
  }
3989
#else  // _LIBCPP_HAS_NO_WIDE_CHARACTERS
3990
  // FIXME: Work around specific multibyte sequences that we can reasonably
3991
  // translate into a different single byte.
3992
  if (is_narrow_non_breaking_space(ptr) || is_non_breaking_space(ptr)) {
3993
    dest = ' ';
3994
    return true;
3995
  }
3996

3997
  return false;
3998
#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
3999
  __libcpp_unreachable();
4000
}
4001

4002
// numpunct<char> && numpunct<wchar_t>
4003

4004
constinit locale::id numpunct<char>::id;
4005
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
4006
constinit locale::id numpunct<wchar_t>::id;
4007
#endif
4008

4009
numpunct<char>::numpunct(size_t refs) : locale::facet(refs), __decimal_point_('.'), __thousands_sep_(',') {}
4010

4011
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
4012
numpunct<wchar_t>::numpunct(size_t refs) : locale::facet(refs), __decimal_point_(L'.'), __thousands_sep_(L',') {}
4013
#endif
4014

4015
numpunct<char>::~numpunct() {}
4016

4017
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
4018
numpunct<wchar_t>::~numpunct() {}
4019
#endif
4020

4021
char numpunct< char >::do_decimal_point() const { return __decimal_point_; }
4022
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
4023
wchar_t numpunct<wchar_t>::do_decimal_point() const { return __decimal_point_; }
4024
#endif
4025

4026
char numpunct< char >::do_thousands_sep() const { return __thousands_sep_; }
4027
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
4028
wchar_t numpunct<wchar_t>::do_thousands_sep() const { return __thousands_sep_; }
4029
#endif
4030

4031
string numpunct< char >::do_grouping() const { return __grouping_; }
4032
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
4033
string numpunct<wchar_t>::do_grouping() const { return __grouping_; }
4034
#endif
4035

4036
string numpunct< char >::do_truename() const { return "true"; }
4037
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
4038
wstring numpunct<wchar_t>::do_truename() const { return L"true"; }
4039
#endif
4040

4041
string numpunct< char >::do_falsename() const { return "false"; }
4042
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
4043
wstring numpunct<wchar_t>::do_falsename() const { return L"false"; }
4044
#endif
4045

4046
// numpunct_byname<char>
4047

4048
numpunct_byname<char>::numpunct_byname(const char* nm, size_t refs) : numpunct<char>(refs) { __init(nm); }
4049

4050
numpunct_byname<char>::numpunct_byname(const string& nm, size_t refs) : numpunct<char>(refs) { __init(nm.c_str()); }
4051

4052
numpunct_byname<char>::~numpunct_byname() {}
4053

4054
void numpunct_byname<char>::__init(const char* nm) {
4055
  typedef numpunct<char> base;
4056
  if (strcmp(nm, "C") != 0) {
4057
    __libcpp_unique_locale loc(nm);
4058
    if (!loc)
4059
      __throw_runtime_error(
4060
          ("numpunct_byname<char>::numpunct_byname"
4061
           " failed to construct for " +
4062
           string(nm))
4063
              .c_str());
4064

4065
    lconv* lc = __libcpp_localeconv_l(loc.get());
4066
    if (!checked_string_to_char_convert(__decimal_point_, lc->decimal_point, loc.get()))
4067
      __decimal_point_ = base::do_decimal_point();
4068
    if (!checked_string_to_char_convert(__thousands_sep_, lc->thousands_sep, loc.get()))
4069
      __thousands_sep_ = base::do_thousands_sep();
4070
    __grouping_ = lc->grouping;
4071
    // localization for truename and falsename is not available
4072
  }
4073
}
4074

4075
// numpunct_byname<wchar_t>
4076

4077
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
4078
numpunct_byname<wchar_t>::numpunct_byname(const char* nm, size_t refs) : numpunct<wchar_t>(refs) { __init(nm); }
4079

4080
numpunct_byname<wchar_t>::numpunct_byname(const string& nm, size_t refs) : numpunct<wchar_t>(refs) {
4081
  __init(nm.c_str());
4082
}
4083

4084
numpunct_byname<wchar_t>::~numpunct_byname() {}
4085

4086
void numpunct_byname<wchar_t>::__init(const char* nm) {
4087
  if (strcmp(nm, "C") != 0) {
4088
    __libcpp_unique_locale loc(nm);
4089
    if (!loc)
4090
      __throw_runtime_error(
4091
          ("numpunct_byname<wchar_t>::numpunct_byname"
4092
           " failed to construct for " +
4093
           string(nm))
4094
              .c_str());
4095

4096
    lconv* lc = __libcpp_localeconv_l(loc.get());
4097
    checked_string_to_wchar_convert(__decimal_point_, lc->decimal_point, loc.get());
4098
    checked_string_to_wchar_convert(__thousands_sep_, lc->thousands_sep, loc.get());
4099
    __grouping_ = lc->grouping;
4100
    // localization for truename and falsename is not available
4101
  }
4102
}
4103
#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
4104

4105
// num_get helpers
4106

4107
int __num_get_base::__get_base(ios_base& iob) {
4108
  ios_base::fmtflags __basefield = iob.flags() & ios_base::basefield;
4109
  if (__basefield == ios_base::oct)
4110
    return 8;
4111
  else if (__basefield == ios_base::hex)
4112
    return 16;
4113
  else if (__basefield == 0)
4114
    return 0;
4115
  return 10;
4116
}
4117

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

4120
void __check_grouping(const string& __grouping, unsigned* __g, unsigned* __g_end, ios_base::iostate& __err) {
4121
  //  if the grouping pattern is empty _or_ there are no grouping bits, then do nothing
4122
  //  we always have at least a single entry in [__g, __g_end); the end of the input sequence
4123
  if (__grouping.size() != 0 && __g_end - __g > 1) {
4124
    reverse(__g, __g_end);
4125
    const char* __ig = __grouping.data();
4126
    const char* __eg = __ig + __grouping.size();
4127
    for (unsigned* __r = __g; __r < __g_end - 1; ++__r) {
4128
      if (0 < *__ig && *__ig < numeric_limits<char>::max()) {
4129
        if (static_cast<unsigned>(*__ig) != *__r) {
4130
          __err = ios_base::failbit;
4131
          return;
4132
        }
4133
      }
4134
      if (__eg - __ig > 1)
4135
        ++__ig;
4136
    }
4137
    if (0 < *__ig && *__ig < numeric_limits<char>::max()) {
4138
      if (static_cast<unsigned>(*__ig) < __g_end[-1] || __g_end[-1] == 0)
4139
        __err = ios_base::failbit;
4140
    }
4141
  }
4142
}
4143

4144
void __num_put_base::__format_int(char* __fmtp, const char* __len, bool __signd, ios_base::fmtflags __flags) {
4145
  if ((__flags & ios_base::showpos) && (__flags & ios_base::basefield) != ios_base::oct &&
4146
      (__flags & ios_base::basefield) != ios_base::hex && __signd)
4147
    *__fmtp++ = '+';
4148
  if (__flags & ios_base::showbase)
4149
    *__fmtp++ = '#';
4150
  while (*__len)
4151
    *__fmtp++ = *__len++;
4152
  if ((__flags & ios_base::basefield) == ios_base::oct)
4153
    *__fmtp = 'o';
4154
  else if ((__flags & ios_base::basefield) == ios_base::hex) {
4155
    if (__flags & ios_base::uppercase)
4156
      *__fmtp = 'X';
4157
    else
4158
      *__fmtp = 'x';
4159
  } else if (__signd)
4160
    *__fmtp = 'd';
4161
  else
4162
    *__fmtp = 'u';
4163
}
4164

4165
bool __num_put_base::__format_float(char* __fmtp, const char* __len, ios_base::fmtflags __flags) {
4166
  bool specify_precision = true;
4167
  if (__flags & ios_base::showpos)
4168
    *__fmtp++ = '+';
4169
  if (__flags & ios_base::showpoint)
4170
    *__fmtp++ = '#';
4171
  ios_base::fmtflags floatfield = __flags & ios_base::floatfield;
4172
  bool uppercase                = (__flags & ios_base::uppercase) != 0;
4173
  if (floatfield == (ios_base::fixed | ios_base::scientific))
4174
    specify_precision = false;
4175
  else {
4176
    *__fmtp++ = '.';
4177
    *__fmtp++ = '*';
4178
  }
4179
  while (*__len)
4180
    *__fmtp++ = *__len++;
4181
  if (floatfield == ios_base::fixed) {
4182
    if (uppercase)
4183
      *__fmtp = 'F';
4184
    else
4185
      *__fmtp = 'f';
4186
  } else if (floatfield == ios_base::scientific) {
4187
    if (uppercase)
4188
      *__fmtp = 'E';
4189
    else
4190
      *__fmtp = 'e';
4191
  } else if (floatfield == (ios_base::fixed | ios_base::scientific)) {
4192
    if (uppercase)
4193
      *__fmtp = 'A';
4194
    else
4195
      *__fmtp = 'a';
4196
  } else {
4197
    if (uppercase)
4198
      *__fmtp = 'G';
4199
    else
4200
      *__fmtp = 'g';
4201
  }
4202
  return specify_precision;
4203
}
4204

4205
char* __num_put_base::__identify_padding(char* __nb, char* __ne, const ios_base& __iob) {
4206
  switch (__iob.flags() & ios_base::adjustfield) {
4207
  case ios_base::internal:
4208
    if (__nb[0] == '-' || __nb[0] == '+')
4209
      return __nb + 1;
4210
    if (__ne - __nb >= 2 && __nb[0] == '0' && (__nb[1] == 'x' || __nb[1] == 'X'))
4211
      return __nb + 2;
4212
    break;
4213
  case ios_base::left:
4214
    return __ne;
4215
  case ios_base::right:
4216
  default:
4217
    break;
4218
  }
4219
  return __nb;
4220
}
4221

4222
// time_get
4223

4224
static string* init_weeks() {
4225
  static string weeks[14];
4226
  weeks[0]  = "Sunday";
4227
  weeks[1]  = "Monday";
4228
  weeks[2]  = "Tuesday";
4229
  weeks[3]  = "Wednesday";
4230
  weeks[4]  = "Thursday";
4231
  weeks[5]  = "Friday";
4232
  weeks[6]  = "Saturday";
4233
  weeks[7]  = "Sun";
4234
  weeks[8]  = "Mon";
4235
  weeks[9]  = "Tue";
4236
  weeks[10] = "Wed";
4237
  weeks[11] = "Thu";
4238
  weeks[12] = "Fri";
4239
  weeks[13] = "Sat";
4240
  return weeks;
4241
}
4242

4243
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
4244
static wstring* init_wweeks() {
4245
  static wstring weeks[14];
4246
  weeks[0]  = L"Sunday";
4247
  weeks[1]  = L"Monday";
4248
  weeks[2]  = L"Tuesday";
4249
  weeks[3]  = L"Wednesday";
4250
  weeks[4]  = L"Thursday";
4251
  weeks[5]  = L"Friday";
4252
  weeks[6]  = L"Saturday";
4253
  weeks[7]  = L"Sun";
4254
  weeks[8]  = L"Mon";
4255
  weeks[9]  = L"Tue";
4256
  weeks[10] = L"Wed";
4257
  weeks[11] = L"Thu";
4258
  weeks[12] = L"Fri";
4259
  weeks[13] = L"Sat";
4260
  return weeks;
4261
}
4262
#endif
4263

4264
template <>
4265
const string* __time_get_c_storage<char>::__weeks() const {
4266
  static const string* weeks = init_weeks();
4267
  return weeks;
4268
}
4269

4270
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
4271
template <>
4272
const wstring* __time_get_c_storage<wchar_t>::__weeks() const {
4273
  static const wstring* weeks = init_wweeks();
4274
  return weeks;
4275
}
4276
#endif
4277

4278
static string* init_months() {
4279
  static string months[24];
4280
  months[0]  = "January";
4281
  months[1]  = "February";
4282
  months[2]  = "March";
4283
  months[3]  = "April";
4284
  months[4]  = "May";
4285
  months[5]  = "June";
4286
  months[6]  = "July";
4287
  months[7]  = "August";
4288
  months[8]  = "September";
4289
  months[9]  = "October";
4290
  months[10] = "November";
4291
  months[11] = "December";
4292
  months[12] = "Jan";
4293
  months[13] = "Feb";
4294
  months[14] = "Mar";
4295
  months[15] = "Apr";
4296
  months[16] = "May";
4297
  months[17] = "Jun";
4298
  months[18] = "Jul";
4299
  months[19] = "Aug";
4300
  months[20] = "Sep";
4301
  months[21] = "Oct";
4302
  months[22] = "Nov";
4303
  months[23] = "Dec";
4304
  return months;
4305
}
4306

4307
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
4308
static wstring* init_wmonths() {
4309
  static wstring months[24];
4310
  months[0]  = L"January";
4311
  months[1]  = L"February";
4312
  months[2]  = L"March";
4313
  months[3]  = L"April";
4314
  months[4]  = L"May";
4315
  months[5]  = L"June";
4316
  months[6]  = L"July";
4317
  months[7]  = L"August";
4318
  months[8]  = L"September";
4319
  months[9]  = L"October";
4320
  months[10] = L"November";
4321
  months[11] = L"December";
4322
  months[12] = L"Jan";
4323
  months[13] = L"Feb";
4324
  months[14] = L"Mar";
4325
  months[15] = L"Apr";
4326
  months[16] = L"May";
4327
  months[17] = L"Jun";
4328
  months[18] = L"Jul";
4329
  months[19] = L"Aug";
4330
  months[20] = L"Sep";
4331
  months[21] = L"Oct";
4332
  months[22] = L"Nov";
4333
  months[23] = L"Dec";
4334
  return months;
4335
}
4336
#endif
4337

4338
template <>
4339
const string* __time_get_c_storage<char>::__months() const {
4340
  static const string* months = init_months();
4341
  return months;
4342
}
4343

4344
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
4345
template <>
4346
const wstring* __time_get_c_storage<wchar_t>::__months() const {
4347
  static const wstring* months = init_wmonths();
4348
  return months;
4349
}
4350
#endif
4351

4352
static string* init_am_pm() {
4353
  static string am_pm[2];
4354
  am_pm[0] = "AM";
4355
  am_pm[1] = "PM";
4356
  return am_pm;
4357
}
4358

4359
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
4360
static wstring* init_wam_pm() {
4361
  static wstring am_pm[2];
4362
  am_pm[0] = L"AM";
4363
  am_pm[1] = L"PM";
4364
  return am_pm;
4365
}
4366
#endif
4367

4368
template <>
4369
const string* __time_get_c_storage<char>::__am_pm() const {
4370
  static const string* am_pm = init_am_pm();
4371
  return am_pm;
4372
}
4373

4374
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
4375
template <>
4376
const wstring* __time_get_c_storage<wchar_t>::__am_pm() const {
4377
  static const wstring* am_pm = init_wam_pm();
4378
  return am_pm;
4379
}
4380
#endif
4381

4382
template <>
4383
const string& __time_get_c_storage<char>::__x() const {
4384
  static string s("%m/%d/%y");
4385
  return s;
4386
}
4387

4388
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
4389
template <>
4390
const wstring& __time_get_c_storage<wchar_t>::__x() const {
4391
  static wstring s(L"%m/%d/%y");
4392
  return s;
4393
}
4394
#endif
4395

4396
template <>
4397
const string& __time_get_c_storage<char>::__X() const {
4398
  static string s("%H:%M:%S");
4399
  return s;
4400
}
4401

4402
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
4403
template <>
4404
const wstring& __time_get_c_storage<wchar_t>::__X() const {
4405
  static wstring s(L"%H:%M:%S");
4406
  return s;
4407
}
4408
#endif
4409

4410
template <>
4411
const string& __time_get_c_storage<char>::__c() const {
4412
  static string s("%a %b %d %H:%M:%S %Y");
4413
  return s;
4414
}
4415

4416
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
4417
template <>
4418
const wstring& __time_get_c_storage<wchar_t>::__c() const {
4419
  static wstring s(L"%a %b %d %H:%M:%S %Y");
4420
  return s;
4421
}
4422
#endif
4423

4424
template <>
4425
const string& __time_get_c_storage<char>::__r() const {
4426
  static string s("%I:%M:%S %p");
4427
  return s;
4428
}
4429

4430
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
4431
template <>
4432
const wstring& __time_get_c_storage<wchar_t>::__r() const {
4433
  static wstring s(L"%I:%M:%S %p");
4434
  return s;
4435
}
4436
#endif
4437

4438
// time_get_byname
4439

4440
__time_get::__time_get(const char* nm) : __loc_(newlocale(LC_ALL_MASK, nm, 0)) {
4441
  if (__loc_ == 0)
4442
    __throw_runtime_error(("time_get_byname failed to construct for " + string(nm)).c_str());
4443
}
4444

4445
__time_get::__time_get(const string& nm) : __loc_(newlocale(LC_ALL_MASK, nm.c_str(), 0)) {
4446
  if (__loc_ == 0)
4447
    __throw_runtime_error(("time_get_byname failed to construct for " + nm).c_str());
4448
}
4449

4450
__time_get::~__time_get() { freelocale(__loc_); }
4451

4452
_LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wmissing-field-initializers")
4453

4454
template <>
4455
string __time_get_storage<char>::__analyze(char fmt, const ctype<char>& ct) {
4456
  tm t       = {0};
4457
  t.tm_sec   = 59;
4458
  t.tm_min   = 55;
4459
  t.tm_hour  = 23;
4460
  t.tm_mday  = 31;
4461
  t.tm_mon   = 11;
4462
  t.tm_year  = 161;
4463
  t.tm_wday  = 6;
4464
  t.tm_yday  = 364;
4465
  t.tm_isdst = -1;
4466
  char buf[100];
4467
  char f[3] = {0};
4468
  f[0]      = '%';
4469
  f[1]      = fmt;
4470
  size_t n  = strftime_l(buf, countof(buf), f, &t, __loc_);
4471
  char* bb  = buf;
4472
  char* be  = buf + n;
4473
  string result;
4474
  while (bb != be) {
4475
    if (ct.is(ctype_base::space, *bb)) {
4476
      result.push_back(' ');
4477
      for (++bb; bb != be && ct.is(ctype_base::space, *bb); ++bb)
4478
        ;
4479
      continue;
4480
    }
4481
    char* w               = bb;
4482
    ios_base::iostate err = ios_base::goodbit;
4483
    ptrdiff_t i           = __scan_keyword(w, be, this->__weeks_, this->__weeks_ + 14, ct, err, false) - this->__weeks_;
4484
    if (i < 14) {
4485
      result.push_back('%');
4486
      if (i < 7)
4487
        result.push_back('A');
4488
      else
4489
        result.push_back('a');
4490
      bb = w;
4491
      continue;
4492
    }
4493
    w = bb;
4494
    i = __scan_keyword(w, be, this->__months_, this->__months_ + 24, ct, err, false) - this->__months_;
4495
    if (i < 24) {
4496
      result.push_back('%');
4497
      if (i < 12)
4498
        result.push_back('B');
4499
      else
4500
        result.push_back('b');
4501
      if (fmt == 'x' && ct.is(ctype_base::digit, this->__months_[i][0]))
4502
        result.back() = 'm';
4503
      bb = w;
4504
      continue;
4505
    }
4506
    if (this->__am_pm_[0].size() + this->__am_pm_[1].size() > 0) {
4507
      w = bb;
4508
      i = __scan_keyword(w, be, this->__am_pm_, this->__am_pm_ + 2, ct, err, false) - this->__am_pm_;
4509
      if (i < 2) {
4510
        result.push_back('%');
4511
        result.push_back('p');
4512
        bb = w;
4513
        continue;
4514
      }
4515
    }
4516
    w = bb;
4517
    if (ct.is(ctype_base::digit, *bb)) {
4518
      switch (__get_up_to_n_digits(bb, be, err, ct, 4)) {
4519
      case 6:
4520
        result.push_back('%');
4521
        result.push_back('w');
4522
        break;
4523
      case 7:
4524
        result.push_back('%');
4525
        result.push_back('u');
4526
        break;
4527
      case 11:
4528
        result.push_back('%');
4529
        result.push_back('I');
4530
        break;
4531
      case 12:
4532
        result.push_back('%');
4533
        result.push_back('m');
4534
        break;
4535
      case 23:
4536
        result.push_back('%');
4537
        result.push_back('H');
4538
        break;
4539
      case 31:
4540
        result.push_back('%');
4541
        result.push_back('d');
4542
        break;
4543
      case 55:
4544
        result.push_back('%');
4545
        result.push_back('M');
4546
        break;
4547
      case 59:
4548
        result.push_back('%');
4549
        result.push_back('S');
4550
        break;
4551
      case 61:
4552
        result.push_back('%');
4553
        result.push_back('y');
4554
        break;
4555
      case 364:
4556
        result.push_back('%');
4557
        result.push_back('j');
4558
        break;
4559
      case 2061:
4560
        result.push_back('%');
4561
        result.push_back('Y');
4562
        break;
4563
      default:
4564
        for (; w != bb; ++w)
4565
          result.push_back(*w);
4566
        break;
4567
      }
4568
      continue;
4569
    }
4570
    if (*bb == '%') {
4571
      result.push_back('%');
4572
      result.push_back('%');
4573
      ++bb;
4574
      continue;
4575
    }
4576
    result.push_back(*bb);
4577
    ++bb;
4578
  }
4579
  return result;
4580
}
4581

4582
_LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wmissing-braces")
4583

4584
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
4585
template <>
4586
wstring __time_get_storage<wchar_t>::__analyze(char fmt, const ctype<wchar_t>& ct) {
4587
  tm t       = {0};
4588
  t.tm_sec   = 59;
4589
  t.tm_min   = 55;
4590
  t.tm_hour  = 23;
4591
  t.tm_mday  = 31;
4592
  t.tm_mon   = 11;
4593
  t.tm_year  = 161;
4594
  t.tm_wday  = 6;
4595
  t.tm_yday  = 364;
4596
  t.tm_isdst = -1;
4597
  char buf[100];
4598
  char f[3] = {0};
4599
  f[0]      = '%';
4600
  f[1]      = fmt;
4601
  strftime_l(buf, countof(buf), f, &t, __loc_);
4602
  wchar_t wbuf[100];
4603
  wchar_t* wbb   = wbuf;
4604
  mbstate_t mb   = {0};
4605
  const char* bb = buf;
4606
  size_t j       = __libcpp_mbsrtowcs_l(wbb, &bb, countof(wbuf), &mb, __loc_);
4607
  if (j == size_t(-1))
4608
    __throw_runtime_error("locale not supported");
4609
  wchar_t* wbe = wbb + j;
4610
  wstring result;
4611
  while (wbb != wbe) {
4612
    if (ct.is(ctype_base::space, *wbb)) {
4613
      result.push_back(L' ');
4614
      for (++wbb; wbb != wbe && ct.is(ctype_base::space, *wbb); ++wbb)
4615
        ;
4616
      continue;
4617
    }
4618
    wchar_t* w            = wbb;
4619
    ios_base::iostate err = ios_base::goodbit;
4620
    ptrdiff_t i = __scan_keyword(w, wbe, this->__weeks_, this->__weeks_ + 14, ct, err, false) - this->__weeks_;
4621
    if (i < 14) {
4622
      result.push_back(L'%');
4623
      if (i < 7)
4624
        result.push_back(L'A');
4625
      else
4626
        result.push_back(L'a');
4627
      wbb = w;
4628
      continue;
4629
    }
4630
    w = wbb;
4631
    i = __scan_keyword(w, wbe, this->__months_, this->__months_ + 24, ct, err, false) - this->__months_;
4632
    if (i < 24) {
4633
      result.push_back(L'%');
4634
      if (i < 12)
4635
        result.push_back(L'B');
4636
      else
4637
        result.push_back(L'b');
4638
      if (fmt == 'x' && ct.is(ctype_base::digit, this->__months_[i][0]))
4639
        result.back() = L'm';
4640
      wbb = w;
4641
      continue;
4642
    }
4643
    if (this->__am_pm_[0].size() + this->__am_pm_[1].size() > 0) {
4644
      w = wbb;
4645
      i = __scan_keyword(w, wbe, this->__am_pm_, this->__am_pm_ + 2, ct, err, false) - this->__am_pm_;
4646
      if (i < 2) {
4647
        result.push_back(L'%');
4648
        result.push_back(L'p');
4649
        wbb = w;
4650
        continue;
4651
      }
4652
    }
4653
    w = wbb;
4654
    if (ct.is(ctype_base::digit, *wbb)) {
4655
      switch (__get_up_to_n_digits(wbb, wbe, err, ct, 4)) {
4656
      case 6:
4657
        result.push_back(L'%');
4658
        result.push_back(L'w');
4659
        break;
4660
      case 7:
4661
        result.push_back(L'%');
4662
        result.push_back(L'u');
4663
        break;
4664
      case 11:
4665
        result.push_back(L'%');
4666
        result.push_back(L'I');
4667
        break;
4668
      case 12:
4669
        result.push_back(L'%');
4670
        result.push_back(L'm');
4671
        break;
4672
      case 23:
4673
        result.push_back(L'%');
4674
        result.push_back(L'H');
4675
        break;
4676
      case 31:
4677
        result.push_back(L'%');
4678
        result.push_back(L'd');
4679
        break;
4680
      case 55:
4681
        result.push_back(L'%');
4682
        result.push_back(L'M');
4683
        break;
4684
      case 59:
4685
        result.push_back(L'%');
4686
        result.push_back(L'S');
4687
        break;
4688
      case 61:
4689
        result.push_back(L'%');
4690
        result.push_back(L'y');
4691
        break;
4692
      case 364:
4693
        result.push_back(L'%');
4694
        result.push_back(L'j');
4695
        break;
4696
      case 2061:
4697
        result.push_back(L'%');
4698
        result.push_back(L'Y');
4699
        break;
4700
      default:
4701
        for (; w != wbb; ++w)
4702
          result.push_back(*w);
4703
        break;
4704
      }
4705
      continue;
4706
    }
4707
    if (ct.narrow(*wbb, 0) == '%') {
4708
      result.push_back(L'%');
4709
      result.push_back(L'%');
4710
      ++wbb;
4711
      continue;
4712
    }
4713
    result.push_back(*wbb);
4714
    ++wbb;
4715
  }
4716
  return result;
4717
}
4718
#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
4719

4720
template <>
4721
void __time_get_storage<char>::init(const ctype<char>& ct) {
4722
  tm t = {0};
4723
  char buf[100];
4724
  // __weeks_
4725
  for (int i = 0; i < 7; ++i) {
4726
    t.tm_wday = i;
4727
    strftime_l(buf, countof(buf), "%A", &t, __loc_);
4728
    __weeks_[i] = buf;
4729
    strftime_l(buf, countof(buf), "%a", &t, __loc_);
4730
    __weeks_[i + 7] = buf;
4731
  }
4732
  // __months_
4733
  for (int i = 0; i < 12; ++i) {
4734
    t.tm_mon = i;
4735
    strftime_l(buf, countof(buf), "%B", &t, __loc_);
4736
    __months_[i] = buf;
4737
    strftime_l(buf, countof(buf), "%b", &t, __loc_);
4738
    __months_[i + 12] = buf;
4739
  }
4740
  // __am_pm_
4741
  t.tm_hour = 1;
4742
  strftime_l(buf, countof(buf), "%p", &t, __loc_);
4743
  __am_pm_[0] = buf;
4744
  t.tm_hour   = 13;
4745
  strftime_l(buf, countof(buf), "%p", &t, __loc_);
4746
  __am_pm_[1] = buf;
4747
  __c_        = __analyze('c', ct);
4748
  __r_        = __analyze('r', ct);
4749
  __x_        = __analyze('x', ct);
4750
  __X_        = __analyze('X', ct);
4751
}
4752

4753
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
4754
template <>
4755
void __time_get_storage<wchar_t>::init(const ctype<wchar_t>& ct) {
4756
  tm t = {0};
4757
  char buf[100];
4758
  wchar_t wbuf[100];
4759
  wchar_t* wbe;
4760
  mbstate_t mb = {0};
4761
  // __weeks_
4762
  for (int i = 0; i < 7; ++i) {
4763
    t.tm_wday = i;
4764
    strftime_l(buf, countof(buf), "%A", &t, __loc_);
4765
    mb             = mbstate_t();
4766
    const char* bb = buf;
4767
    size_t j       = __libcpp_mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, __loc_);
4768
    if (j == size_t(-1) || j == 0)
4769
      __throw_runtime_error("locale not supported");
4770
    wbe = wbuf + j;
4771
    __weeks_[i].assign(wbuf, wbe);
4772
    strftime_l(buf, countof(buf), "%a", &t, __loc_);
4773
    mb = mbstate_t();
4774
    bb = buf;
4775
    j  = __libcpp_mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, __loc_);
4776
    if (j == size_t(-1) || j == 0)
4777
      __throw_runtime_error("locale not supported");
4778
    wbe = wbuf + j;
4779
    __weeks_[i + 7].assign(wbuf, wbe);
4780
  }
4781
  // __months_
4782
  for (int i = 0; i < 12; ++i) {
4783
    t.tm_mon = i;
4784
    strftime_l(buf, countof(buf), "%B", &t, __loc_);
4785
    mb             = mbstate_t();
4786
    const char* bb = buf;
4787
    size_t j       = __libcpp_mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, __loc_);
4788
    if (j == size_t(-1) || j == 0)
4789
      __throw_runtime_error("locale not supported");
4790
    wbe = wbuf + j;
4791
    __months_[i].assign(wbuf, wbe);
4792
    strftime_l(buf, countof(buf), "%b", &t, __loc_);
4793
    mb = mbstate_t();
4794
    bb = buf;
4795
    j  = __libcpp_mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, __loc_);
4796
    if (j == size_t(-1) || j == 0)
4797
      __throw_runtime_error("locale not supported");
4798
    wbe = wbuf + j;
4799
    __months_[i + 12].assign(wbuf, wbe);
4800
  }
4801
  // __am_pm_
4802
  t.tm_hour = 1;
4803
  strftime_l(buf, countof(buf), "%p", &t, __loc_);
4804
  mb             = mbstate_t();
4805
  const char* bb = buf;
4806
  size_t j       = __libcpp_mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, __loc_);
4807
  if (j == size_t(-1))
4808
    __throw_runtime_error("locale not supported");
4809
  wbe = wbuf + j;
4810
  __am_pm_[0].assign(wbuf, wbe);
4811
  t.tm_hour = 13;
4812
  strftime_l(buf, countof(buf), "%p", &t, __loc_);
4813
  mb = mbstate_t();
4814
  bb = buf;
4815
  j  = __libcpp_mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, __loc_);
4816
  if (j == size_t(-1))
4817
    __throw_runtime_error("locale not supported");
4818
  wbe = wbuf + j;
4819
  __am_pm_[1].assign(wbuf, wbe);
4820
  __c_ = __analyze('c', ct);
4821
  __r_ = __analyze('r', ct);
4822
  __x_ = __analyze('x', ct);
4823
  __X_ = __analyze('X', ct);
4824
}
4825
#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
4826

4827
template <class CharT>
4828
struct _LIBCPP_HIDDEN __time_get_temp : public ctype_byname<CharT> {
4829
  explicit __time_get_temp(const char* nm) : ctype_byname<CharT>(nm, 1) {}
4830
  explicit __time_get_temp(const string& nm) : ctype_byname<CharT>(nm, 1) {}
4831
};
4832

4833
template <>
4834
__time_get_storage<char>::__time_get_storage(const char* __nm) : __time_get(__nm) {
4835
  const __time_get_temp<char> ct(__nm);
4836
  init(ct);
4837
}
4838

4839
template <>
4840
__time_get_storage<char>::__time_get_storage(const string& __nm) : __time_get(__nm) {
4841
  const __time_get_temp<char> ct(__nm);
4842
  init(ct);
4843
}
4844

4845
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
4846
template <>
4847
__time_get_storage<wchar_t>::__time_get_storage(const char* __nm) : __time_get(__nm) {
4848
  const __time_get_temp<wchar_t> ct(__nm);
4849
  init(ct);
4850
}
4851

4852
template <>
4853
__time_get_storage<wchar_t>::__time_get_storage(const string& __nm) : __time_get(__nm) {
4854
  const __time_get_temp<wchar_t> ct(__nm);
4855
  init(ct);
4856
}
4857
#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
4858

4859
template <>
4860
time_base::dateorder __time_get_storage<char>::__do_date_order() const {
4861
  unsigned i;
4862
  for (i = 0; i < __x_.size(); ++i)
4863
    if (__x_[i] == '%')
4864
      break;
4865
  ++i;
4866
  switch (__x_[i]) {
4867
  case 'y':
4868
  case 'Y':
4869
    for (++i; i < __x_.size(); ++i)
4870
      if (__x_[i] == '%')
4871
        break;
4872
    if (i == __x_.size())
4873
      break;
4874
    ++i;
4875
    switch (__x_[i]) {
4876
    case 'm':
4877
      for (++i; i < __x_.size(); ++i)
4878
        if (__x_[i] == '%')
4879
          break;
4880
      if (i == __x_.size())
4881
        break;
4882
      ++i;
4883
      if (__x_[i] == 'd')
4884
        return time_base::ymd;
4885
      break;
4886
    case 'd':
4887
      for (++i; i < __x_.size(); ++i)
4888
        if (__x_[i] == '%')
4889
          break;
4890
      if (i == __x_.size())
4891
        break;
4892
      ++i;
4893
      if (__x_[i] == 'm')
4894
        return time_base::ydm;
4895
      break;
4896
    }
4897
    break;
4898
  case 'm':
4899
    for (++i; i < __x_.size(); ++i)
4900
      if (__x_[i] == '%')
4901
        break;
4902
    if (i == __x_.size())
4903
      break;
4904
    ++i;
4905
    if (__x_[i] == 'd') {
4906
      for (++i; i < __x_.size(); ++i)
4907
        if (__x_[i] == '%')
4908
          break;
4909
      if (i == __x_.size())
4910
        break;
4911
      ++i;
4912
      if (__x_[i] == 'y' || __x_[i] == 'Y')
4913
        return time_base::mdy;
4914
      break;
4915
    }
4916
    break;
4917
  case 'd':
4918
    for (++i; i < __x_.size(); ++i)
4919
      if (__x_[i] == '%')
4920
        break;
4921
    if (i == __x_.size())
4922
      break;
4923
    ++i;
4924
    if (__x_[i] == 'm') {
4925
      for (++i; i < __x_.size(); ++i)
4926
        if (__x_[i] == '%')
4927
          break;
4928
      if (i == __x_.size())
4929
        break;
4930
      ++i;
4931
      if (__x_[i] == 'y' || __x_[i] == 'Y')
4932
        return time_base::dmy;
4933
      break;
4934
    }
4935
    break;
4936
  }
4937
  return time_base::no_order;
4938
}
4939

4940
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
4941
template <>
4942
time_base::dateorder __time_get_storage<wchar_t>::__do_date_order() const {
4943
  unsigned i;
4944
  for (i = 0; i < __x_.size(); ++i)
4945
    if (__x_[i] == L'%')
4946
      break;
4947
  ++i;
4948
  switch (__x_[i]) {
4949
  case L'y':
4950
  case L'Y':
4951
    for (++i; i < __x_.size(); ++i)
4952
      if (__x_[i] == L'%')
4953
        break;
4954
    if (i == __x_.size())
4955
      break;
4956
    ++i;
4957
    switch (__x_[i]) {
4958
    case L'm':
4959
      for (++i; i < __x_.size(); ++i)
4960
        if (__x_[i] == L'%')
4961
          break;
4962
      if (i == __x_.size())
4963
        break;
4964
      ++i;
4965
      if (__x_[i] == L'd')
4966
        return time_base::ymd;
4967
      break;
4968
    case L'd':
4969
      for (++i; i < __x_.size(); ++i)
4970
        if (__x_[i] == L'%')
4971
          break;
4972
      if (i == __x_.size())
4973
        break;
4974
      ++i;
4975
      if (__x_[i] == L'm')
4976
        return time_base::ydm;
4977
      break;
4978
    }
4979
    break;
4980
  case L'm':
4981
    for (++i; i < __x_.size(); ++i)
4982
      if (__x_[i] == L'%')
4983
        break;
4984
    if (i == __x_.size())
4985
      break;
4986
    ++i;
4987
    if (__x_[i] == L'd') {
4988
      for (++i; i < __x_.size(); ++i)
4989
        if (__x_[i] == L'%')
4990
          break;
4991
      if (i == __x_.size())
4992
        break;
4993
      ++i;
4994
      if (__x_[i] == L'y' || __x_[i] == L'Y')
4995
        return time_base::mdy;
4996
      break;
4997
    }
4998
    break;
4999
  case L'd':
5000
    for (++i; i < __x_.size(); ++i)
5001
      if (__x_[i] == L'%')
5002
        break;
5003
    if (i == __x_.size())
5004
      break;
5005
    ++i;
5006
    if (__x_[i] == L'm') {
5007
      for (++i; i < __x_.size(); ++i)
5008
        if (__x_[i] == L'%')
5009
          break;
5010
      if (i == __x_.size())
5011
        break;
5012
      ++i;
5013
      if (__x_[i] == L'y' || __x_[i] == L'Y')
5014
        return time_base::dmy;
5015
      break;
5016
    }
5017
    break;
5018
  }
5019
  return time_base::no_order;
5020
}
5021
#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
5022

5023
// time_put
5024

5025
__time_put::__time_put(const char* nm) : __loc_(newlocale(LC_ALL_MASK, nm, 0)) {
5026
  if (__loc_ == 0)
5027
    __throw_runtime_error(("time_put_byname failed to construct for " + string(nm)).c_str());
5028
}
5029

5030
__time_put::__time_put(const string& nm) : __loc_(newlocale(LC_ALL_MASK, nm.c_str(), 0)) {
5031
  if (__loc_ == 0)
5032
    __throw_runtime_error(("time_put_byname failed to construct for " + nm).c_str());
5033
}
5034

5035
__time_put::~__time_put() {
5036
  if (__loc_ != _LIBCPP_GET_C_LOCALE)
5037
    freelocale(__loc_);
5038
}
5039

5040
void __time_put::__do_put(char* __nb, char*& __ne, const tm* __tm, char __fmt, char __mod) const {
5041
  char fmt[] = {'%', __fmt, __mod, 0};
5042
  if (__mod != 0)
5043
    swap(fmt[1], fmt[2]);
5044
  size_t n = strftime_l(__nb, countof(__nb, __ne), fmt, __tm, __loc_);
5045
  __ne     = __nb + n;
5046
}
5047

5048
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
5049
void __time_put::__do_put(wchar_t* __wb, wchar_t*& __we, const tm* __tm, char __fmt, char __mod) const {
5050
  char __nar[100];
5051
  char* __ne = __nar + 100;
5052
  __do_put(__nar, __ne, __tm, __fmt, __mod);
5053
  mbstate_t mb     = {0};
5054
  const char* __nb = __nar;
5055
  size_t j         = __libcpp_mbsrtowcs_l(__wb, &__nb, countof(__wb, __we), &mb, __loc_);
5056
  if (j == size_t(-1))
5057
    __throw_runtime_error("locale not supported");
5058
  __we = __wb + j;
5059
}
5060
#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
5061

5062
// moneypunct_byname
5063

5064
template <class charT>
5065
static void __init_pat(
5066
    money_base::pattern& pat,
5067
    basic_string<charT>& __curr_symbol_,
5068
    bool intl,
5069
    char cs_precedes,
5070
    char sep_by_space,
5071
    char sign_posn,
5072
    charT space_char) {
5073
  const char sign                = static_cast<char>(money_base::sign);
5074
  const char space               = static_cast<char>(money_base::space);
5075
  const char none                = static_cast<char>(money_base::none);
5076
  const char symbol              = static_cast<char>(money_base::symbol);
5077
  const char value               = static_cast<char>(money_base::value);
5078
  const bool symbol_contains_sep = intl && __curr_symbol_.size() == 4;
5079

5080
  // Comments on case branches reflect 'C11 7.11.2.1 The localeconv
5081
  // function'. "Space between sign and symbol or value" means that
5082
  // if the sign is adjacent to the symbol, there's a space between
5083
  // them, and otherwise there's a space between the sign and value.
5084
  //
5085
  // C11's localeconv specifies that the fourth character of an
5086
  // international curr_symbol is used to separate the sign and
5087
  // value when sep_by_space says to do so. C++ can't represent
5088
  // that, so we just use a space.  When sep_by_space says to
5089
  // separate the symbol and value-or-sign with a space, we rearrange the
5090
  // curr_symbol to put its spacing character on the correct side of
5091
  // the symbol.
5092
  //
5093
  // We also need to avoid adding an extra space between the sign
5094
  // and value when the currency symbol is suppressed (by not
5095
  // setting showbase).  We match glibc's strfmon by interpreting
5096
  // sep_by_space==1 as "omit the space when the currency symbol is
5097
  // absent".
5098
  //
5099
  // Users who want to get this right should use ICU instead.
5100

5101
  switch (cs_precedes) {
5102
  case 0: // value before curr_symbol
5103
    if (symbol_contains_sep) {
5104
      // Move the separator to before the symbol, to place it
5105
      // between the value and symbol.
5106
      rotate(__curr_symbol_.begin(), __curr_symbol_.begin() + 3, __curr_symbol_.end());
5107
    }
5108
    switch (sign_posn) {
5109
    case 0: // Parentheses surround the quantity and currency symbol.
5110
      pat.field[0] = sign;
5111
      pat.field[1] = value;
5112
      pat.field[2] = none; // Any space appears in the symbol.
5113
      pat.field[3] = symbol;
5114
      switch (sep_by_space) {
5115
      case 0: // No space separates the currency symbol and value.
5116
              // This case may have changed between C99 and C11;
5117
              // assume the currency symbol matches the intention.
5118
      case 2: // Space between sign and currency or value.
5119
        // The "sign" is two parentheses, so no space here either.
5120
        return;
5121
      case 1: // Space between currency-and-sign or currency and value.
5122
        if (!symbol_contains_sep) {
5123
          // We insert the space into the symbol instead of
5124
          // setting pat.field[2]=space so that when
5125
          // showbase is not set, the space goes away too.
5126
          __curr_symbol_.insert(0, 1, space_char);
5127
        }
5128
        return;
5129
      default:
5130
        break;
5131
      }
5132
      break;
5133
    case 1: // The sign string precedes the quantity and currency symbol.
5134
      pat.field[0] = sign;
5135
      pat.field[3] = symbol;
5136
      switch (sep_by_space) {
5137
      case 0: // No space separates the currency symbol and value.
5138
        pat.field[1] = value;
5139
        pat.field[2] = none;
5140
        return;
5141
      case 1: // Space between currency-and-sign or currency and value.
5142
        pat.field[1] = value;
5143
        pat.field[2] = none;
5144
        if (!symbol_contains_sep) {
5145
          // We insert the space into the symbol instead of
5146
          // setting pat.field[2]=space so that when
5147
          // showbase is not set, the space goes away too.
5148
          __curr_symbol_.insert(0, 1, space_char);
5149
        }
5150
        return;
5151
      case 2: // Space between sign and currency or value.
5152
        pat.field[1] = space;
5153
        pat.field[2] = value;
5154
        if (symbol_contains_sep) {
5155
          // Remove the separator from the symbol, since it
5156
          // has already appeared after the sign.
5157
          __curr_symbol_.erase(__curr_symbol_.begin());
5158
        }
5159
        return;
5160
      default:
5161
        break;
5162
      }
5163
      break;
5164
    case 2: // The sign string succeeds the quantity and currency symbol.
5165
      pat.field[0] = value;
5166
      pat.field[3] = sign;
5167
      switch (sep_by_space) {
5168
      case 0: // No space separates the currency symbol and value.
5169
        pat.field[1] = none;
5170
        pat.field[2] = symbol;
5171
        return;
5172
      case 1: // Space between currency-and-sign or currency and value.
5173
        if (!symbol_contains_sep) {
5174
          // We insert the space into the symbol instead of
5175
          // setting pat.field[1]=space so that when
5176
          // showbase is not set, the space goes away too.
5177
          __curr_symbol_.insert(0, 1, space_char);
5178
        }
5179
        pat.field[1] = none;
5180
        pat.field[2] = symbol;
5181
        return;
5182
      case 2: // Space between sign and currency or value.
5183
        pat.field[1] = symbol;
5184
        pat.field[2] = space;
5185
        if (symbol_contains_sep) {
5186
          // Remove the separator from the symbol, since it
5187
          // should not be removed if showbase is absent.
5188
          __curr_symbol_.erase(__curr_symbol_.begin());
5189
        }
5190
        return;
5191
      default:
5192
        break;
5193
      }
5194
      break;
5195
    case 3: // The sign string immediately precedes the currency symbol.
5196
      pat.field[0] = value;
5197
      pat.field[3] = symbol;
5198
      switch (sep_by_space) {
5199
      case 0: // No space separates the currency symbol and value.
5200
        pat.field[1] = none;
5201
        pat.field[2] = sign;
5202
        return;
5203
      case 1: // Space between currency-and-sign or currency and value.
5204
        pat.field[1] = space;
5205
        pat.field[2] = sign;
5206
        if (symbol_contains_sep) {
5207
          // Remove the separator from the symbol, since it
5208
          // has already appeared before the sign.
5209
          __curr_symbol_.erase(__curr_symbol_.begin());
5210
        }
5211
        return;
5212
      case 2: // Space between sign and currency or value.
5213
        pat.field[1] = sign;
5214
        pat.field[2] = none;
5215
        if (!symbol_contains_sep) {
5216
          // We insert the space into the symbol instead of
5217
          // setting pat.field[2]=space so that when
5218
          // showbase is not set, the space goes away too.
5219
          __curr_symbol_.insert(0, 1, space_char);
5220
        }
5221
        return;
5222
      default:
5223
        break;
5224
      }
5225
      break;
5226
    case 4: // The sign string immediately succeeds the currency symbol.
5227
      pat.field[0] = value;
5228
      pat.field[3] = sign;
5229
      switch (sep_by_space) {
5230
      case 0: // No space separates the currency symbol and value.
5231
        pat.field[1] = none;
5232
        pat.field[2] = symbol;
5233
        return;
5234
      case 1: // Space between currency-and-sign or currency and value.
5235
        pat.field[1] = none;
5236
        pat.field[2] = symbol;
5237
        if (!symbol_contains_sep) {
5238
          // We insert the space into the symbol instead of
5239
          // setting pat.field[1]=space so that when
5240
          // showbase is not set, the space goes away too.
5241
          __curr_symbol_.insert(0, 1, space_char);
5242
        }
5243
        return;
5244
      case 2: // Space between sign and currency or value.
5245
        pat.field[1] = symbol;
5246
        pat.field[2] = space;
5247
        if (symbol_contains_sep) {
5248
          // Remove the separator from the symbol, since it
5249
          // should not disappear when showbase is absent.
5250
          __curr_symbol_.erase(__curr_symbol_.begin());
5251
        }
5252
        return;
5253
      default:
5254
        break;
5255
      }
5256
      break;
5257
    default:
5258
      break;
5259
    }
5260
    break;
5261
  case 1: // curr_symbol before value
5262
    switch (sign_posn) {
5263
    case 0: // Parentheses surround the quantity and currency symbol.
5264
      pat.field[0] = sign;
5265
      pat.field[1] = symbol;
5266
      pat.field[2] = none; // Any space appears in the symbol.
5267
      pat.field[3] = value;
5268
      switch (sep_by_space) {
5269
      case 0: // No space separates the currency symbol and value.
5270
              // This case may have changed between C99 and C11;
5271
              // assume the currency symbol matches the intention.
5272
      case 2: // Space between sign and currency or value.
5273
        // The "sign" is two parentheses, so no space here either.
5274
        return;
5275
      case 1: // Space between currency-and-sign or currency and value.
5276
        if (!symbol_contains_sep) {
5277
          // We insert the space into the symbol instead of
5278
          // setting pat.field[2]=space so that when
5279
          // showbase is not set, the space goes away too.
5280
          __curr_symbol_.insert(0, 1, space_char);
5281
        }
5282
        return;
5283
      default:
5284
        break;
5285
      }
5286
      break;
5287
    case 1: // The sign string precedes the quantity and currency symbol.
5288
      pat.field[0] = sign;
5289
      pat.field[3] = value;
5290
      switch (sep_by_space) {
5291
      case 0: // No space separates the currency symbol and value.
5292
        pat.field[1] = symbol;
5293
        pat.field[2] = none;
5294
        return;
5295
      case 1: // Space between currency-and-sign or currency and value.
5296
        pat.field[1] = symbol;
5297
        pat.field[2] = none;
5298
        if (!symbol_contains_sep) {
5299
          // We insert the space into the symbol instead of
5300
          // setting pat.field[2]=space so that when
5301
          // showbase is not set, the space goes away too.
5302
          __curr_symbol_.push_back(space_char);
5303
        }
5304
        return;
5305
      case 2: // Space between sign and currency or value.
5306
        pat.field[1] = space;
5307
        pat.field[2] = symbol;
5308
        if (symbol_contains_sep) {
5309
          // Remove the separator from the symbol, since it
5310
          // has already appeared after the sign.
5311
          __curr_symbol_.pop_back();
5312
        }
5313
        return;
5314
      default:
5315
        break;
5316
      }
5317
      break;
5318
    case 2: // The sign string succeeds the quantity and currency symbol.
5319
      pat.field[0] = symbol;
5320
      pat.field[3] = sign;
5321
      switch (sep_by_space) {
5322
      case 0: // No space separates the currency symbol and value.
5323
        pat.field[1] = none;
5324
        pat.field[2] = value;
5325
        return;
5326
      case 1: // Space between currency-and-sign or currency and value.
5327
        pat.field[1] = none;
5328
        pat.field[2] = value;
5329
        if (!symbol_contains_sep) {
5330
          // We insert the space into the symbol instead of
5331
          // setting pat.field[1]=space so that when
5332
          // showbase is not set, the space goes away too.
5333
          __curr_symbol_.push_back(space_char);
5334
        }
5335
        return;
5336
      case 2: // Space between sign and currency or value.
5337
        pat.field[1] = value;
5338
        pat.field[2] = space;
5339
        if (symbol_contains_sep) {
5340
          // Remove the separator from the symbol, since it
5341
          // will appear before the sign.
5342
          __curr_symbol_.pop_back();
5343
        }
5344
        return;
5345
      default:
5346
        break;
5347
      }
5348
      break;
5349
    case 3: // The sign string immediately precedes the currency symbol.
5350
      pat.field[0] = sign;
5351
      pat.field[3] = value;
5352
      switch (sep_by_space) {
5353
      case 0: // No space separates the currency symbol and value.
5354
        pat.field[1] = symbol;
5355
        pat.field[2] = none;
5356
        return;
5357
      case 1: // Space between currency-and-sign or currency and value.
5358
        pat.field[1] = symbol;
5359
        pat.field[2] = none;
5360
        if (!symbol_contains_sep) {
5361
          // We insert the space into the symbol instead of
5362
          // setting pat.field[2]=space so that when
5363
          // showbase is not set, the space goes away too.
5364
          __curr_symbol_.push_back(space_char);
5365
        }
5366
        return;
5367
      case 2: // Space between sign and currency or value.
5368
        pat.field[1] = space;
5369
        pat.field[2] = symbol;
5370
        if (symbol_contains_sep) {
5371
          // Remove the separator from the symbol, since it
5372
          // has already appeared after the sign.
5373
          __curr_symbol_.pop_back();
5374
        }
5375
        return;
5376
      default:
5377
        break;
5378
      }
5379
      break;
5380
    case 4: // The sign string immediately succeeds the currency symbol.
5381
      pat.field[0] = symbol;
5382
      pat.field[3] = value;
5383
      switch (sep_by_space) {
5384
      case 0: // No space separates the currency symbol and value.
5385
        pat.field[1] = sign;
5386
        pat.field[2] = none;
5387
        return;
5388
      case 1: // Space between currency-and-sign or currency and value.
5389
        pat.field[1] = sign;
5390
        pat.field[2] = space;
5391
        if (symbol_contains_sep) {
5392
          // Remove the separator from the symbol, since it
5393
          // should not disappear when showbase is absent.
5394
          __curr_symbol_.pop_back();
5395
        }
5396
        return;
5397
      case 2: // Space between sign and currency or value.
5398
        pat.field[1] = none;
5399
        pat.field[2] = sign;
5400
        if (!symbol_contains_sep) {
5401
          // We insert the space into the symbol instead of
5402
          // setting pat.field[1]=space so that when
5403
          // showbase is not set, the space goes away too.
5404
          __curr_symbol_.push_back(space_char);
5405
        }
5406
        return;
5407
      default:
5408
        break;
5409
      }
5410
      break;
5411
    default:
5412
      break;
5413
    }
5414
    break;
5415
  default:
5416
    break;
5417
  }
5418
  pat.field[0] = symbol;
5419
  pat.field[1] = sign;
5420
  pat.field[2] = none;
5421
  pat.field[3] = value;
5422
}
5423

5424
template <>
5425
void moneypunct_byname<char, false>::init(const char* nm) {
5426
  typedef moneypunct<char, false> base;
5427
  __libcpp_unique_locale loc(nm);
5428
  if (!loc)
5429
    __throw_runtime_error(("moneypunct_byname failed to construct for " + string(nm)).c_str());
5430

5431
  lconv* lc = __libcpp_localeconv_l(loc.get());
5432
  if (!checked_string_to_char_convert(__decimal_point_, lc->mon_decimal_point, loc.get()))
5433
    __decimal_point_ = base::do_decimal_point();
5434
  if (!checked_string_to_char_convert(__thousands_sep_, lc->mon_thousands_sep, loc.get()))
5435
    __thousands_sep_ = base::do_thousands_sep();
5436

5437
  __grouping_    = lc->mon_grouping;
5438
  __curr_symbol_ = lc->currency_symbol;
5439
  if (lc->frac_digits != CHAR_MAX)
5440
    __frac_digits_ = lc->frac_digits;
5441
  else
5442
    __frac_digits_ = base::do_frac_digits();
5443
  if (lc->p_sign_posn == 0)
5444
    __positive_sign_ = "()";
5445
  else
5446
    __positive_sign_ = lc->positive_sign;
5447
  if (lc->n_sign_posn == 0)
5448
    __negative_sign_ = "()";
5449
  else
5450
    __negative_sign_ = lc->negative_sign;
5451
  // Assume the positive and negative formats will want spaces in
5452
  // the same places in curr_symbol since there's no way to
5453
  // represent anything else.
5454
  string_type __dummy_curr_symbol = __curr_symbol_;
5455
  __init_pat(__pos_format_, __dummy_curr_symbol, false, lc->p_cs_precedes, lc->p_sep_by_space, lc->p_sign_posn, ' ');
5456
  __init_pat(__neg_format_, __curr_symbol_, false, lc->n_cs_precedes, lc->n_sep_by_space, lc->n_sign_posn, ' ');
5457
}
5458

5459
template <>
5460
void moneypunct_byname<char, true>::init(const char* nm) {
5461
  typedef moneypunct<char, true> base;
5462
  __libcpp_unique_locale loc(nm);
5463
  if (!loc)
5464
    __throw_runtime_error(("moneypunct_byname failed to construct for " + string(nm)).c_str());
5465

5466
  lconv* lc = __libcpp_localeconv_l(loc.get());
5467
  if (!checked_string_to_char_convert(__decimal_point_, lc->mon_decimal_point, loc.get()))
5468
    __decimal_point_ = base::do_decimal_point();
5469
  if (!checked_string_to_char_convert(__thousands_sep_, lc->mon_thousands_sep, loc.get()))
5470
    __thousands_sep_ = base::do_thousands_sep();
5471
  __grouping_    = lc->mon_grouping;
5472
  __curr_symbol_ = lc->int_curr_symbol;
5473
  if (lc->int_frac_digits != CHAR_MAX)
5474
    __frac_digits_ = lc->int_frac_digits;
5475
  else
5476
    __frac_digits_ = base::do_frac_digits();
5477
#if defined(_LIBCPP_MSVCRT) || defined(__MINGW32__)
5478
  if (lc->p_sign_posn == 0)
5479
#else  // _LIBCPP_MSVCRT
5480
  if (lc->int_p_sign_posn == 0)
5481
#endif // !_LIBCPP_MSVCRT
5482
    __positive_sign_ = "()";
5483
  else
5484
    __positive_sign_ = lc->positive_sign;
5485
#if defined(_LIBCPP_MSVCRT) || defined(__MINGW32__)
5486
  if (lc->n_sign_posn == 0)
5487
#else  // _LIBCPP_MSVCRT
5488
  if (lc->int_n_sign_posn == 0)
5489
#endif // !_LIBCPP_MSVCRT
5490
    __negative_sign_ = "()";
5491
  else
5492
    __negative_sign_ = lc->negative_sign;
5493
  // Assume the positive and negative formats will want spaces in
5494
  // the same places in curr_symbol since there's no way to
5495
  // represent anything else.
5496
  string_type __dummy_curr_symbol = __curr_symbol_;
5497
#if defined(_LIBCPP_MSVCRT) || defined(__MINGW32__)
5498
  __init_pat(__pos_format_, __dummy_curr_symbol, true, lc->p_cs_precedes, lc->p_sep_by_space, lc->p_sign_posn, ' ');
5499
  __init_pat(__neg_format_, __curr_symbol_, true, lc->n_cs_precedes, lc->n_sep_by_space, lc->n_sign_posn, ' ');
5500
#else  // _LIBCPP_MSVCRT
5501
  __init_pat(
5502
      __pos_format_,
5503
      __dummy_curr_symbol,
5504
      true,
5505
      lc->int_p_cs_precedes,
5506
      lc->int_p_sep_by_space,
5507
      lc->int_p_sign_posn,
5508
      ' ');
5509
  __init_pat(
5510
      __neg_format_, __curr_symbol_, true, lc->int_n_cs_precedes, lc->int_n_sep_by_space, lc->int_n_sign_posn, ' ');
5511
#endif // !_LIBCPP_MSVCRT
5512
}
5513

5514
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
5515
template <>
5516
void moneypunct_byname<wchar_t, false>::init(const char* nm) {
5517
  typedef moneypunct<wchar_t, false> base;
5518
  __libcpp_unique_locale loc(nm);
5519
  if (!loc)
5520
    __throw_runtime_error(("moneypunct_byname failed to construct for " + string(nm)).c_str());
5521
  lconv* lc = __libcpp_localeconv_l(loc.get());
5522
  if (!checked_string_to_wchar_convert(__decimal_point_, lc->mon_decimal_point, loc.get()))
5523
    __decimal_point_ = base::do_decimal_point();
5524
  if (!checked_string_to_wchar_convert(__thousands_sep_, lc->mon_thousands_sep, loc.get()))
5525
    __thousands_sep_ = base::do_thousands_sep();
5526
  __grouping_ = lc->mon_grouping;
5527
  wchar_t wbuf[100];
5528
  mbstate_t mb   = {0};
5529
  const char* bb = lc->currency_symbol;
5530
  size_t j       = __libcpp_mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, loc.get());
5531
  if (j == size_t(-1))
5532
    __throw_runtime_error("locale not supported");
5533
  wchar_t* wbe = wbuf + j;
5534
  __curr_symbol_.assign(wbuf, wbe);
5535
  if (lc->frac_digits != CHAR_MAX)
5536
    __frac_digits_ = lc->frac_digits;
5537
  else
5538
    __frac_digits_ = base::do_frac_digits();
5539
  if (lc->p_sign_posn == 0)
5540
    __positive_sign_ = L"()";
5541
  else {
5542
    mb = mbstate_t();
5543
    bb = lc->positive_sign;
5544
    j  = __libcpp_mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, loc.get());
5545
    if (j == size_t(-1))
5546
      __throw_runtime_error("locale not supported");
5547
    wbe = wbuf + j;
5548
    __positive_sign_.assign(wbuf, wbe);
5549
  }
5550
  if (lc->n_sign_posn == 0)
5551
    __negative_sign_ = L"()";
5552
  else {
5553
    mb = mbstate_t();
5554
    bb = lc->negative_sign;
5555
    j  = __libcpp_mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, loc.get());
5556
    if (j == size_t(-1))
5557
      __throw_runtime_error("locale not supported");
5558
    wbe = wbuf + j;
5559
    __negative_sign_.assign(wbuf, wbe);
5560
  }
5561
  // Assume the positive and negative formats will want spaces in
5562
  // the same places in curr_symbol since there's no way to
5563
  // represent anything else.
5564
  string_type __dummy_curr_symbol = __curr_symbol_;
5565
  __init_pat(__pos_format_, __dummy_curr_symbol, false, lc->p_cs_precedes, lc->p_sep_by_space, lc->p_sign_posn, L' ');
5566
  __init_pat(__neg_format_, __curr_symbol_, false, lc->n_cs_precedes, lc->n_sep_by_space, lc->n_sign_posn, L' ');
5567
}
5568

5569
template <>
5570
void moneypunct_byname<wchar_t, true>::init(const char* nm) {
5571
  typedef moneypunct<wchar_t, true> base;
5572
  __libcpp_unique_locale loc(nm);
5573
  if (!loc)
5574
    __throw_runtime_error(("moneypunct_byname failed to construct for " + string(nm)).c_str());
5575

5576
  lconv* lc = __libcpp_localeconv_l(loc.get());
5577
  if (!checked_string_to_wchar_convert(__decimal_point_, lc->mon_decimal_point, loc.get()))
5578
    __decimal_point_ = base::do_decimal_point();
5579
  if (!checked_string_to_wchar_convert(__thousands_sep_, lc->mon_thousands_sep, loc.get()))
5580
    __thousands_sep_ = base::do_thousands_sep();
5581
  __grouping_ = lc->mon_grouping;
5582
  wchar_t wbuf[100];
5583
  mbstate_t mb   = {0};
5584
  const char* bb = lc->int_curr_symbol;
5585
  size_t j       = __libcpp_mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, loc.get());
5586
  if (j == size_t(-1))
5587
    __throw_runtime_error("locale not supported");
5588
  wchar_t* wbe = wbuf + j;
5589
  __curr_symbol_.assign(wbuf, wbe);
5590
  if (lc->int_frac_digits != CHAR_MAX)
5591
    __frac_digits_ = lc->int_frac_digits;
5592
  else
5593
    __frac_digits_ = base::do_frac_digits();
5594
#  if defined(_LIBCPP_MSVCRT) || defined(__MINGW32__)
5595
  if (lc->p_sign_posn == 0)
5596
#  else  // _LIBCPP_MSVCRT
5597
  if (lc->int_p_sign_posn == 0)
5598
#  endif // !_LIBCPP_MSVCRT
5599
    __positive_sign_ = L"()";
5600
  else {
5601
    mb = mbstate_t();
5602
    bb = lc->positive_sign;
5603
    j  = __libcpp_mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, loc.get());
5604
    if (j == size_t(-1))
5605
      __throw_runtime_error("locale not supported");
5606
    wbe = wbuf + j;
5607
    __positive_sign_.assign(wbuf, wbe);
5608
  }
5609
#  if defined(_LIBCPP_MSVCRT) || defined(__MINGW32__)
5610
  if (lc->n_sign_posn == 0)
5611
#  else  // _LIBCPP_MSVCRT
5612
  if (lc->int_n_sign_posn == 0)
5613
#  endif // !_LIBCPP_MSVCRT
5614
    __negative_sign_ = L"()";
5615
  else {
5616
    mb = mbstate_t();
5617
    bb = lc->negative_sign;
5618
    j  = __libcpp_mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, loc.get());
5619
    if (j == size_t(-1))
5620
      __throw_runtime_error("locale not supported");
5621
    wbe = wbuf + j;
5622
    __negative_sign_.assign(wbuf, wbe);
5623
  }
5624
  // Assume the positive and negative formats will want spaces in
5625
  // the same places in curr_symbol since there's no way to
5626
  // represent anything else.
5627
  string_type __dummy_curr_symbol = __curr_symbol_;
5628
#  if defined(_LIBCPP_MSVCRT) || defined(__MINGW32__)
5629
  __init_pat(__pos_format_, __dummy_curr_symbol, true, lc->p_cs_precedes, lc->p_sep_by_space, lc->p_sign_posn, L' ');
5630
  __init_pat(__neg_format_, __curr_symbol_, true, lc->n_cs_precedes, lc->n_sep_by_space, lc->n_sign_posn, L' ');
5631
#  else  // _LIBCPP_MSVCRT
5632
  __init_pat(
5633
      __pos_format_,
5634
      __dummy_curr_symbol,
5635
      true,
5636
      lc->int_p_cs_precedes,
5637
      lc->int_p_sep_by_space,
5638
      lc->int_p_sign_posn,
5639
      L' ');
5640
  __init_pat(
5641
      __neg_format_, __curr_symbol_, true, lc->int_n_cs_precedes, lc->int_n_sep_by_space, lc->int_n_sign_posn, L' ');
5642
#  endif // !_LIBCPP_MSVCRT
5643
}
5644
#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
5645

5646
void __do_nothing(void*) {}
5647

5648
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS collate<char>;
5649
_LIBCPP_IF_WIDE_CHARACTERS(template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS collate<wchar_t>;)
5650

5651
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS num_get<char>;
5652
_LIBCPP_IF_WIDE_CHARACTERS(template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS num_get<wchar_t>;)
5653

5654
template struct _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS __num_get<char>;
5655
_LIBCPP_IF_WIDE_CHARACTERS(template struct _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS __num_get<wchar_t>;)
5656

5657
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS num_put<char>;
5658
_LIBCPP_IF_WIDE_CHARACTERS(template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS num_put<wchar_t>;)
5659

5660
template struct _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS __num_put<char>;
5661
_LIBCPP_IF_WIDE_CHARACTERS(template struct _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS __num_put<wchar_t>;)
5662

5663
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS time_get<char>;
5664
_LIBCPP_IF_WIDE_CHARACTERS(template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS time_get<wchar_t>;)
5665

5666
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS time_get_byname<char>;
5667
_LIBCPP_IF_WIDE_CHARACTERS(template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS time_get_byname<wchar_t>;)
5668

5669
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS time_put<char>;
5670
_LIBCPP_IF_WIDE_CHARACTERS(template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS time_put<wchar_t>;)
5671

5672
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS time_put_byname<char>;
5673
_LIBCPP_IF_WIDE_CHARACTERS(template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS time_put_byname<wchar_t>;)
5674

5675
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS moneypunct<char, false>;
5676
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS moneypunct<char, true>;
5677
_LIBCPP_IF_WIDE_CHARACTERS(template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS moneypunct<wchar_t, false>;)
5678
_LIBCPP_IF_WIDE_CHARACTERS(template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS moneypunct<wchar_t, true>;)
5679

5680
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS moneypunct_byname<char, false>;
5681
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS moneypunct_byname<char, true>;
5682
_LIBCPP_IF_WIDE_CHARACTERS(template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS moneypunct_byname<wchar_t, false>;)
5683
_LIBCPP_IF_WIDE_CHARACTERS(template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS moneypunct_byname<wchar_t, true>;)
5684

5685
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS money_get<char>;
5686
_LIBCPP_IF_WIDE_CHARACTERS(template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS money_get<wchar_t>;)
5687

5688
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS __money_get<char>;
5689
_LIBCPP_IF_WIDE_CHARACTERS(template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS __money_get<wchar_t>;)
5690

5691
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS money_put<char>;
5692
_LIBCPP_IF_WIDE_CHARACTERS(template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS money_put<wchar_t>;)
5693

5694
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS __money_put<char>;
5695
_LIBCPP_IF_WIDE_CHARACTERS(template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS __money_put<wchar_t>;)
5696

5697
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS messages<char>;
5698
_LIBCPP_IF_WIDE_CHARACTERS(template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS messages<wchar_t>;)
5699

5700
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS messages_byname<char>;
5701
_LIBCPP_IF_WIDE_CHARACTERS(template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS messages_byname<wchar_t>;)
5702

5703
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS codecvt_byname<char, char, mbstate_t>;
5704
_LIBCPP_IF_WIDE_CHARACTERS(
5705
    template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS codecvt_byname<wchar_t, char, mbstate_t>;)
5706
template class _LIBCPP_DEPRECATED_IN_CXX20 _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS
5707
    codecvt_byname<char16_t, char, mbstate_t>;
5708
template class _LIBCPP_DEPRECATED_IN_CXX20 _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS
5709
    codecvt_byname<char32_t, char, mbstate_t>;
5710
#ifndef _LIBCPP_HAS_NO_CHAR8_T
5711
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS codecvt_byname<char16_t, char8_t, mbstate_t>;
5712
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS codecvt_byname<char32_t, char8_t, mbstate_t>;
5713
#endif
5714

5715
_LIBCPP_END_NAMESPACE_STD
5716

5717
_LIBCPP_POP_MACROS
5718
llvm-project

Использование cookies
