Line data Source code
1 : // Character Traits for use by standard string and iostream -*- C++ -*-
2 :
3 : // Copyright (C) 1997-2018 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 :
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 0 : eq(const char_type& __c1, const char_type& __c2)
101 0 : { return __c1 == __c2; }
102 :
103 : static _GLIBCXX_CONSTEXPR bool
104 0 : lt(const char_type& __c1, const char_type& __c2)
105 0 : { 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 0 : char_traits<_CharT>::
149 : compare(const char_type* __s1, const char_type* __s2, std::size_t __n)
150 : {
151 0 : for (std::size_t __i = 0; __i < __n; ++__i)
152 0 : if (lt(__s1[__i], __s2[__i]))
153 0 : return -1;
154 0 : else if (lt(__s2[__i], __s1[__i]))
155 0 : return 1;
156 0 : return 0;
157 : }
158 :
159 : template<typename _CharT>
160 : _GLIBCXX14_CONSTEXPR std::size_t
161 0 : char_traits<_CharT>::
162 : length(const char_type* __p)
163 : {
164 0 : std::size_t __i = 0;
165 0 : while (!eq(__p[__i], char_type()))
166 0 : ++__i;
167 0 : return __i;
168 : }
169 :
170 : template<typename _CharT>
171 : _GLIBCXX14_CONSTEXPR const typename char_traits<_CharT>::char_type*
172 0 : char_traits<_CharT>::
173 : find(const char_type* __s, std::size_t __n, const char_type& __a)
174 : {
175 0 : for (std::size_t __i = 0; __i < __n; ++__i)
176 0 : if (eq(__s[__i], __a))
177 0 : return __s + __i;
178 0 : 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 :
215 : namespace std _GLIBCXX_VISIBILITY(default)
216 : {
217 : _GLIBCXX_BEGIN_NAMESPACE_VERSION
218 :
219 : #if __cplusplus > 201402
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 : while (__builtin_constant_p(*__s) && *__s)
234 : __s++;
235 1014971 : return __builtin_constant_p(*__s);
236 : }
237 :
238 : /**
239 : * @brief Determine whether the characters of a character array are
240 : * known at compile time.
241 : * @param __a The character array.
242 : * @param __n Number of characters.
243 : *
244 : * Assumes that _CharT is a built-in character type.
245 : */
246 : template<typename _CharT>
247 : static _GLIBCXX_ALWAYS_INLINE constexpr bool
248 : __constant_char_array_p(const _CharT* __a, size_t __n)
249 : {
250 : size_t __i = 0;
251 : while (__i < __n && __builtin_constant_p(__a[__i]))
252 : __i++;
253 : return __i == __n;
254 : }
255 : #endif
256 :
257 : // 21.1
258 : /**
259 : * @brief Basis for explicit traits specializations.
260 : *
261 : * @note For any given actual character type, this definition is
262 : * probably wrong. Since this is just a thin wrapper around
263 : * __gnu_cxx::char_traits, it is possible to achieve a more
264 : * appropriate definition by specializing __gnu_cxx::char_traits.
265 : *
266 : * See https://gcc.gnu.org/onlinedocs/libstdc++/manual/strings.html#strings.string.character_types
267 : * for advice on how to make use of this class for @a unusual character
268 : * types. Also, check out include/ext/pod_char_traits.h.
269 : */
270 : template<class _CharT>
271 : struct char_traits : public __gnu_cxx::char_traits<_CharT>
272 : { };
273 :
274 :
275 : /// 21.1.3.1 char_traits specializations
276 : template<>
277 : struct char_traits<char>
278 : {
279 : typedef char char_type;
280 : typedef int int_type;
281 : typedef streampos pos_type;
282 : typedef streamoff off_type;
283 : typedef mbstate_t state_type;
284 :
285 : static _GLIBCXX17_CONSTEXPR void
286 1031842 : assign(char_type& __c1, const char_type& __c2) _GLIBCXX_NOEXCEPT
287 1031842 : { __c1 = __c2; }
288 :
289 : static _GLIBCXX_CONSTEXPR bool
290 : eq(const char_type& __c1, const char_type& __c2) _GLIBCXX_NOEXCEPT
291 : { return __c1 == __c2; }
292 :
293 : static _GLIBCXX_CONSTEXPR bool
294 : lt(const char_type& __c1, const char_type& __c2) _GLIBCXX_NOEXCEPT
295 : {
296 : // LWG 467.
297 : return (static_cast<unsigned char>(__c1)
298 : < static_cast<unsigned char>(__c2));
299 : }
300 :
301 : static _GLIBCXX17_CONSTEXPR int
302 1983 : compare(const char_type* __s1, const char_type* __s2, size_t __n)
303 : {
304 : #if __cplusplus > 201402
305 1983 : if (__builtin_constant_p(__n)
306 : && __constant_char_array_p(__s1, __n)
307 1983 : && __constant_char_array_p(__s2, __n))
308 0 : return __gnu_cxx::char_traits<char_type>::compare(__s1, __s2, __n);
309 : #endif
310 1983 : if (__n == 0)
311 0 : return 0;
312 1983 : return __builtin_memcmp(__s1, __s2, __n);
313 : }
314 :
315 : static _GLIBCXX17_CONSTEXPR size_t
316 1014971 : length(const char_type* __s)
317 : {
318 : #if __cplusplus > 201402
319 1014971 : if (__constant_string_p(__s))
320 0 : return __gnu_cxx::char_traits<char_type>::length(__s);
321 : #endif
322 1014971 : return __builtin_strlen(__s);
323 : }
324 :
325 : static _GLIBCXX17_CONSTEXPR const char_type*
326 3361 : find(const char_type* __s, size_t __n, const char_type& __a)
327 : {
328 : #if __cplusplus > 201402
329 3361 : if (__builtin_constant_p(__n)
330 : && __builtin_constant_p(__a)
331 3361 : && __constant_char_array_p(__s, __n))
332 0 : return __gnu_cxx::char_traits<char_type>::find(__s, __n, __a);
333 : #endif
334 3361 : if (__n == 0)
335 0 : return 0;
336 3361 : return static_cast<const char_type*>(__builtin_memchr(__s, __a, __n));
337 : }
338 :
339 : static char_type*
340 151 : move(char_type* __s1, const char_type* __s2, size_t __n)
341 : {
342 151 : if (__n == 0)
343 0 : return __s1;
344 151 : return static_cast<char_type*>(__builtin_memmove(__s1, __s2, __n));
345 : }
346 :
347 : static char_type*
348 1020264 : copy(char_type* __s1, const char_type* __s2, size_t __n)
349 : {
350 1020264 : if (__n == 0)
351 0 : return __s1;
352 1020264 : return static_cast<char_type*>(__builtin_memcpy(__s1, __s2, __n));
353 : }
354 :
355 : static char_type*
356 : assign(char_type* __s, size_t __n, char_type __a)
357 : {
358 : if (__n == 0)
359 : return __s;
360 : return static_cast<char_type*>(__builtin_memset(__s, __a, __n));
361 : }
362 :
363 : static _GLIBCXX_CONSTEXPR char_type
364 : to_char_type(const int_type& __c) _GLIBCXX_NOEXCEPT
365 : { return static_cast<char_type>(__c); }
366 :
367 : // To keep both the byte 0xff and the eof symbol 0xffffffff
368 : // from ending up as 0xffffffff.
369 : static _GLIBCXX_CONSTEXPR int_type
370 : to_int_type(const char_type& __c) _GLIBCXX_NOEXCEPT
371 : { return static_cast<int_type>(static_cast<unsigned char>(__c)); }
372 :
373 : static _GLIBCXX_CONSTEXPR bool
374 : eq_int_type(const int_type& __c1, const int_type& __c2) _GLIBCXX_NOEXCEPT
375 : { return __c1 == __c2; }
376 :
377 : static _GLIBCXX_CONSTEXPR int_type
378 : eof() _GLIBCXX_NOEXCEPT
379 : { return static_cast<int_type>(_GLIBCXX_STDIO_EOF); }
380 :
381 : static _GLIBCXX_CONSTEXPR int_type
382 : not_eof(const int_type& __c) _GLIBCXX_NOEXCEPT
383 : { return (__c == eof()) ? 0 : __c; }
384 : };
385 :
386 :
387 : #ifdef _GLIBCXX_USE_WCHAR_T
388 : /// 21.1.3.2 char_traits specializations
389 : template<>
390 : struct char_traits<wchar_t>
391 : {
392 : typedef wchar_t char_type;
393 : typedef wint_t int_type;
394 : typedef streamoff off_type;
395 : typedef wstreampos pos_type;
396 : typedef mbstate_t state_type;
397 :
398 : static _GLIBCXX17_CONSTEXPR void
399 : assign(char_type& __c1, const char_type& __c2) _GLIBCXX_NOEXCEPT
400 : { __c1 = __c2; }
401 :
402 : static _GLIBCXX_CONSTEXPR bool
403 : eq(const char_type& __c1, const char_type& __c2) _GLIBCXX_NOEXCEPT
404 : { return __c1 == __c2; }
405 :
406 : static _GLIBCXX_CONSTEXPR bool
407 : lt(const char_type& __c1, const char_type& __c2) _GLIBCXX_NOEXCEPT
408 : { return __c1 < __c2; }
409 :
410 : static _GLIBCXX17_CONSTEXPR int
411 : compare(const char_type* __s1, const char_type* __s2, size_t __n)
412 : {
413 : #if __cplusplus > 201402
414 : if (__builtin_constant_p(__n)
415 : && __constant_char_array_p(__s1, __n)
416 : && __constant_char_array_p(__s2, __n))
417 : return __gnu_cxx::char_traits<char_type>::compare(__s1, __s2, __n);
418 : #endif
419 : if (__n == 0)
420 : return 0;
421 : else
422 : return wmemcmp(__s1, __s2, __n);
423 : }
424 :
425 : static _GLIBCXX17_CONSTEXPR size_t
426 : length(const char_type* __s)
427 : {
428 : #if __cplusplus > 201402
429 : if (__constant_string_p(__s))
430 : return __gnu_cxx::char_traits<char_type>::length(__s);
431 : else
432 : #endif
433 : return wcslen(__s);
434 : }
435 :
436 : static _GLIBCXX17_CONSTEXPR const char_type*
437 : find(const char_type* __s, size_t __n, const char_type& __a)
438 : {
439 : #if __cplusplus > 201402
440 : if (__builtin_constant_p(__n)
441 : && __builtin_constant_p(__a)
442 : && __constant_char_array_p(__s, __n))
443 : return __gnu_cxx::char_traits<char_type>::find(__s, __n, __a);
444 : #endif
445 : if (__n == 0)
446 : return 0;
447 : else
448 : return wmemchr(__s, __a, __n);
449 : }
450 :
451 : static char_type*
452 : move(char_type* __s1, const char_type* __s2, size_t __n)
453 : {
454 : if (__n == 0)
455 : return __s1;
456 : return wmemmove(__s1, __s2, __n);
457 : }
458 :
459 : static char_type*
460 : copy(char_type* __s1, const char_type* __s2, size_t __n)
461 : {
462 : if (__n == 0)
463 : return __s1;
464 : return wmemcpy(__s1, __s2, __n);
465 : }
466 :
467 : static char_type*
468 : assign(char_type* __s, size_t __n, char_type __a)
469 : {
470 : if (__n == 0)
471 : return __s;
472 : return wmemset(__s, __a, __n);
473 : }
474 :
475 : static _GLIBCXX_CONSTEXPR char_type
476 : to_char_type(const int_type& __c) _GLIBCXX_NOEXCEPT
477 : { return char_type(__c); }
478 :
479 : static _GLIBCXX_CONSTEXPR int_type
480 : to_int_type(const char_type& __c) _GLIBCXX_NOEXCEPT
481 : { return int_type(__c); }
482 :
483 : static _GLIBCXX_CONSTEXPR bool
484 : eq_int_type(const int_type& __c1, const int_type& __c2) _GLIBCXX_NOEXCEPT
485 : { return __c1 == __c2; }
486 :
487 : static _GLIBCXX_CONSTEXPR int_type
488 : eof() _GLIBCXX_NOEXCEPT
489 : { return static_cast<int_type>(WEOF); }
490 :
491 : static _GLIBCXX_CONSTEXPR int_type
492 : not_eof(const int_type& __c) _GLIBCXX_NOEXCEPT
493 : { return eq_int_type(__c, eof()) ? 0 : __c; }
494 : };
495 : #endif //_GLIBCXX_USE_WCHAR_T
496 :
497 : _GLIBCXX_END_NAMESPACE_VERSION
498 : } // namespace
499 :
500 : #if ((__cplusplus >= 201103L) \
501 : && defined(_GLIBCXX_USE_C99_STDINT_TR1))
502 :
503 : #include <cstdint>
504 :
505 : namespace std _GLIBCXX_VISIBILITY(default)
506 : {
507 : _GLIBCXX_BEGIN_NAMESPACE_VERSION
508 :
509 : template<>
510 : struct char_traits<char16_t>
511 : {
512 : typedef char16_t char_type;
513 : typedef uint_least16_t int_type;
514 : typedef streamoff off_type;
515 : typedef u16streampos pos_type;
516 : typedef mbstate_t state_type;
517 :
518 : static _GLIBCXX17_CONSTEXPR void
519 : assign(char_type& __c1, const char_type& __c2) noexcept
520 : { __c1 = __c2; }
521 :
522 : static constexpr bool
523 : eq(const char_type& __c1, const char_type& __c2) noexcept
524 : { return __c1 == __c2; }
525 :
526 : static constexpr bool
527 : lt(const char_type& __c1, const char_type& __c2) noexcept
528 : { return __c1 < __c2; }
529 :
530 : static _GLIBCXX17_CONSTEXPR int
531 : compare(const char_type* __s1, const char_type* __s2, size_t __n)
532 : {
533 : for (size_t __i = 0; __i < __n; ++__i)
534 : if (lt(__s1[__i], __s2[__i]))
535 : return -1;
536 : else if (lt(__s2[__i], __s1[__i]))
537 : return 1;
538 : return 0;
539 : }
540 :
541 : static _GLIBCXX17_CONSTEXPR size_t
542 : length(const char_type* __s)
543 : {
544 : size_t __i = 0;
545 : while (!eq(__s[__i], char_type()))
546 : ++__i;
547 : return __i;
548 : }
549 :
550 : static _GLIBCXX17_CONSTEXPR const char_type*
551 : find(const char_type* __s, size_t __n, const char_type& __a)
552 : {
553 : for (size_t __i = 0; __i < __n; ++__i)
554 : if (eq(__s[__i], __a))
555 : return __s + __i;
556 : return 0;
557 : }
558 :
559 : static char_type*
560 : move(char_type* __s1, const char_type* __s2, size_t __n)
561 : {
562 : if (__n == 0)
563 : return __s1;
564 : return (static_cast<char_type*>
565 : (__builtin_memmove(__s1, __s2, __n * sizeof(char_type))));
566 : }
567 :
568 : static char_type*
569 : copy(char_type* __s1, const char_type* __s2, size_t __n)
570 : {
571 : if (__n == 0)
572 : return __s1;
573 : return (static_cast<char_type*>
574 : (__builtin_memcpy(__s1, __s2, __n * sizeof(char_type))));
575 : }
576 :
577 : static char_type*
578 : assign(char_type* __s, size_t __n, char_type __a)
579 : {
580 : for (size_t __i = 0; __i < __n; ++__i)
581 : assign(__s[__i], __a);
582 : return __s;
583 : }
584 :
585 : static constexpr char_type
586 : to_char_type(const int_type& __c) noexcept
587 : { return char_type(__c); }
588 :
589 : static constexpr int_type
590 : to_int_type(const char_type& __c) noexcept
591 : { return __c == eof() ? int_type(0xfffd) : int_type(__c); }
592 :
593 : static constexpr bool
594 : eq_int_type(const int_type& __c1, const int_type& __c2) noexcept
595 : { return __c1 == __c2; }
596 :
597 : static constexpr int_type
598 : eof() noexcept
599 : { return static_cast<int_type>(-1); }
600 :
601 : static constexpr int_type
602 : not_eof(const int_type& __c) noexcept
603 : { return eq_int_type(__c, eof()) ? 0 : __c; }
604 : };
605 :
606 : template<>
607 : struct char_traits<char32_t>
608 : {
609 : typedef char32_t char_type;
610 : typedef uint_least32_t int_type;
611 : typedef streamoff off_type;
612 : typedef u32streampos pos_type;
613 : typedef mbstate_t state_type;
614 :
615 : static _GLIBCXX17_CONSTEXPR void
616 : assign(char_type& __c1, const char_type& __c2) noexcept
617 : { __c1 = __c2; }
618 :
619 : static constexpr bool
620 : eq(const char_type& __c1, const char_type& __c2) noexcept
621 : { return __c1 == __c2; }
622 :
623 : static constexpr bool
624 : lt(const char_type& __c1, const char_type& __c2) noexcept
625 : { return __c1 < __c2; }
626 :
627 : static _GLIBCXX17_CONSTEXPR int
628 : compare(const char_type* __s1, const char_type* __s2, size_t __n)
629 : {
630 : for (size_t __i = 0; __i < __n; ++__i)
631 : if (lt(__s1[__i], __s2[__i]))
632 : return -1;
633 : else if (lt(__s2[__i], __s1[__i]))
634 : return 1;
635 : return 0;
636 : }
637 :
638 : static _GLIBCXX17_CONSTEXPR size_t
639 : length(const char_type* __s)
640 : {
641 : size_t __i = 0;
642 : while (!eq(__s[__i], char_type()))
643 : ++__i;
644 : return __i;
645 : }
646 :
647 : static _GLIBCXX17_CONSTEXPR const char_type*
648 : find(const char_type* __s, size_t __n, const char_type& __a)
649 : {
650 : for (size_t __i = 0; __i < __n; ++__i)
651 : if (eq(__s[__i], __a))
652 : return __s + __i;
653 : return 0;
654 : }
655 :
656 : static char_type*
657 : move(char_type* __s1, const char_type* __s2, size_t __n)
658 : {
659 : if (__n == 0)
660 : return __s1;
661 : return (static_cast<char_type*>
662 : (__builtin_memmove(__s1, __s2, __n * sizeof(char_type))));
663 : }
664 :
665 : static char_type*
666 : copy(char_type* __s1, const char_type* __s2, size_t __n)
667 : {
668 : if (__n == 0)
669 : return __s1;
670 : return (static_cast<char_type*>
671 : (__builtin_memcpy(__s1, __s2, __n * sizeof(char_type))));
672 : }
673 :
674 : static char_type*
675 : assign(char_type* __s, size_t __n, char_type __a)
676 : {
677 : for (size_t __i = 0; __i < __n; ++__i)
678 : assign(__s[__i], __a);
679 : return __s;
680 : }
681 :
682 : static constexpr char_type
683 : to_char_type(const int_type& __c) noexcept
684 : { return char_type(__c); }
685 :
686 : static constexpr int_type
687 : to_int_type(const char_type& __c) noexcept
688 : { return int_type(__c); }
689 :
690 : static constexpr bool
691 : eq_int_type(const int_type& __c1, const int_type& __c2) noexcept
692 : { return __c1 == __c2; }
693 :
694 : static constexpr int_type
695 : eof() noexcept
696 : { return static_cast<int_type>(-1); }
697 :
698 : static constexpr int_type
699 : not_eof(const int_type& __c) noexcept
700 : { return eq_int_type(__c, eof()) ? 0 : __c; }
701 : };
702 :
703 : _GLIBCXX_END_NAMESPACE_VERSION
704 : } // namespace
705 :
706 : #endif
707 :
708 : #endif // _CHAR_TRAITS_H
|
