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