Line data Source code
1 : // Character Traits for use by standard string and iostream -*- C++ -*-
2 :
3 : // Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
4 : // 2006, 2007, 2008, 2009
5 : // Free Software Foundation, Inc.
6 : //
7 : // This file is part of the GNU ISO C++ Library. This library is free
8 : // software; you can redistribute it and/or modify it under the
9 : // terms of the GNU General Public License as published by the
10 : // Free Software Foundation; either version 3, or (at your option)
11 : // any later version.
12 :
13 : // This library is distributed in the hope that it will be useful,
14 : // but WITHOUT ANY WARRANTY; without even the implied warranty of
15 : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 : // GNU General Public License for more details.
17 :
18 : // Under Section 7 of GPL version 3, you are granted additional
19 : // permissions described in the GCC Runtime Library Exception, version
20 : // 3.1, as published by the Free Software Foundation.
21 :
22 : // You should have received a copy of the GNU General Public License and
23 : // a copy of the GCC Runtime Library Exception along with this program;
24 : // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
25 : // <http://www.gnu.org/licenses/>.
26 :
27 : /** @file char_traits.h
28 : * This is an internal header file, included by other library headers.
29 : * You should not attempt to use it directly.
30 : */
31 :
32 : //
33 : // ISO C++ 14882: 21 Strings library
34 : //
35 :
36 : #ifndef _CHAR_TRAITS_H
37 : #define _CHAR_TRAITS_H 1
38 :
39 : #pragma GCC system_header
40 :
41 : #include <bits/stl_algobase.h> // std::copy, std::fill_n
42 : #include <bits/postypes.h> // For streampos
43 : #include <cwchar> // For WEOF, wmemmove, wmemset, etc.
44 :
45 : #ifndef _GLIBCXX_STDIO_MACROS
46 : # include <cstdio> // For EOF
47 : # define _CHAR_TRAITS_EOF EOF
48 : #else
49 : # define _CHAR_TRAITS_EOF (-1)
50 : #endif
51 :
52 : _GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
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 http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt05ch13s03.html
86 : * for advice on how to make use of this class for "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 :
98 : static void
99 : assign(char_type& __c1, const char_type& __c2)
100 : { __c1 = __c2; }
101 :
102 : static bool
103 : eq(const char_type& __c1, const char_type& __c2)
104 : { return __c1 == __c2; }
105 :
106 : static bool
107 : lt(const char_type& __c1, const char_type& __c2)
108 : { return __c1 < __c2; }
109 :
110 : static int
111 : compare(const char_type* __s1, const char_type* __s2, std::size_t __n);
112 :
113 : static std::size_t
114 : length(const char_type* __s);
115 :
116 : static const char_type*
117 : find(const char_type* __s, std::size_t __n, const char_type& __a);
118 :
119 : static char_type*
120 : move(char_type* __s1, const char_type* __s2, std::size_t __n);
121 :
122 : static char_type*
123 : copy(char_type* __s1, const char_type* __s2, std::size_t __n);
124 :
125 : static char_type*
126 : assign(char_type* __s, std::size_t __n, char_type __a);
127 :
128 : static char_type
129 : to_char_type(const int_type& __c)
130 : { return static_cast<char_type>(__c); }
131 :
132 : static int_type
133 : to_int_type(const char_type& __c)
134 : { return static_cast<int_type>(__c); }
135 :
136 : static bool
137 : eq_int_type(const int_type& __c1, const int_type& __c2)
138 : { return __c1 == __c2; }
139 :
140 : static int_type
141 : eof()
142 : { return static_cast<int_type>(_CHAR_TRAITS_EOF); }
143 :
144 : static int_type
145 : not_eof(const int_type& __c)
146 : { return !eq_int_type(__c, eof()) ? __c : to_int_type(char_type()); }
147 : };
148 :
149 : template<typename _CharT>
150 : int
151 : char_traits<_CharT>::
152 : compare(const char_type* __s1, const char_type* __s2, std::size_t __n)
153 : {
154 : for (std::size_t __i = 0; __i < __n; ++__i)
155 : if (lt(__s1[__i], __s2[__i]))
156 : return -1;
157 : else if (lt(__s2[__i], __s1[__i]))
158 : return 1;
159 : return 0;
160 : }
161 :
162 : template<typename _CharT>
163 : std::size_t
164 : char_traits<_CharT>::
165 : length(const char_type* __p)
166 : {
167 : std::size_t __i = 0;
168 : while (!eq(__p[__i], char_type()))
169 : ++__i;
170 : return __i;
171 : }
172 :
173 : template<typename _CharT>
174 : const typename char_traits<_CharT>::char_type*
175 : char_traits<_CharT>::
176 : find(const char_type* __s, std::size_t __n, const char_type& __a)
177 : {
178 : for (std::size_t __i = 0; __i < __n; ++__i)
179 : if (eq(__s[__i], __a))
180 : return __s + __i;
181 : return 0;
182 : }
183 :
184 : template<typename _CharT>
185 : typename char_traits<_CharT>::char_type*
186 : char_traits<_CharT>::
187 : move(char_type* __s1, const char_type* __s2, std::size_t __n)
188 : {
189 : return static_cast<_CharT*>(__builtin_memmove(__s1, __s2,
190 : __n * sizeof(char_type)));
191 : }
192 :
193 : template<typename _CharT>
194 : typename char_traits<_CharT>::char_type*
195 : char_traits<_CharT>::
196 : copy(char_type* __s1, const char_type* __s2, std::size_t __n)
197 : {
198 : // NB: Inline std::copy so no recursive dependencies.
199 : std::copy(__s2, __s2 + __n, __s1);
200 : return __s1;
201 : }
202 :
203 : template<typename _CharT>
204 : typename char_traits<_CharT>::char_type*
205 : char_traits<_CharT>::
206 : assign(char_type* __s, std::size_t __n, char_type __a)
207 : {
208 : // NB: Inline std::fill_n so no recursive dependencies.
209 : std::fill_n(__s, __n, __a);
210 : return __s;
211 : }
212 :
213 : _GLIBCXX_END_NAMESPACE
214 :
215 : _GLIBCXX_BEGIN_NAMESPACE(std)
216 :
217 : // 21.1
218 : /**
219 : * @brief Basis for explicit traits specializations.
220 : *
221 : * @note For any given actual character type, this definition is
222 : * probably wrong. Since this is just a thin wrapper around
223 : * __gnu_cxx::char_traits, it is possible to achieve a more
224 : * appropriate definition by specializing __gnu_cxx::char_traits.
225 : *
226 : * See http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt05ch13s03.html
227 : * for advice on how to make use of this class for "unusual" character
228 : * types. Also, check out include/ext/pod_char_traits.h.
229 : */
230 : template<class _CharT>
231 : struct char_traits : public __gnu_cxx::char_traits<_CharT>
232 : { };
233 :
234 :
235 : /// 21.1.3.1 char_traits specializations
236 : template<>
237 : struct char_traits<char>
238 : {
239 : typedef char char_type;
240 : typedef int int_type;
241 : typedef streampos pos_type;
242 : typedef streamoff off_type;
243 : typedef mbstate_t state_type;
244 :
245 : static void
246 : assign(char_type& __c1, const char_type& __c2)
247 : { __c1 = __c2; }
248 :
249 : static bool
250 : eq(const char_type& __c1, const char_type& __c2)
251 : { return __c1 == __c2; }
252 :
253 : static bool
254 : lt(const char_type& __c1, const char_type& __c2)
255 : { return __c1 < __c2; }
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 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 : 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 char_type
282 : to_char_type(const int_type& __c)
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 int_type
288 : to_int_type(const char_type& __c)
289 : { return static_cast<int_type>(static_cast<unsigned char>(__c)); }
290 :
291 : static bool
292 : eq_int_type(const int_type& __c1, const int_type& __c2)
293 : { return __c1 == __c2; }
294 :
295 : static int_type
296 : eof()
297 : { return static_cast<int_type>(_CHAR_TRAITS_EOF); }
298 :
299 : static int_type
300 : not_eof(const int_type& __c)
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)
318 : { __c1 = __c2; }
319 :
320 : static bool
321 : eq(const char_type& __c1, const char_type& __c2)
322 : { return __c1 == __c2; }
323 :
324 : static bool
325 : lt(const char_type& __c1, const char_type& __c2)
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 char_type
353 : to_char_type(const int_type& __c)
354 : { return char_type(__c); }
355 :
356 : static int_type
357 : to_int_type(const char_type& __c)
358 : { return int_type(__c); }
359 :
360 : static bool
361 : eq_int_type(const int_type& __c1, const int_type& __c2)
362 : { return __c1 == __c2; }
363 :
364 : static int_type
365 : eof()
366 : { return static_cast<int_type>(WEOF); }
367 :
368 : static int_type
369 : not_eof(const int_type& __c)
370 : { return eq_int_type(__c, eof()) ? 0 : __c; }
371 : };
372 : #endif //_GLIBCXX_USE_WCHAR_T
373 :
374 : _GLIBCXX_END_NAMESPACE
375 :
376 : #if (defined(__GXX_EXPERIMENTAL_CXX0X__) \
377 : && defined(_GLIBCXX_USE_C99_STDINT_TR1))
378 :
379 : #include <cstdint>
380 :
381 : _GLIBCXX_BEGIN_NAMESPACE(std)
382 :
383 : template<>
384 : struct char_traits<char16_t>
385 : {
386 : typedef char16_t char_type;
387 : typedef uint_least16_t int_type;
388 : typedef streamoff off_type;
389 : typedef u16streampos pos_type;
390 : typedef mbstate_t state_type;
391 :
392 : static void
393 : assign(char_type& __c1, const char_type& __c2)
394 : { __c1 = __c2; }
395 :
396 : static bool
397 : eq(const char_type& __c1, const char_type& __c2)
398 : { return __c1 == __c2; }
399 :
400 : static bool
401 : lt(const char_type& __c1, const char_type& __c2)
402 : { return __c1 < __c2; }
403 :
404 : static int
405 : compare(const char_type* __s1, const char_type* __s2, size_t __n)
406 : {
407 : for (size_t __i = 0; __i < __n; ++__i)
408 : if (lt(__s1[__i], __s2[__i]))
409 : return -1;
410 : else if (lt(__s2[__i], __s1[__i]))
411 : return 1;
412 : return 0;
413 : }
414 :
415 : static size_t
416 : length(const char_type* __s)
417 : {
418 : size_t __i = 0;
419 : while (!eq(__s[__i], char_type()))
420 : ++__i;
421 : return __i;
422 : }
423 :
424 : static const char_type*
425 : find(const char_type* __s, size_t __n, const char_type& __a)
426 : {
427 : for (size_t __i = 0; __i < __n; ++__i)
428 : if (eq(__s[__i], __a))
429 : return __s + __i;
430 : return 0;
431 : }
432 :
433 : static char_type*
434 : move(char_type* __s1, const char_type* __s2, size_t __n)
435 : {
436 : return (static_cast<char_type*>
437 : (__builtin_memmove(__s1, __s2, __n * sizeof(char_type))));
438 : }
439 :
440 : static char_type*
441 : copy(char_type* __s1, const char_type* __s2, size_t __n)
442 : {
443 : return (static_cast<char_type*>
444 : (__builtin_memcpy(__s1, __s2, __n * sizeof(char_type))));
445 : }
446 :
447 : static char_type*
448 : assign(char_type* __s, size_t __n, char_type __a)
449 : {
450 : for (size_t __i = 0; __i < __n; ++__i)
451 : assign(__s[__i], __a);
452 : return __s;
453 : }
454 :
455 : static char_type
456 : to_char_type(const int_type& __c)
457 : { return char_type(__c); }
458 :
459 : static int_type
460 : to_int_type(const char_type& __c)
461 : { return int_type(__c); }
462 :
463 : static bool
464 : eq_int_type(const int_type& __c1, const int_type& __c2)
465 : { return __c1 == __c2; }
466 :
467 : static int_type
468 : eof()
469 : { return static_cast<int_type>(-1); }
470 :
471 : static int_type
472 : not_eof(const int_type& __c)
473 : { return eq_int_type(__c, eof()) ? 0 : __c; }
474 : };
475 :
476 : template<>
477 : struct char_traits<char32_t>
478 : {
479 : typedef char32_t char_type;
480 : typedef uint_least32_t int_type;
481 : typedef streamoff off_type;
482 : typedef u32streampos pos_type;
483 : typedef mbstate_t state_type;
484 :
485 : static void
486 : assign(char_type& __c1, const char_type& __c2)
487 : { __c1 = __c2; }
488 :
489 : static bool
490 : eq(const char_type& __c1, const char_type& __c2)
491 : { return __c1 == __c2; }
492 :
493 : static bool
494 : lt(const char_type& __c1, const char_type& __c2)
495 : { return __c1 < __c2; }
496 :
497 : static int
498 : compare(const char_type* __s1, const char_type* __s2, size_t __n)
499 : {
500 : for (size_t __i = 0; __i < __n; ++__i)
501 : if (lt(__s1[__i], __s2[__i]))
502 : return -1;
503 : else if (lt(__s2[__i], __s1[__i]))
504 : return 1;
505 : return 0;
506 : }
507 :
508 : static size_t
509 : length(const char_type* __s)
510 : {
511 : size_t __i = 0;
512 : while (!eq(__s[__i], char_type()))
513 : ++__i;
514 : return __i;
515 : }
516 :
517 : static const char_type*
518 : find(const char_type* __s, size_t __n, const char_type& __a)
519 : {
520 : for (size_t __i = 0; __i < __n; ++__i)
521 : if (eq(__s[__i], __a))
522 : return __s + __i;
523 : return 0;
524 : }
525 :
526 : static char_type*
527 : move(char_type* __s1, const char_type* __s2, size_t __n)
528 : {
529 : return (static_cast<char_type*>
530 : (__builtin_memmove(__s1, __s2, __n * sizeof(char_type))));
531 : }
532 :
533 : static char_type*
534 : copy(char_type* __s1, const char_type* __s2, size_t __n)
535 : {
536 : return (static_cast<char_type*>
537 : (__builtin_memcpy(__s1, __s2, __n * sizeof(char_type))));
538 : }
539 :
540 : static char_type*
541 : assign(char_type* __s, size_t __n, char_type __a)
542 : {
543 : for (size_t __i = 0; __i < __n; ++__i)
544 : assign(__s[__i], __a);
545 : return __s;
546 : }
547 :
548 : static char_type
549 : to_char_type(const int_type& __c)
550 : { return char_type(__c); }
551 :
552 : static int_type
553 : to_int_type(const char_type& __c)
554 : { return int_type(__c); }
555 :
556 : static bool
557 : eq_int_type(const int_type& __c1, const int_type& __c2)
558 : { return __c1 == __c2; }
559 :
560 : static int_type
561 : eof()
562 : { return static_cast<int_type>(-1); }
563 :
564 : static int_type
565 : not_eof(const int_type& __c)
566 : { return eq_int_type(__c, eof()) ? 0 : __c; }
567 : };
568 :
569 : _GLIBCXX_END_NAMESPACE
570 :
571 : #endif
572 :
573 : #undef _CHAR_TRAITS_EOF
574 :
575 : #endif // _CHAR_TRAITS_H
|
