Line data Source code
1 : // Character Traits for use by standard string and iostream -*- C++ -*-
2 :
3 : // Copyright (C) 1997-2014 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 : namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
44 : {
45 : _GLIBCXX_BEGIN_NAMESPACE_VERSION
46 :
47 : /**
48 : * @brief Mapping from character type to associated types.
49 : *
50 : * @note This is an implementation class for the generic version
51 : * of char_traits. It defines int_type, off_type, pos_type, and
52 : * state_type. By default these are unsigned long, streamoff,
53 : * streampos, and mbstate_t. Users who need a different set of
54 : * types, but who don't need to change the definitions of any function
55 : * defined in char_traits, can specialize __gnu_cxx::_Char_types
56 : * while leaving __gnu_cxx::char_traits alone. */
57 : template<typename _CharT>
58 : struct _Char_types
59 : {
60 : typedef unsigned long int_type;
61 : typedef std::streampos pos_type;
62 : typedef std::streamoff off_type;
63 : typedef std::mbstate_t state_type;
64 : };
65 :
66 :
67 : /**
68 : * @brief Base class used to implement std::char_traits.
69 : *
70 : * @note For any given actual character type, this definition is
71 : * probably wrong. (Most of the member functions are likely to be
72 : * right, but the int_type and state_type typedefs, and the eof()
73 : * member function, are likely to be wrong.) The reason this class
74 : * exists is so users can specialize it. Classes in namespace std
75 : * may not be specialized for fundamental types, but classes in
76 : * namespace __gnu_cxx may be.
77 : *
78 : * See http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt05ch13s03.html
79 : * for advice on how to make use of this class for @a unusual character
80 : * types. Also, check out include/ext/pod_char_traits.h.
81 : */
82 : template<typename _CharT>
83 : struct char_traits
84 : {
85 : typedef _CharT char_type;
86 : typedef typename _Char_types<_CharT>::int_type int_type;
87 : typedef typename _Char_types<_CharT>::pos_type pos_type;
88 : typedef typename _Char_types<_CharT>::off_type off_type;
89 : typedef typename _Char_types<_CharT>::state_type state_type;
90 :
91 : static void
92 : assign(char_type& __c1, const char_type& __c2)
93 : { __c1 = __c2; }
94 :
95 : static _GLIBCXX_CONSTEXPR bool
96 : eq(const char_type& __c1, const char_type& __c2)
97 : { return __c1 == __c2; }
98 :
99 : static _GLIBCXX_CONSTEXPR bool
100 : lt(const char_type& __c1, const char_type& __c2)
101 : { return __c1 < __c2; }
102 :
103 : static int
104 : compare(const char_type* __s1, const char_type* __s2, std::size_t __n);
105 :
106 : static std::size_t
107 : length(const char_type* __s);
108 :
109 : static const char_type*
110 : find(const char_type* __s, std::size_t __n, const char_type& __a);
111 :
112 : static char_type*
113 : move(char_type* __s1, const char_type* __s2, std::size_t __n);
114 :
115 : static char_type*
116 : copy(char_type* __s1, const char_type* __s2, std::size_t __n);
117 :
118 : static char_type*
119 : assign(char_type* __s, std::size_t __n, char_type __a);
120 :
121 : static _GLIBCXX_CONSTEXPR char_type
122 : to_char_type(const int_type& __c)
123 : { return static_cast<char_type>(__c); }
124 :
125 : static _GLIBCXX_CONSTEXPR int_type
126 : to_int_type(const char_type& __c)
127 : { return static_cast<int_type>(__c); }
128 :
129 : static _GLIBCXX_CONSTEXPR bool
130 : eq_int_type(const int_type& __c1, const int_type& __c2)
131 : { return __c1 == __c2; }
132 :
133 : static _GLIBCXX_CONSTEXPR int_type
134 : eof()
135 : { return static_cast<int_type>(_GLIBCXX_STDIO_EOF); }
136 :
137 : static _GLIBCXX_CONSTEXPR int_type
138 : not_eof(const int_type& __c)
139 : { return !eq_int_type(__c, eof()) ? __c : to_int_type(char_type()); }
140 : };
141 :
142 : template<typename _CharT>
143 : int
144 : char_traits<_CharT>::
145 : compare(const char_type* __s1, const char_type* __s2, std::size_t __n)
146 : {
147 : for (std::size_t __i = 0; __i < __n; ++__i)
148 : if (lt(__s1[__i], __s2[__i]))
149 : return -1;
150 : else if (lt(__s2[__i], __s1[__i]))
151 : return 1;
152 : return 0;
153 : }
154 :
155 : template<typename _CharT>
156 : std::size_t
157 : char_traits<_CharT>::
158 : length(const char_type* __p)
159 : {
160 : std::size_t __i = 0;
161 : while (!eq(__p[__i], char_type()))
162 : ++__i;
163 : return __i;
164 : }
165 :
166 : template<typename _CharT>
167 : const typename char_traits<_CharT>::char_type*
168 : char_traits<_CharT>::
169 : find(const char_type* __s, std::size_t __n, const char_type& __a)
170 : {
171 : for (std::size_t __i = 0; __i < __n; ++__i)
172 : if (eq(__s[__i], __a))
173 : return __s + __i;
174 : return 0;
175 : }
176 :
177 : template<typename _CharT>
178 : typename char_traits<_CharT>::char_type*
179 : char_traits<_CharT>::
180 : move(char_type* __s1, const char_type* __s2, std::size_t __n)
181 : {
182 : return static_cast<_CharT*>(__builtin_memmove(__s1, __s2,
183 : __n * sizeof(char_type)));
184 : }
185 :
186 : template<typename _CharT>
187 : typename char_traits<_CharT>::char_type*
188 : char_traits<_CharT>::
189 : copy(char_type* __s1, const char_type* __s2, std::size_t __n)
190 : {
191 : // NB: Inline std::copy so no recursive dependencies.
192 : std::copy(__s2, __s2 + __n, __s1);
193 : return __s1;
194 : }
195 :
196 : template<typename _CharT>
197 : typename char_traits<_CharT>::char_type*
198 : char_traits<_CharT>::
199 : assign(char_type* __s, std::size_t __n, char_type __a)
200 : {
201 : // NB: Inline std::fill_n so no recursive dependencies.
202 : std::fill_n(__s, __n, __a);
203 : return __s;
204 : }
205 :
206 : _GLIBCXX_END_NAMESPACE_VERSION
207 : } // namespace
208 :
209 : namespace std _GLIBCXX_VISIBILITY(default)
210 : {
211 : _GLIBCXX_BEGIN_NAMESPACE_VERSION
212 :
213 : // 21.1
214 : /**
215 : * @brief Basis for explicit traits specializations.
216 : *
217 : * @note For any given actual character type, this definition is
218 : * probably wrong. Since this is just a thin wrapper around
219 : * __gnu_cxx::char_traits, it is possible to achieve a more
220 : * appropriate definition by specializing __gnu_cxx::char_traits.
221 : *
222 : * See http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt05ch13s03.html
223 : * for advice on how to make use of this class for @a unusual character
224 : * types. Also, check out include/ext/pod_char_traits.h.
225 : */
226 : template<class _CharT>
227 : struct char_traits : public __gnu_cxx::char_traits<_CharT>
228 : { };
229 :
230 :
231 : /// 21.1.3.1 char_traits specializations
232 : template<>
233 : struct char_traits<char>
234 : {
235 : typedef char char_type;
236 : typedef int int_type;
237 : typedef streampos pos_type;
238 : typedef streamoff off_type;
239 : typedef mbstate_t state_type;
240 :
241 : static void
242 0 : assign(char_type& __c1, const char_type& __c2) _GLIBCXX_NOEXCEPT
243 0 : { __c1 = __c2; }
244 :
245 : static _GLIBCXX_CONSTEXPR bool
246 : eq(const char_type& __c1, const char_type& __c2) _GLIBCXX_NOEXCEPT
247 : { return __c1 == __c2; }
248 :
249 : static _GLIBCXX_CONSTEXPR bool
250 : lt(const char_type& __c1, const char_type& __c2) _GLIBCXX_NOEXCEPT
251 : {
252 : // LWG 467.
253 : return (static_cast<unsigned char>(__c1)
254 : < static_cast<unsigned char>(__c2));
255 : }
256 :
257 : static int
258 0 : compare(const char_type* __s1, const char_type* __s2, size_t __n)
259 0 : { return __builtin_memcmp(__s1, __s2, __n); }
260 :
261 : static size_t
262 0 : length(const char_type* __s)
263 0 : { return __builtin_strlen(__s); }
264 :
265 : static const char_type*
266 : find(const char_type* __s, size_t __n, const char_type& __a)
267 : { return static_cast<const char_type*>(__builtin_memchr(__s, __a, __n)); }
268 :
269 : static char_type*
270 : move(char_type* __s1, const char_type* __s2, size_t __n)
271 : { return static_cast<char_type*>(__builtin_memmove(__s1, __s2, __n)); }
272 :
273 : static char_type*
274 0 : copy(char_type* __s1, const char_type* __s2, size_t __n)
275 0 : { return static_cast<char_type*>(__builtin_memcpy(__s1, __s2, __n)); }
276 :
277 : static char_type*
278 : assign(char_type* __s, size_t __n, char_type __a)
279 : { return static_cast<char_type*>(__builtin_memset(__s, __a, __n)); }
280 :
281 : static _GLIBCXX_CONSTEXPR char_type
282 : to_char_type(const int_type& __c) _GLIBCXX_NOEXCEPT
283 : { return static_cast<char_type>(__c); }
284 :
285 : // To keep both the byte 0xff and the eof symbol 0xffffffff
286 : // from ending up as 0xffffffff.
287 : static _GLIBCXX_CONSTEXPR int_type
288 : to_int_type(const char_type& __c) _GLIBCXX_NOEXCEPT
289 : { return static_cast<int_type>(static_cast<unsigned char>(__c)); }
290 :
291 : static _GLIBCXX_CONSTEXPR bool
292 : eq_int_type(const int_type& __c1, const int_type& __c2) _GLIBCXX_NOEXCEPT
293 : { return __c1 == __c2; }
294 :
295 : static _GLIBCXX_CONSTEXPR int_type
296 : eof() _GLIBCXX_NOEXCEPT
297 : { return static_cast<int_type>(_GLIBCXX_STDIO_EOF); }
298 :
299 : static _GLIBCXX_CONSTEXPR int_type
300 : not_eof(const int_type& __c) _GLIBCXX_NOEXCEPT
301 : { return (__c == eof()) ? 0 : __c; }
302 : };
303 :
304 :
305 : #ifdef _GLIBCXX_USE_WCHAR_T
306 : /// 21.1.3.2 char_traits specializations
307 : template<>
308 : struct char_traits<wchar_t>
309 : {
310 : typedef wchar_t char_type;
311 : typedef wint_t int_type;
312 : typedef streamoff off_type;
313 : typedef wstreampos pos_type;
314 : typedef mbstate_t state_type;
315 :
316 : static void
317 : assign(char_type& __c1, const char_type& __c2) _GLIBCXX_NOEXCEPT
318 : { __c1 = __c2; }
319 :
320 : static _GLIBCXX_CONSTEXPR bool
321 : eq(const char_type& __c1, const char_type& __c2) _GLIBCXX_NOEXCEPT
322 : { return __c1 == __c2; }
323 :
324 : static _GLIBCXX_CONSTEXPR bool
325 : lt(const char_type& __c1, const char_type& __c2) _GLIBCXX_NOEXCEPT
326 : { return __c1 < __c2; }
327 :
328 : static int
329 : compare(const char_type* __s1, const char_type* __s2, size_t __n)
330 : { return wmemcmp(__s1, __s2, __n); }
331 :
332 : static size_t
333 : length(const char_type* __s)
334 : { return wcslen(__s); }
335 :
336 : static const char_type*
337 : find(const char_type* __s, size_t __n, const char_type& __a)
338 : { return wmemchr(__s, __a, __n); }
339 :
340 : static char_type*
341 : move(char_type* __s1, const char_type* __s2, size_t __n)
342 : { return wmemmove(__s1, __s2, __n); }
343 :
344 : static char_type*
345 : copy(char_type* __s1, const char_type* __s2, size_t __n)
346 : { return wmemcpy(__s1, __s2, __n); }
347 :
348 : static char_type*
349 : assign(char_type* __s, size_t __n, char_type __a)
350 : { return wmemset(__s, __a, __n); }
351 :
352 : static _GLIBCXX_CONSTEXPR char_type
353 : to_char_type(const int_type& __c) _GLIBCXX_NOEXCEPT
354 : { return char_type(__c); }
355 :
356 : static _GLIBCXX_CONSTEXPR int_type
357 : to_int_type(const char_type& __c) _GLIBCXX_NOEXCEPT
358 : { return int_type(__c); }
359 :
360 : static _GLIBCXX_CONSTEXPR bool
361 : eq_int_type(const int_type& __c1, const int_type& __c2) _GLIBCXX_NOEXCEPT
362 : { return __c1 == __c2; }
363 :
364 : static _GLIBCXX_CONSTEXPR int_type
365 : eof() _GLIBCXX_NOEXCEPT
366 : { return static_cast<int_type>(WEOF); }
367 :
368 : static _GLIBCXX_CONSTEXPR int_type
369 : not_eof(const int_type& __c) _GLIBCXX_NOEXCEPT
370 : { return eq_int_type(__c, eof()) ? 0 : __c; }
371 : };
372 : #endif //_GLIBCXX_USE_WCHAR_T
373 :
374 : _GLIBCXX_END_NAMESPACE_VERSION
375 : } // namespace
376 :
377 : #if ((__cplusplus >= 201103L) \
378 : && defined(_GLIBCXX_USE_C99_STDINT_TR1))
379 :
380 : #include <cstdint>
381 :
382 : namespace std _GLIBCXX_VISIBILITY(default)
383 : {
384 : _GLIBCXX_BEGIN_NAMESPACE_VERSION
385 :
386 : template<>
387 : struct char_traits<char16_t>
388 : {
389 : typedef char16_t char_type;
390 : typedef uint_least16_t int_type;
391 : typedef streamoff off_type;
392 : typedef u16streampos pos_type;
393 : typedef mbstate_t state_type;
394 :
395 : static void
396 : assign(char_type& __c1, const char_type& __c2) noexcept
397 : { __c1 = __c2; }
398 :
399 : static constexpr bool
400 : eq(const char_type& __c1, const char_type& __c2) noexcept
401 : { return __c1 == __c2; }
402 :
403 : static constexpr bool
404 : lt(const char_type& __c1, const char_type& __c2) noexcept
405 : { return __c1 < __c2; }
406 :
407 : static int
408 : compare(const char_type* __s1, const char_type* __s2, size_t __n)
409 : {
410 : for (size_t __i = 0; __i < __n; ++__i)
411 : if (lt(__s1[__i], __s2[__i]))
412 : return -1;
413 : else if (lt(__s2[__i], __s1[__i]))
414 : return 1;
415 : return 0;
416 : }
417 :
418 : static size_t
419 : length(const char_type* __s)
420 : {
421 : size_t __i = 0;
422 : while (!eq(__s[__i], char_type()))
423 : ++__i;
424 : return __i;
425 : }
426 :
427 : static const char_type*
428 : find(const char_type* __s, size_t __n, const char_type& __a)
429 : {
430 : for (size_t __i = 0; __i < __n; ++__i)
431 : if (eq(__s[__i], __a))
432 : return __s + __i;
433 : return 0;
434 : }
435 :
436 : static char_type*
437 : move(char_type* __s1, const char_type* __s2, size_t __n)
438 : {
439 : return (static_cast<char_type*>
440 : (__builtin_memmove(__s1, __s2, __n * sizeof(char_type))));
441 : }
442 :
443 : static char_type*
444 : copy(char_type* __s1, const char_type* __s2, size_t __n)
445 : {
446 : return (static_cast<char_type*>
447 : (__builtin_memcpy(__s1, __s2, __n * sizeof(char_type))));
448 : }
449 :
450 : static char_type*
451 : assign(char_type* __s, size_t __n, char_type __a)
452 : {
453 : for (size_t __i = 0; __i < __n; ++__i)
454 : assign(__s[__i], __a);
455 : return __s;
456 : }
457 :
458 : static constexpr char_type
459 : to_char_type(const int_type& __c) noexcept
460 : { return char_type(__c); }
461 :
462 : static constexpr int_type
463 : to_int_type(const char_type& __c) noexcept
464 : { return int_type(__c); }
465 :
466 : static constexpr bool
467 : eq_int_type(const int_type& __c1, const int_type& __c2) noexcept
468 : { return __c1 == __c2; }
469 :
470 : static constexpr int_type
471 : eof() noexcept
472 : { return static_cast<int_type>(-1); }
473 :
474 : static constexpr int_type
475 : not_eof(const int_type& __c) noexcept
476 : { return eq_int_type(__c, eof()) ? 0 : __c; }
477 : };
478 :
479 : template<>
480 : struct char_traits<char32_t>
481 : {
482 : typedef char32_t char_type;
483 : typedef uint_least32_t int_type;
484 : typedef streamoff off_type;
485 : typedef u32streampos pos_type;
486 : typedef mbstate_t state_type;
487 :
488 : static void
489 : assign(char_type& __c1, const char_type& __c2) noexcept
490 : { __c1 = __c2; }
491 :
492 : static constexpr bool
493 : eq(const char_type& __c1, const char_type& __c2) noexcept
494 : { return __c1 == __c2; }
495 :
496 : static constexpr bool
497 : lt(const char_type& __c1, const char_type& __c2) noexcept
498 : { return __c1 < __c2; }
499 :
500 : static int
501 : compare(const char_type* __s1, const char_type* __s2, size_t __n)
502 : {
503 : for (size_t __i = 0; __i < __n; ++__i)
504 : if (lt(__s1[__i], __s2[__i]))
505 : return -1;
506 : else if (lt(__s2[__i], __s1[__i]))
507 : return 1;
508 : return 0;
509 : }
510 :
511 : static size_t
512 : length(const char_type* __s)
513 : {
514 : size_t __i = 0;
515 : while (!eq(__s[__i], char_type()))
516 : ++__i;
517 : return __i;
518 : }
519 :
520 : static const char_type*
521 : find(const char_type* __s, size_t __n, const char_type& __a)
522 : {
523 : for (size_t __i = 0; __i < __n; ++__i)
524 : if (eq(__s[__i], __a))
525 : return __s + __i;
526 : return 0;
527 : }
528 :
529 : static char_type*
530 : move(char_type* __s1, const char_type* __s2, size_t __n)
531 : {
532 : return (static_cast<char_type*>
533 : (__builtin_memmove(__s1, __s2, __n * sizeof(char_type))));
534 : }
535 :
536 : static char_type*
537 : copy(char_type* __s1, const char_type* __s2, size_t __n)
538 : {
539 : return (static_cast<char_type*>
540 : (__builtin_memcpy(__s1, __s2, __n * sizeof(char_type))));
541 : }
542 :
543 : static char_type*
544 : assign(char_type* __s, size_t __n, char_type __a)
545 : {
546 : for (size_t __i = 0; __i < __n; ++__i)
547 : assign(__s[__i], __a);
548 : return __s;
549 : }
550 :
551 : static constexpr char_type
552 : to_char_type(const int_type& __c) noexcept
553 : { return char_type(__c); }
554 :
555 : static constexpr int_type
556 : to_int_type(const char_type& __c) noexcept
557 : { return int_type(__c); }
558 :
559 : static constexpr bool
560 : eq_int_type(const int_type& __c1, const int_type& __c2) noexcept
561 : { return __c1 == __c2; }
562 :
563 : static constexpr int_type
564 : eof() noexcept
565 : { return static_cast<int_type>(-1); }
566 :
567 : static constexpr int_type
568 : not_eof(const int_type& __c) noexcept
569 : { return eq_int_type(__c, eof()) ? 0 : __c; }
570 : };
571 :
572 : _GLIBCXX_END_NAMESPACE_VERSION
573 : } // namespace
574 :
575 : #endif
576 :
577 : #endif // _CHAR_TRAITS_H
|
