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