| Line | % of fetches | Source |
|---|---|---|
| 1 | // Character Traits for use by standard string and iostream -*- C++ -*- | |
| 2 | ||
| 3 | // Copyright (C) 1997-2015 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 https://gcc.gnu.org/onlinedocs/libstdc++/manual/strings.html#strings.string.character_types | |
| 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 https://gcc.gnu.org/onlinedocs/libstdc++/manual/strings.html#strings.string.character_types | |
| 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 | { | |
| 260 | if (__n == 0) | |
| 261 | return 0; | |
| 262 | return __builtin_memcmp(__s1, __s2, __n); | |
| 263 | } | |
| 264 | ||
| 265 | static size_t | |
| 266 | length(const char_type* __s) | |
| 267 | { return __builtin_strlen(__s); } | |
| 268 | ||
| 269 | static const char_type* | |
| 270 | find(const char_type* __s, size_t __n, const char_type& __a) | |
| 271 | { | |
| 272 | if (__n == 0) | |
| 273 | return 0; | |
| 274 | return static_cast<const char_type*>(__builtin_memchr(__s, __a, __n)); | |
| 275 | } | |
| 276 | ||
| 277 | static char_type* | |
| 278 | move(char_type* __s1, const char_type* __s2, size_t __n) | |
| 279 | { | |
| 280 | if (__n == 0) | |
| 281 | return __s1; | |
| 282 | return static_cast<char_type*>(__builtin_memmove(__s1, __s2, __n)); | |
| 283 | } | |
| 284 | ||
| 285 | static char_type* | |
| 286 | copy(char_type* __s1, const char_type* __s2, size_t __n) | |
| 287 | { | |
| 288 | if (__n == 0) | |
| 289 | return __s1; | |
| 290 | return static_cast<char_type*>(__builtin_memcpy(__s1, __s2, __n)); | |
| 291 | } | |
| 292 | ||
| 293 | static char_type* | |
| 294 | assign(char_type* __s, size_t __n, char_type __a) | |
| 295 | { | |
| 296 | if (__n == 0) | |
| 297 | return __s; | |
| 298 | return static_cast<char_type*>(__builtin_memset(__s, __a, __n)); | |
| 299 | } | |
| 300 | ||
| 301 | static _GLIBCXX_CONSTEXPR char_type | |
| 302 | to_char_type(const int_type& __c) _GLIBCXX_NOEXCEPT | |
| 303 | { return static_cast<char_type>(__c); } | |
| 304 | ||
| 305 | // To keep both the byte 0xff and the eof symbol 0xffffffff | |
| 306 | // from ending up as 0xffffffff. | |
| 307 | static _GLIBCXX_CONSTEXPR int_type | |
| 308 | to_int_type(const char_type& __c) _GLIBCXX_NOEXCEPT | |
| 309 | { return static_cast<int_type>(static_cast<unsigned char>(__c)); } | |
| 310 | ||
| 311 | static _GLIBCXX_CONSTEXPR bool | |
| 312 | eq_int_type(const int_type& __c1, const int_type& __c2) _GLIBCXX_NOEXCEPT | |
| 313 | { return __c1 == __c2; } | |
| 314 | ||
| 315 | static _GLIBCXX_CONSTEXPR int_type | |
| 316 | eof() _GLIBCXX_NOEXCEPT | |
| 317 | { return static_cast<int_type>(_GLIBCXX_STDIO_EOF); } | |
| 318 | ||
| 319 | static _GLIBCXX_CONSTEXPR int_type | |
| 320 | not_eof(const int_type& __c) _GLIBCXX_NOEXCEPT | |
| 321 | { return (__c == eof()) ? 0 : __c; } | |
| 322 | }; | |
| 323 | ||
| 324 | ||
| 325 | #ifdef _GLIBCXX_USE_WCHAR_T | |
| 326 | /// 21.1.3.2 char_traits specializations | |
| 327 | template<> | |
| 328 | struct char_traits<wchar_t> | |
| 329 | { | |
| 330 | typedef wchar_t char_type; | |
| 331 | typedef wint_t int_type; | |
| 332 | typedef streamoff off_type; | |
| 333 | typedef wstreampos pos_type; | |
| 334 | typedef mbstate_t state_type; | |
| 335 | ||
| 336 | static void | |
| 337 | assign(char_type& __c1, const char_type& __c2) _GLIBCXX_NOEXCEPT | |
| 338 | { __c1 = __c2; } | |
| 339 | ||
| 340 | static _GLIBCXX_CONSTEXPR bool | |
| 341 | eq(const char_type& __c1, const char_type& __c2) _GLIBCXX_NOEXCEPT | |
| 342 | { return __c1 == __c2; } | |
| 343 | ||
| 344 | static _GLIBCXX_CONSTEXPR bool | |
| 345 | lt(const char_type& __c1, const char_type& __c2) _GLIBCXX_NOEXCEPT | |
| 346 | { return __c1 < __c2; } | |
| 347 | ||
| 348 | static int | |
| 349 | compare(const char_type* __s1, const char_type* __s2, size_t __n) | |
| 350 | { | |
| 351 | if (__n == 0) | |
| 352 | return 0; | |
| 353 | return wmemcmp(__s1, __s2, __n); | |
| 354 | } | |
| 355 | ||
| 356 | static size_t | |
| 357 | length(const char_type* __s) | |
| 358 | { return wcslen(__s); } | |
| 359 | ||
| 360 | static const char_type* | |
| 361 | find(const char_type* __s, size_t __n, const char_type& __a) | |
| 362 | { | |
| 363 | if (__n == 0) | |
| 364 | return 0; | |
| 365 | return wmemchr(__s, __a, __n); | |
| 366 | } | |
| 367 | ||
| 368 | static char_type* | |
| 369 | move(char_type* __s1, const char_type* __s2, size_t __n) | |
| 370 | { | |
| 371 | if (__n == 0) | |
| 372 | return __s1; | |
| 373 | return wmemmove(__s1, __s2, __n); | |
| 374 | } | |
| 375 | ||
| 376 | static char_type* | |
| 377 | copy(char_type* __s1, const char_type* __s2, size_t __n) | |
| 378 | { | |
| 379 | if (__n == 0) | |
| 380 | return __s1; | |
| 381 | return wmemcpy(__s1, __s2, __n); | |
| 382 | } | |
| 383 | ||
| 384 | static char_type* | |
| 385 | assign(char_type* __s, size_t __n, char_type __a) | |
| 386 | { | |
| 387 | if (__n == 0) | |
| 388 | return __s; | |
| 389 | return wmemset(__s, __a, __n); | |
| 390 | } | |
| 391 | ||
| 392 | static _GLIBCXX_CONSTEXPR char_type | |
| 393 | to_char_type(const int_type& __c) _GLIBCXX_NOEXCEPT | |
| 394 | { return char_type(__c); } | |
| 395 | ||
| 396 | static _GLIBCXX_CONSTEXPR int_type | |
| 397 | to_int_type(const char_type& __c) _GLIBCXX_NOEXCEPT | |
| 398 | { return int_type(__c); } | |
| 399 | ||
| 400 | static _GLIBCXX_CONSTEXPR bool | |
| 401 | eq_int_type(const int_type& __c1, const int_type& __c2) _GLIBCXX_NOEXCEPT | |
| 402 | { return __c1 == __c2; } | |
| 403 | ||
| 404 | static _GLIBCXX_CONSTEXPR int_type | |
| 405 | eof() _GLIBCXX_NOEXCEPT | |
| 406 | { return static_cast<int_type>(WEOF); } | |
| 407 | ||
| 408 | static _GLIBCXX_CONSTEXPR int_type | |
| 409 | not_eof(const int_type& __c) _GLIBCXX_NOEXCEPT | |
| 410 | { return eq_int_type(__c, eof()) ? 0 : __c; } | |
| 411 | }; | |
| 412 | #endif //_GLIBCXX_USE_WCHAR_T | |
| 413 | ||
| 414 | _GLIBCXX_END_NAMESPACE_VERSION | |
| 415 | } // namespace | |
| 416 | ||
| 417 | #if ((__cplusplus >= 201103L) \ | |
| 418 | && defined(_GLIBCXX_USE_C99_STDINT_TR1)) | |
| 419 | ||
| 420 | #include <cstdint> | |
| 421 | ||
| 422 | namespace std _GLIBCXX_VISIBILITY(default) | |
| 423 | { | |
| 424 | _GLIBCXX_BEGIN_NAMESPACE_VERSION | |
| 425 | ||
| 426 | template<> | |
| 427 | struct char_traits<char16_t> | |
| 428 | { | |
| 429 | typedef char16_t char_type; | |
| 430 | typedef uint_least16_t int_type; | |
| 431 | typedef streamoff off_type; | |
| 432 | typedef u16streampos pos_type; | |
| 433 | typedef mbstate_t state_type; | |
| 434 | ||
| 435 | static void | |
| 436 | assign(char_type& __c1, const char_type& __c2) noexcept | |
| 437 | { __c1 = __c2; } | |
| 438 | ||
| 439 | static constexpr bool | |
| 440 | eq(const char_type& __c1, const char_type& __c2) noexcept | |
| 441 | { return __c1 == __c2; } | |
| 442 | ||
| 443 | static constexpr bool | |
| 444 | lt(const char_type& __c1, const char_type& __c2) noexcept | |
| 445 | { return __c1 < __c2; } | |
| 446 | ||
| 447 | static int | |
| 448 | compare(const char_type* __s1, const char_type* __s2, size_t __n) | |
| 449 | { | |
| 450 | for (size_t __i = 0; __i < __n; ++__i) | |
| 451 | if (lt(__s1[__i], __s2[__i])) | |
| 452 | return -1; | |
| 453 | else if (lt(__s2[__i], __s1[__i])) | |
| 454 | return 1; | |
| 455 | return 0; | |
| 456 | } | |
| 457 | ||
| 458 | static size_t | |
| 459 | length(const char_type* __s) | |
| 460 | { | |
| 461 | size_t __i = 0; | |
| 462 | while (!eq(__s[__i], char_type())) | |
| 463 | ++__i; | |
| 464 | return __i; | |
| 465 | } | |
| 466 | ||
| 467 | static const char_type* | |
| 468 | find(const char_type* __s, size_t __n, const char_type& __a) | |
| 469 | { | |
| 470 | for (size_t __i = 0; __i < __n; ++__i) | |
| 471 | if (eq(__s[__i], __a)) | |
| 472 | return __s + __i; | |
| 473 | return 0; | |
| 474 | } | |
| 475 | ||
| 476 | static char_type* | |
| 477 | move(char_type* __s1, const char_type* __s2, size_t __n) | |
| 478 | { | |
| 479 | if (__n == 0) | |
| 480 | return __s1; | |
| 481 | return (static_cast<char_type*> | |
| 482 | (__builtin_memmove(__s1, __s2, __n * sizeof(char_type)))); | |
| 483 | } | |
| 484 | ||
| 485 | static char_type* | |
| 486 | copy(char_type* __s1, const char_type* __s2, size_t __n) | |
| 487 | { | |
| 488 | if (__n == 0) | |
| 489 | return __s1; | |
| 490 | return (static_cast<char_type*> | |
| 491 | (__builtin_memcpy(__s1, __s2, __n * sizeof(char_type)))); | |
| 492 | } | |
| 493 | ||
| 494 | static char_type* | |
| 495 | assign(char_type* __s, size_t __n, char_type __a) | |
| 496 | { | |
| 497 | for (size_t __i = 0; __i < __n; ++__i) | |
| 498 | assign(__s[__i], __a); | |
| 499 | return __s; | |
| 500 | } | |
| 501 | ||
| 502 | static constexpr char_type | |
| 503 | to_char_type(const int_type& __c) noexcept | |
| 504 | { return char_type(__c); } | |
| 505 | ||
| 506 | static constexpr int_type | |
| 507 | to_int_type(const char_type& __c) noexcept | |
| 508 | { return int_type(__c); } | |
| 509 | ||
| 510 | static constexpr bool | |
| 511 | eq_int_type(const int_type& __c1, const int_type& __c2) noexcept | |
| 512 | { return __c1 == __c2; } | |
| 513 | ||
| 514 | static constexpr int_type | |
| 515 | eof() noexcept | |
| 516 | { return static_cast<int_type>(-1); } | |
| 517 | ||
| 518 | static constexpr int_type | |
| 519 | not_eof(const int_type& __c) noexcept | |
| 520 | { return eq_int_type(__c, eof()) ? 0 : __c; } | |
| 521 | }; | |
| 522 | ||
| 523 | template<> | |
| 524 | struct char_traits<char32_t> | |
| 525 | { | |
| 526 | typedef char32_t char_type; | |
| 527 | typedef uint_least32_t int_type; | |
| 528 | typedef streamoff off_type; | |
| 529 | typedef u32streampos pos_type; | |
| 530 | typedef mbstate_t state_type; | |
| 531 | ||
| 532 | static void | |
| 533 | assign(char_type& __c1, const char_type& __c2) noexcept | |
| 534 | { __c1 = __c2; } | |
| 535 | ||
| 536 | static constexpr bool | |
| 537 | eq(const char_type& __c1, const char_type& __c2) noexcept | |
| 538 | { return __c1 == __c2; } | |
| 539 | ||
| 540 | static constexpr bool | |
| 541 | lt(const char_type& __c1, const char_type& __c2) noexcept | |
| 542 | { return __c1 < __c2; } | |
| 543 | ||
| 544 | static int | |
| 545 | compare(const char_type* __s1, const char_type* __s2, size_t __n) | |
| 546 | { | |
| 547 | for (size_t __i = 0; __i < __n; ++__i) | |
| 548 | if (lt(__s1[__i], __s2[__i])) | |
| 549 | return -1; | |
| 550 | else if (lt(__s2[__i], __s1[__i])) | |
| 551 | return 1; | |
| 552 | return 0; | |
| 553 | } | |
| 554 | ||
| 555 | static size_t | |
| 556 | length(const char_type* __s) | |
| 557 | { | |
| 558 | size_t __i = 0; | |
| 559 | while (!eq(__s[__i], char_type())) | |
| 560 | ++__i; | |
| 561 | return __i; | |
| 562 | } | |
| 563 | ||
| 564 | static const char_type* | |
| 565 | find(const char_type* __s, size_t __n, const char_type& __a) | |
| 566 | { | |
| 567 | for (size_t __i = 0; __i < __n; ++__i) | |
| 568 | if (eq(__s[__i], __a)) | |
| 569 | return __s + __i; | |
| 570 | return 0; | |
| 571 | } | |
| 572 | ||
| 573 | static char_type* | |
| 574 | move(char_type* __s1, const char_type* __s2, size_t __n) | |
| 575 | { | |
| 576 | if (__n == 0) | |
| 577 | return __s1; | |
| 578 | return (static_cast<char_type*> | |
| 579 | (__builtin_memmove(__s1, __s2, __n * sizeof(char_type)))); | |
| 580 | } | |
| 581 | ||
| 582 | static char_type* | |
| 583 | copy(char_type* __s1, const char_type* __s2, size_t __n) | |
| 584 | { | |
| 585 | if (__n == 0) | |
| 586 | return __s1; | |
| 587 | return (static_cast<char_type*> | |
| 588 | (__builtin_memcpy(__s1, __s2, __n * sizeof(char_type)))); | |
| 589 | } | |
| 590 | ||
| 591 | static char_type* | |
| 592 | assign(char_type* __s, size_t __n, char_type __a) | |
| 593 | { | |
| 594 | for (size_t __i = 0; __i < __n; ++__i) | |
| 595 | assign(__s[__i], __a); | |
| 596 | return __s; | |
| 597 | } | |
| 598 | ||
| 599 | static constexpr char_type | |
| 600 | to_char_type(const int_type& __c) noexcept | |
| 601 | { return char_type(__c); } | |
| 602 | ||
| 603 | static constexpr int_type | |
| 604 | to_int_type(const char_type& __c) noexcept | |
| 605 | { return int_type(__c); } | |
| 606 | ||
| 607 | static constexpr bool | |
| 608 | eq_int_type(const int_type& __c1, const int_type& __c2) noexcept | |
| 609 | { return __c1 == __c2; } | |
| 610 | ||
| 611 | static constexpr int_type | |
| 612 | eof() noexcept | |
| 613 | { return static_cast<int_type>(-1); } | |
| 614 | ||
| 615 | static constexpr int_type | |
| 616 | not_eof(const int_type& __c) noexcept | |
| 617 | { return eq_int_type(__c, eof()) ? 0 : __c; } | |
| 618 | }; | |
| 619 | ||
| 620 | _GLIBCXX_END_NAMESPACE_VERSION | |
| 621 | } // namespace | |
| 622 | ||
| 623 | #endif | |
| 624 | ||
| 625 | #endif // _CHAR_TRAITS_H | |
| 626 |
Copyright (c) 2006-2012 Rogue Wave Software, Inc. All Rights Reserved.
Patents pending.