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
_GLIBCXX_VISIBILITY(default)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
_GLIBCXX_VISIBILITY(default)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 assign(char_type& __c1, const char_type& __c2) _GLIBCXX_NOEXCEPT
243 { __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 compare(const char_type* __s1, const char_type* __s2, size_t __n)
259 { return __builtin_memcmp(__s1, __s2, __n); }
260
261 static size_t
262 length(const char_type* __s)
263 { 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 copy(char_type* __s1, const char_type* __s2, size_t __n)
275 { 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
578