1// Character Traits for use by standard string and iostream -*- C++ -*-
2
3// Copyright (C) 1997-2022 Free Software Foundation, Inc.
4//
5// This file is part of the GNU ISO C++ Library. This library is free
6// software; you can redistribute it and/or modify it under the
7// terms of the GNU General Public License as published by the
8// Free Software Foundation; either version 3, or (at your option)
9// any later version.
10
11// This library is distributed in the hope that it will be useful,
12// but WITHOUT ANY WARRANTY; without even the implied warranty of
13// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14// GNU General Public License for more details.
15
16// Under Section 7 of GPL version 3, you are granted additional
17// permissions described in the GCC Runtime Library Exception, version
18// 3.1, as published by the Free Software Foundation.
19
20// You should have received a copy of the GNU General Public License and
21// a copy of the GCC Runtime Library Exception along with this program;
22// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
23// <http://www.gnu.org/licenses/>.
24
25/** @file bits/char_traits.h
26 * This is an internal header file, included by other library headers.
27 * Do not attempt to use it directly. @headername{string}
28 */
29
30//
31// ISO C++ 14882: 21 Strings library
32//
33
34#ifndef _CHAR_TRAITS_H
35#define _CHAR_TRAITS_H 1
36
37#pragma GCC system_header
38
39#include <bits/postypes.h> // For streampos
40#include <cwchar> // For WEOF, wmemmove, wmemset, etc.
41#if __cplusplus >= 201103L
42# include <type_traits>
43#endif
44#if __cplusplus >= 202002L
45# include <compare>
46# include <bits/stl_construct.h>
47#endif
48
49#ifndef _GLIBCXX_ALWAYS_INLINE
50# define _GLIBCXX_ALWAYS_INLINE inline __attribute__((__always_inline__))
51#endif
52
53namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
54{
55_GLIBCXX_BEGIN_NAMESPACE_VERSION
56
57#pragma GCC diagnostic push
58#pragma GCC diagnostic ignored "-Wstringop-overflow"
59#pragma GCC diagnostic ignored "-Wstringop-overread"
60#pragma GCC diagnostic ignored "-Warray-bounds"
61
62 /**
63 * @brief Mapping from character type to associated types.
64 *
65 * @note This is an implementation class for the generic version
66 * of char_traits. It defines int_type, off_type, pos_type, and
67 * state_type. By default these are unsigned long, streamoff,
68 * streampos, and mbstate_t. Users who need a different set of
69 * types, but who don't need to change the definitions of any function
70 * defined in char_traits, can specialize __gnu_cxx::_Char_types
71 * while leaving __gnu_cxx::char_traits alone. */
72 template<typename _CharT>
73 struct _Char_types
74 {
75 typedef unsigned long int_type;
76 typedef std::streampos pos_type;
77 typedef std::streamoff off_type;
78 typedef std::mbstate_t state_type;
79 };
80
81
82 /**
83 * @brief Base class used to implement std::char_traits.
84 *
85 * @note For any given actual character type, this definition is
86 * probably wrong. (Most of the member functions are likely to be
87 * right, but the int_type and state_type typedefs, and the eof()
88 * member function, are likely to be wrong.) The reason this class
89 * exists is so users can specialize it. Classes in namespace std
90 * may not be specialized for fundamental types, but classes in
91 * namespace __gnu_cxx may be.
92 *
93 * See https://gcc.gnu.org/onlinedocs/libstdc++/manual/strings.html#strings.string.character_types
94 * for advice on how to make use of this class for @a unusual character
95 * types. Also, check out include/ext/pod_char_traits.h.
96 */
97 template<typename _CharT>
98 struct char_traits
99 {
100 typedef _CharT char_type;
101 typedef typename _Char_types<_CharT>::int_type int_type;
102 typedef typename _Char_types<_CharT>::pos_type pos_type;
103 typedef typename _Char_types<_CharT>::off_type off_type;
104 typedef typename _Char_types<_CharT>::state_type state_type;
105#if __cpp_lib_three_way_comparison
106 using comparison_category = std::strong_ordering;
107#endif
108
109 static _GLIBCXX14_CONSTEXPR void
110 assign(char_type& __c1, const char_type& __c2)
111 {
112#if __cpp_constexpr_dynamic_alloc
113 if (std::__is_constant_evaluated())
114 std::construct_at(__builtin_addressof(__c1), __c2);
115 else
116#endif
117 __c1 = __c2;
118 }
119
120 static _GLIBCXX_CONSTEXPR bool
121 eq(const char_type& __c1, const char_type& __c2)
122 { return __c1 == __c2; }
123
124 static _GLIBCXX_CONSTEXPR bool
125 lt(const char_type& __c1, const char_type& __c2)
126 { return __c1 < __c2; }
127
128 static _GLIBCXX14_CONSTEXPR int
129 compare(const char_type* __s1, const char_type* __s2, std::size_t __n);
130
131 static _GLIBCXX14_CONSTEXPR std::size_t
132 length(const char_type* __s);
133
134 static _GLIBCXX14_CONSTEXPR const char_type*
135 find(const char_type* __s, std::size_t __n, const char_type& __a);
136
137 static _GLIBCXX20_CONSTEXPR char_type*
138 move(char_type* __s1, const char_type* __s2, std::size_t __n);
139
140 static _GLIBCXX20_CONSTEXPR char_type*
141 copy(char_type* __s1, const char_type* __s2, std::size_t __n);
142
143 static _GLIBCXX20_CONSTEXPR char_type*
144 assign(char_type* __s, std::size_t __n, char_type __a);
145
146 static _GLIBCXX_CONSTEXPR char_type
147 to_char_type(const int_type& __c)
148 { return static_cast<char_type>(__c); }
149
150 static _GLIBCXX_CONSTEXPR int_type
151 to_int_type(const char_type& __c)
152 { return static_cast<int_type>(__c); }
153
154 static _GLIBCXX_CONSTEXPR bool
155 eq_int_type(const int_type& __c1, const int_type& __c2)
156 { return __c1 == __c2; }
157
158 static _GLIBCXX_CONSTEXPR int_type
159 eof()
160 { return static_cast<int_type>(_GLIBCXX_STDIO_EOF); }
161
162 static _GLIBCXX_CONSTEXPR int_type
163 not_eof(const int_type& __c)
164 { return !eq_int_type(__c, eof()) ? __c : to_int_type(char_type()); }
165 };
166
167 template<typename _CharT>
168 _GLIBCXX14_CONSTEXPR int
169 char_traits<_CharT>::
170 compare(const char_type* __s1, const char_type* __s2, std::size_t __n)
171 {
172 for (std::size_t __i = 0; __i < __n; ++__i)
173 if (lt(__s1[__i], __s2[__i]))
174 return -1;
175 else if (lt(__s2[__i], __s1[__i]))
176 return 1;
177 return 0;
178 }
179
180 template<typename _CharT>
181 _GLIBCXX14_CONSTEXPR std::size_t
182 char_traits<_CharT>::
183 length(const char_type* __p)
184 {
185 std::size_t __i = 0;
186 while (!eq(__p[__i], char_type()))
187 ++__i;
188 return __i;
189 }
190
191 template<typename _CharT>
192 _GLIBCXX14_CONSTEXPR const typename char_traits<_CharT>::char_type*
193 char_traits<_CharT>::
194 find(const char_type* __s, std::size_t __n, const char_type& __a)
195 {
196 for (std::size_t __i = 0; __i < __n; ++__i)
197 if (eq(__s[__i], __a))
198 return __s + __i;
199 return 0;
200 }
201
202 template<typename _CharT>
203 _GLIBCXX20_CONSTEXPR
204 typename char_traits<_CharT>::char_type*
205 char_traits<_CharT>::
206 move(char_type* __s1, const char_type* __s2, std::size_t __n)
207 {
208 if (__n == 0)
209 return __s1;
210#if __cplusplus >= 202002L
211 if (std::__is_constant_evaluated())
212 {
213 if (__s1 == __s2) // unlikely, but saves a lot of work
214 return __s1;
215#if __cpp_constexpr_dynamic_alloc
216 // The overlap detection below fails due to PR c++/89074,
217 // so use a temporary buffer instead.
218 char_type* __tmp = new char_type[__n];
219 copy(__tmp, __s2, __n);
220 copy(__s1, __tmp, __n);
221 delete[] __tmp;
222#else
223 const auto __end = __s2 + __n - 1;
224 bool __overlap = false;
225 for (std::size_t __i = 0; __i < __n - 1; ++__i)
226 {
227 if (__s1 + __i == __end)
228 {
229 __overlap = true;
230 break;
231 }
232 }
233 if (__overlap)
234 {
235 do
236 {
237 --__n;
238 assign(__s1[__n], __s2[__n]);
239 }
240 while (__n > 0);
241 }
242 else
243 copy(__s1, __s2, __n);
244#endif
245 return __s1;
246 }
247#endif
248 __builtin_memmove(__s1, __s2, __n * sizeof(char_type));
249 return __s1;
250 }
251
252 template<typename _CharT>
253 _GLIBCXX20_CONSTEXPR
254 typename char_traits<_CharT>::char_type*
255 char_traits<_CharT>::
256 copy(char_type* __s1, const char_type* __s2, std::size_t __n)
257 {
258#if __cplusplus >= 202002L
259 if (std::__is_constant_evaluated())
260 {
261 for (std::size_t __i = 0; __i < __n; ++__i)
262 std::construct_at(__s1 + __i, __s2[__i]);
263 return __s1;
264 }
265#endif
266
267 __builtin_memcpy(__s1, __s2, __n * sizeof(char_type));
268 return __s1;
269 }
270
271 template<typename _CharT>
272 _GLIBCXX20_CONSTEXPR
273 typename char_traits<_CharT>::char_type*
274 char_traits<_CharT>::
275 assign(char_type* __s, std::size_t __n, char_type __a)
276 {
277#if __cplusplus >= 202002L
278 if (std::__is_constant_evaluated())
279 {
280 for (std::size_t __i = 0; __i < __n; ++__i)
281 std::construct_at(__s + __i, __a);
282 return __s;
283 }
284#endif
285
286 if _GLIBCXX17_CONSTEXPR (sizeof(_CharT) == 1 && __is_trivial(_CharT))
287 {
288 unsigned char __c;
289 __builtin_memcpy(&__c, __builtin_addressof(__a), 1);
290 __builtin_memset(__s, __c, __n);
291 }
292 else
293 {
294 for (std::size_t __i = 0; __i < __n; ++__i)
295 __s[__i] = __a;
296 }
297 return __s;
298 }
299
300_GLIBCXX_END_NAMESPACE_VERSION
301} // namespace
302
303namespace std _GLIBCXX_VISIBILITY(default)
304{
305_GLIBCXX_BEGIN_NAMESPACE_VERSION
306
307#ifdef __cpp_lib_is_constant_evaluated
308// Unofficial macro indicating P1032R1 support in C++20
309# define __cpp_lib_constexpr_char_traits 201811L
310#elif __cplusplus >= 201703L && _GLIBCXX_HAVE_IS_CONSTANT_EVALUATED
311// Unofficial macro indicating P0426R1 support in C++17
312# define __cpp_lib_constexpr_char_traits 201611L
313#endif
314
315 // 21.1
316 /**
317 * @brief Basis for explicit traits specializations.
318 *
319 * @note For any given actual character type, this definition is
320 * probably wrong. Since this is just a thin wrapper around
321 * __gnu_cxx::char_traits, it is possible to achieve a more
322 * appropriate definition by specializing __gnu_cxx::char_traits.
323 *
324 * See https://gcc.gnu.org/onlinedocs/libstdc++/manual/strings.html#strings.string.character_types
325 * for advice on how to make use of this class for @a unusual character
326 * types. Also, check out include/ext/pod_char_traits.h.
327 */
328 template<typename _CharT>
329 struct char_traits : public __gnu_cxx::char_traits<_CharT>
330 { };
331
332
333 /// 21.1.3.1 char_traits specializations
334 template<>
335 struct char_traits<char>
336 {
337 typedef char char_type;
338 typedef int int_type;
339 typedef streampos pos_type;
340 typedef streamoff off_type;
341 typedef mbstate_t state_type;
342#if __cpp_lib_three_way_comparison
343 using comparison_category = strong_ordering;
344#endif
345
346 static _GLIBCXX17_CONSTEXPR void
347 assign(char_type& __c1, const char_type& __c2) _GLIBCXX_NOEXCEPT
348 {
349#if __cpp_constexpr_dynamic_alloc
350 if (std::__is_constant_evaluated())
351 std::construct_at(__builtin_addressof(__c1), __c2);
352 else
353#endif
354 __c1 = __c2;
355 }
356
357 static _GLIBCXX_CONSTEXPR bool
358 eq(const char_type& __c1, const char_type& __c2) _GLIBCXX_NOEXCEPT
359 { return __c1 == __c2; }
360
361 static _GLIBCXX_CONSTEXPR bool
362 lt(const char_type& __c1, const char_type& __c2) _GLIBCXX_NOEXCEPT
363 {
364 // LWG 467.
365 return (static_cast<unsigned char>(__c1)
366 < static_cast<unsigned char>(__c2));
367 }
368
369 static _GLIBCXX17_CONSTEXPR int
370 compare(const char_type* __s1, const char_type* __s2, size_t __n)
371 {
372 if (__n == 0)
373 return 0;
374#if __cplusplus >= 201703L
375 if (std::__is_constant_evaluated())
376 {
377 for (size_t __i = 0; __i < __n; ++__i)
378 if (lt(__s1[__i], __s2[__i]))
379 return -1;
380 else if (lt(__s2[__i], __s1[__i]))
381 return 1;
382 return 0;
383 }
384#endif
385 return __builtin_memcmp(__s1, __s2, __n);
386 }
387
388 static _GLIBCXX17_CONSTEXPR size_t
389 length(const char_type* __s)
390 {
391#if __cplusplus >= 201703L
392 if (std::__is_constant_evaluated())
393 return __gnu_cxx::char_traits<char_type>::length(__s);
394#endif
395 return __builtin_strlen(__s);
396 }
397
398 static _GLIBCXX17_CONSTEXPR const char_type*
399 find(const char_type* __s, size_t __n, const char_type& __a)
400 {
401 if (__n == 0)
402 return 0;
403#if __cplusplus >= 201703L
404 if (std::__is_constant_evaluated())
405 return __gnu_cxx::char_traits<char_type>::find(__s, __n, __a);
406#endif
407 return static_cast<const char_type*>(__builtin_memchr(__s, __a, __n));
408 }
409
410 static _GLIBCXX20_CONSTEXPR char_type*
411 move(char_type* __s1, const char_type* __s2, size_t __n)
412 {
413 if (__n == 0)
414 return __s1;
415#if __cplusplus >= 202002L
416 if (std::__is_constant_evaluated())
417 return __gnu_cxx::char_traits<char_type>::move(__s1, __s2, __n);
418#endif
419 return static_cast<char_type*>(__builtin_memmove(__s1, __s2, __n));
420 }
421
422 static _GLIBCXX20_CONSTEXPR char_type*
423 copy(char_type* __s1, const char_type* __s2, size_t __n)
424 {
425 if (__n == 0)
426 return __s1;
427#if __cplusplus >= 202002L
428 if (std::__is_constant_evaluated())
429 return __gnu_cxx::char_traits<char_type>::copy(__s1, __s2, __n);
430#endif
431 return static_cast<char_type*>(__builtin_memcpy(__s1, __s2, __n));
432 }
433
434 static _GLIBCXX20_CONSTEXPR char_type*
435 assign(char_type* __s, size_t __n, char_type __a)
436 {
437 if (__n == 0)
438 return __s;
439#if __cplusplus >= 202002L
440 if (std::__is_constant_evaluated())
441 return __gnu_cxx::char_traits<char_type>::assign(__s, __n, __a);
442#endif
443 return static_cast<char_type*>(__builtin_memset(__s, __a, __n));
444 }
445
446 static _GLIBCXX_CONSTEXPR char_type
447 to_char_type(const int_type& __c) _GLIBCXX_NOEXCEPT
448 { return static_cast<char_type>(__c); }
449
450 // To keep both the byte 0xff and the eof symbol 0xffffffff
451 // from ending up as 0xffffffff.
452 static _GLIBCXX_CONSTEXPR int_type
453 to_int_type(const char_type& __c) _GLIBCXX_NOEXCEPT
454 { return static_cast<int_type>(static_cast<unsigned char>(__c)); }
455
456 static _GLIBCXX_CONSTEXPR bool
457 eq_int_type(const int_type& __c1, const int_type& __c2) _GLIBCXX_NOEXCEPT
458 { return __c1 == __c2; }
459
460 static _GLIBCXX_CONSTEXPR int_type
461 eof() _GLIBCXX_NOEXCEPT
462 { return static_cast<int_type>(_GLIBCXX_STDIO_EOF); }
463
464 static _GLIBCXX_CONSTEXPR int_type
465 not_eof(const int_type& __c) _GLIBCXX_NOEXCEPT
466 { return (__c == eof()) ? 0 : __c; }
467 };
468
469
470#ifdef _GLIBCXX_USE_WCHAR_T
471 /// 21.1.3.2 char_traits specializations
472 template<>
473 struct char_traits<wchar_t>
474 {
475 typedef wchar_t char_type;
476 typedef wint_t int_type;
477 typedef streamoff off_type;
478 typedef wstreampos pos_type;
479 typedef mbstate_t state_type;
480#if __cpp_lib_three_way_comparison
481 using comparison_category = strong_ordering;
482#endif
483
484 static _GLIBCXX17_CONSTEXPR void
485 assign(char_type& __c1, const char_type& __c2) _GLIBCXX_NOEXCEPT
486 {
487#if __cpp_constexpr_dynamic_alloc
488 if (std::__is_constant_evaluated())
489 std::construct_at(__builtin_addressof(__c1), __c2);
490 else
491#endif
492 __c1 = __c2;
493 }
494
495 static _GLIBCXX_CONSTEXPR bool
496 eq(const char_type& __c1, const char_type& __c2) _GLIBCXX_NOEXCEPT
497 { return __c1 == __c2; }
498
499 static _GLIBCXX_CONSTEXPR bool
500 lt(const char_type& __c1, const char_type& __c2) _GLIBCXX_NOEXCEPT
501 { return __c1 < __c2; }
502
503 static _GLIBCXX17_CONSTEXPR int
504 compare(const char_type* __s1, const char_type* __s2, size_t __n)
505 {
506 if (__n == 0)
507 return 0;
508#if __cplusplus >= 201703L
509 if (std::__is_constant_evaluated())
510 return __gnu_cxx::char_traits<char_type>::compare(__s1, __s2, __n);
511#endif
512 return wmemcmp(__s1, __s2, __n);
513 }
514
515 static _GLIBCXX17_CONSTEXPR size_t
516 length(const char_type* __s)
517 {
518#if __cplusplus >= 201703L
519 if (std::__is_constant_evaluated())
520 return __gnu_cxx::char_traits<char_type>::length(__s);
521#endif
522 return wcslen(__s);
523 }
524
525 static _GLIBCXX17_CONSTEXPR const char_type*
526 find(const char_type* __s, size_t __n, const char_type& __a)
527 {
528 if (__n == 0)
529 return 0;
530#if __cplusplus >= 201703L
531 if (std::__is_constant_evaluated())
532 return __gnu_cxx::char_traits<char_type>::find(__s, __n, __a);
533#endif
534 return wmemchr(__s, __a, __n);
535 }
536
537 static _GLIBCXX20_CONSTEXPR char_type*
538 move(char_type* __s1, const char_type* __s2, size_t __n)
539 {
540 if (__n == 0)
541 return __s1;
542#if __cplusplus >= 202002L
543 if (std::__is_constant_evaluated())
544 return __gnu_cxx::char_traits<char_type>::move(__s1, __s2, __n);
545#endif
546 return wmemmove(__s1, __s2, __n);
547 }
548
549 static _GLIBCXX20_CONSTEXPR char_type*
550 copy(char_type* __s1, const char_type* __s2, size_t __n)
551 {
552 if (__n == 0)
553 return __s1;
554#if __cplusplus >= 202002L
555 if (std::__is_constant_evaluated())
556 return __gnu_cxx::char_traits<char_type>::copy(__s1, __s2, __n);
557#endif
558 return wmemcpy(__s1, __s2, __n);
559 }
560
561 static _GLIBCXX20_CONSTEXPR char_type*
562 assign(char_type* __s, size_t __n, char_type __a)
563 {
564 if (__n == 0)
565 return __s;
566#if __cplusplus >= 202002L
567 if (std::__is_constant_evaluated())
568 return __gnu_cxx::char_traits<char_type>::assign(__s, __n, __a);
569#endif
570 return wmemset(__s, __a, __n);
571 }
572
573 static _GLIBCXX_CONSTEXPR char_type
574 to_char_type(const int_type& __c) _GLIBCXX_NOEXCEPT
575 { return char_type(__c); }
576
577 static _GLIBCXX_CONSTEXPR int_type
578 to_int_type(const char_type& __c) _GLIBCXX_NOEXCEPT
579 { return int_type(__c); }
580
581 static _GLIBCXX_CONSTEXPR bool
582 eq_int_type(const int_type& __c1, const int_type& __c2) _GLIBCXX_NOEXCEPT
583 { return __c1 == __c2; }
584
585 static _GLIBCXX_CONSTEXPR int_type
586 eof() _GLIBCXX_NOEXCEPT
587 { return static_cast<int_type>(WEOF); }
588
589 static _GLIBCXX_CONSTEXPR int_type
590 not_eof(const int_type& __c) _GLIBCXX_NOEXCEPT
591 { return eq_int_type(__c, eof()) ? 0 : __c; }
592 };
593#else // _GLIBCXX_USE_WCHAR_T
594 template<>
595 struct char_traits<wchar_t> : public __gnu_cxx::char_traits<wchar_t>
596 { };
597#endif //_GLIBCXX_USE_WCHAR_T
598
599#ifdef _GLIBCXX_USE_CHAR8_T
600 template<>
601 struct char_traits<char8_t>
602 {
603 typedef char8_t char_type;
604 typedef unsigned int int_type;
605 typedef u8streampos pos_type;
606 typedef streamoff off_type;
607 typedef mbstate_t state_type;
608#if __cpp_lib_three_way_comparison
609 using comparison_category = strong_ordering;
610#endif
611
612 static _GLIBCXX17_CONSTEXPR void
613 assign(char_type& __c1, const char_type& __c2) _GLIBCXX_NOEXCEPT
614 {
615#if __cpp_constexpr_dynamic_alloc
616 if (std::__is_constant_evaluated())
617 std::construct_at(__builtin_addressof(__c1), __c2);
618 else
619#endif
620 __c1 = __c2;
621 }
622
623 static _GLIBCXX_CONSTEXPR bool
624 eq(const char_type& __c1, const char_type& __c2) _GLIBCXX_NOEXCEPT
625 { return __c1 == __c2; }
626
627 static _GLIBCXX_CONSTEXPR bool
628 lt(const char_type& __c1, const char_type& __c2) _GLIBCXX_NOEXCEPT
629 { return __c1 < __c2; }
630
631 static _GLIBCXX17_CONSTEXPR int
632 compare(const char_type* __s1, const char_type* __s2, size_t __n)
633 {
634 if (__n == 0)
635 return 0;
636#if __cplusplus >= 201703L
637 if (std::__is_constant_evaluated())
638 return __gnu_cxx::char_traits<char_type>::compare(__s1, __s2, __n);
639#endif
640 return __builtin_memcmp(__s1, __s2, __n);
641 }
642
643 static _GLIBCXX17_CONSTEXPR size_t
644 length(const char_type* __s)
645 {
646#if __cplusplus >= 201703L
647 if (std::__is_constant_evaluated())
648 return __gnu_cxx::char_traits<char_type>::length(__s);
649#endif
650 size_t __i = 0;
651 while (!eq(__s[__i], char_type()))
652 ++__i;
653 return __i;
654 }
655
656 static _GLIBCXX17_CONSTEXPR const char_type*
657 find(const char_type* __s, size_t __n, const char_type& __a)
658 {
659 if (__n == 0)
660 return 0;
661#if __cplusplus >= 201703L
662 if (std::__is_constant_evaluated())
663 return __gnu_cxx::char_traits<char_type>::find(__s, __n, __a);
664#endif
665 return static_cast<const char_type*>(__builtin_memchr(__s, __a, __n));
666 }
667
668 static _GLIBCXX20_CONSTEXPR char_type*
669 move(char_type* __s1, const char_type* __s2, size_t __n)
670 {
671 if (__n == 0)
672 return __s1;
673#if __cplusplus >= 202002L
674 if (std::__is_constant_evaluated())
675 return __gnu_cxx::char_traits<char_type>::move(__s1, __s2, __n);
676#endif
677 return static_cast<char_type*>(__builtin_memmove(__s1, __s2, __n));
678 }
679
680 static _GLIBCXX20_CONSTEXPR char_type*
681 copy(char_type* __s1, const char_type* __s2, size_t __n)
682 {
683 if (__n == 0)
684 return __s1;
685#if __cplusplus >= 202002L
686 if (std::__is_constant_evaluated())
687 return __gnu_cxx::char_traits<char_type>::copy(__s1, __s2, __n);
688#endif
689 return static_cast<char_type*>(__builtin_memcpy(__s1, __s2, __n));
690 }
691
692 static _GLIBCXX20_CONSTEXPR char_type*
693 assign(char_type* __s, size_t __n, char_type __a)
694 {
695 if (__n == 0)
696 return __s;
697#if __cplusplus >= 202002L
698 if (std::__is_constant_evaluated())
699 return __gnu_cxx::char_traits<char_type>::assign(__s, __n, __a);
700#endif
701 return static_cast<char_type*>(__builtin_memset(__s, __a, __n));
702 }
703
704 static _GLIBCXX_CONSTEXPR char_type
705 to_char_type(const int_type& __c) _GLIBCXX_NOEXCEPT
706 { return char_type(__c); }
707
708 static _GLIBCXX_CONSTEXPR int_type
709 to_int_type(const char_type& __c) _GLIBCXX_NOEXCEPT
710 { return int_type(__c); }
711
712 static _GLIBCXX_CONSTEXPR bool
713 eq_int_type(const int_type& __c1, const int_type& __c2) _GLIBCXX_NOEXCEPT
714 { return __c1 == __c2; }
715
716 static _GLIBCXX_CONSTEXPR int_type
717 eof() _GLIBCXX_NOEXCEPT
718 { return static_cast<int_type>(-1); }
719
720 static _GLIBCXX_CONSTEXPR int_type
721 not_eof(const int_type& __c) _GLIBCXX_NOEXCEPT
722 { return eq_int_type(__c, eof()) ? 0 : __c; }
723 };
724#endif //_GLIBCXX_USE_CHAR8_T
725
726_GLIBCXX_END_NAMESPACE_VERSION
727} // namespace
728
729#if __cplusplus >= 201103L
730
731#include <cstdint>
732
733namespace std _GLIBCXX_VISIBILITY(default)
734{
735_GLIBCXX_BEGIN_NAMESPACE_VERSION
736
737 template<>
738 struct char_traits<char16_t>
739 {
740 typedef char16_t char_type;
741#ifdef _GLIBCXX_USE_C99_STDINT_TR1
742 typedef uint_least16_t int_type;
743#elif defined __UINT_LEAST16_TYPE__
744 typedef __UINT_LEAST16_TYPE__ int_type;
745#else
746 typedef make_unsigned<char16_t>::type int_type;
747#endif
748 typedef streamoff off_type;
749 typedef u16streampos pos_type;
750 typedef mbstate_t state_type;
751#if __cpp_lib_three_way_comparison
752 using comparison_category = strong_ordering;
753#endif
754
755 static _GLIBCXX17_CONSTEXPR void
756 assign(char_type& __c1, const char_type& __c2) noexcept
757 {
758#if __cpp_constexpr_dynamic_alloc
759 if (std::__is_constant_evaluated())
760 std::construct_at(__builtin_addressof(__c1), __c2);
761 else
762#endif
763 __c1 = __c2;
764 }
765
766 static constexpr bool
767 eq(const char_type& __c1, const char_type& __c2) noexcept
768 { return __c1 == __c2; }
769
770 static constexpr bool
771 lt(const char_type& __c1, const char_type& __c2) noexcept
772 { return __c1 < __c2; }
773
774 static _GLIBCXX17_CONSTEXPR int
775 compare(const char_type* __s1, const char_type* __s2, size_t __n)
776 {
777 for (size_t __i = 0; __i < __n; ++__i)
778 if (lt(__s1[__i], __s2[__i]))
779 return -1;
780 else if (lt(__s2[__i], __s1[__i]))
781 return 1;
782 return 0;
783 }
784
785 static _GLIBCXX17_CONSTEXPR size_t
786 length(const char_type* __s)
787 {
788 size_t __i = 0;
789 while (!eq(__s[__i], char_type()))
790 ++__i;
791 return __i;
792 }
793
794 static _GLIBCXX17_CONSTEXPR const char_type*
795 find(const char_type* __s, size_t __n, const char_type& __a)
796 {
797 for (size_t __i = 0; __i < __n; ++__i)
798 if (eq(__s[__i], __a))
799 return __s + __i;
800 return 0;
801 }
802
803 static _GLIBCXX20_CONSTEXPR char_type*
804 move(char_type* __s1, const char_type* __s2, size_t __n)
805 {
806 if (__n == 0)
807 return __s1;
808#if __cplusplus >= 202002L
809 if (std::__is_constant_evaluated())
810 return __gnu_cxx::char_traits<char_type>::move(__s1, __s2, __n);
811#endif
812 return (static_cast<char_type*>
813 (__builtin_memmove(__s1, __s2, __n * sizeof(char_type))));
814 }
815
816 static _GLIBCXX20_CONSTEXPR char_type*
817 copy(char_type* __s1, const char_type* __s2, size_t __n)
818 {
819 if (__n == 0)
820 return __s1;
821#if __cplusplus >= 202002L
822 if (std::__is_constant_evaluated())
823 return __gnu_cxx::char_traits<char_type>::copy(__s1, __s2, __n);
824#endif
825 return (static_cast<char_type*>
826 (__builtin_memcpy(__s1, __s2, __n * sizeof(char_type))));
827 }
828
829 static _GLIBCXX20_CONSTEXPR char_type*
830 assign(char_type* __s, size_t __n, char_type __a)
831 {
832 for (size_t __i = 0; __i < __n; ++__i)
833 assign(__s[__i], __a);
834 return __s;
835 }
836
837 static constexpr char_type
838 to_char_type(const int_type& __c) noexcept
839 { return char_type(__c); }
840
841 static constexpr int_type
842 to_int_type(const char_type& __c) noexcept
843 { return __c == eof() ? int_type(0xfffd) : int_type(__c); }
844
845 static constexpr bool
846 eq_int_type(const int_type& __c1, const int_type& __c2) noexcept
847 { return __c1 == __c2; }
848
849 static constexpr int_type
850 eof() noexcept
851 { return static_cast<int_type>(-1); }
852
853 static constexpr int_type
854 not_eof(const int_type& __c) noexcept
855 { return eq_int_type(__c, eof()) ? 0 : __c; }
856 };
857
858 template<>
859 struct char_traits<char32_t>
860 {
861 typedef char32_t char_type;
862#ifdef _GLIBCXX_USE_C99_STDINT_TR1
863 typedef uint_least32_t int_type;
864#elif defined __UINT_LEAST32_TYPE__
865 typedef __UINT_LEAST32_TYPE__ int_type;
866#else
867 typedef make_unsigned<char32_t>::type int_type;
868#endif
869 typedef streamoff off_type;
870 typedef u32streampos pos_type;
871 typedef mbstate_t state_type;
872#if __cpp_lib_three_way_comparison
873 using comparison_category = strong_ordering;
874#endif
875
876 static _GLIBCXX17_CONSTEXPR void
877 assign(char_type& __c1, const char_type& __c2) noexcept
878 {
879#if __cpp_constexpr_dynamic_alloc
880 if (std::__is_constant_evaluated())
881 std::construct_at(__builtin_addressof(__c1), __c2);
882 else
883#endif
884 __c1 = __c2;
885 }
886
887 static constexpr bool
888 eq(const char_type& __c1, const char_type& __c2) noexcept
889 { return __c1 == __c2; }
890
891 static constexpr bool
892 lt(const char_type& __c1, const char_type& __c2) noexcept
893 { return __c1 < __c2; }
894
895 static _GLIBCXX17_CONSTEXPR int
896 compare(const char_type* __s1, const char_type* __s2, size_t __n)
897 {
898 for (size_t __i = 0; __i < __n; ++__i)
899 if (lt(__s1[__i], __s2[__i]))
900 return -1;
901 else if (lt(__s2[__i], __s1[__i]))
902 return 1;
903 return 0;
904 }
905
906 static _GLIBCXX17_CONSTEXPR size_t
907 length(const char_type* __s)
908 {
909 size_t __i = 0;
910 while (!eq(__s[__i], char_type()))
911 ++__i;
912 return __i;
913 }
914
915 static _GLIBCXX17_CONSTEXPR const char_type*
916 find(const char_type* __s, size_t __n, const char_type& __a)
917 {
918 for (size_t __i = 0; __i < __n; ++__i)
919 if (eq(__s[__i], __a))
920 return __s + __i;
921 return 0;
922 }
923
924 static _GLIBCXX20_CONSTEXPR char_type*
925 move(char_type* __s1, const char_type* __s2, size_t __n)
926 {
927 if (__n == 0)
928 return __s1;
929#if __cplusplus >= 202002L
930 if (std::__is_constant_evaluated())
931 return __gnu_cxx::char_traits<char_type>::move(__s1, __s2, __n);
932#endif
933 return (static_cast<char_type*>
934 (__builtin_memmove(__s1, __s2, __n * sizeof(char_type))));
935 }
936
937 static _GLIBCXX20_CONSTEXPR char_type*
938 copy(char_type* __s1, const char_type* __s2, size_t __n)
939 {
940 if (__n == 0)
941 return __s1;
942#if __cplusplus >= 202002L
943 if (std::__is_constant_evaluated())
944 return __gnu_cxx::char_traits<char_type>::copy(__s1, __s2, __n);
945#endif
946 return (static_cast<char_type*>
947 (__builtin_memcpy(__s1, __s2, __n * sizeof(char_type))));
948 }
949
950 static _GLIBCXX20_CONSTEXPR char_type*
951 assign(char_type* __s, size_t __n, char_type __a)
952 {
953 for (size_t __i = 0; __i < __n; ++__i)
954 assign(__s[__i], __a);
955 return __s;
956 }
957
958 static constexpr char_type
959 to_char_type(const int_type& __c) noexcept
960 { return char_type(__c); }
961
962 static constexpr int_type
963 to_int_type(const char_type& __c) noexcept
964 { return int_type(__c); }
965
966 static constexpr bool
967 eq_int_type(const int_type& __c1, const int_type& __c2) noexcept
968 { return __c1 == __c2; }
969
970 static constexpr int_type
971 eof() noexcept
972 { return static_cast<int_type>(-1); }
973
974 static constexpr int_type
975 not_eof(const int_type& __c) noexcept
976 { return eq_int_type(__c, eof()) ? 0 : __c; }
977 };
978
979#if __cpp_lib_three_way_comparison
980 namespace __detail
981 {
982 template<typename _ChTraits>
983 constexpr auto
984 __char_traits_cmp_cat(int __cmp) noexcept
985 {
986 if constexpr (requires { typename _ChTraits::comparison_category; })
987 {
988 using _Cat = typename _ChTraits::comparison_category;
989 static_assert( !is_void_v<common_comparison_category_t<_Cat>> );
990 return static_cast<_Cat>(__cmp <=> 0);
991 }
992 else
993 return static_cast<weak_ordering>(__cmp <=> 0);
994 }
995 } // namespace __detail
996#endif // C++20
997
998#pragma GCC diagnostic pop
999
1000_GLIBCXX_END_NAMESPACE_VERSION
1001} // namespace
1002
1003#endif // C++11
1004
1005#endif // _CHAR_TRAITS_H
1006