LCOV - app.info - /tools/gcc-4.5/include/c++/4.5.2/bits/char_traits.h

LCOV - code coverage report
| Current view: | directory - tools/gcc-4.5/include/c++/4.5.2/bits - char_traits.h (source / functions) |  | Found | Hit | Coverage |
| Test: | app.info | Lines: | 14 | 2 | 14.3 %
| Date: | 2012-04-07 | Functions: | 7 | 1 | 14.3 %

           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, 2010
           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 @a 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 @a 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               0 :       assign(char_type& __c1, const char_type& __c2)
         247               0 :       { __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       151464365 :       compare(const char_type* __s1, const char_type* __s2, size_t __n)
         259       151464365 :       { 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 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               0 :       to_int_type(const char_type& __c)
         289               0 :       { return static_cast<int_type>(static_cast<unsigned char>(__c)); }
         290                 :
         291                 :       static bool
         292               0 :       eq_int_type(const int_type& __c1, const int_type& __c2)
         293               0 :       { return __c1 == __c2; }
         294                 :
         295                 :       static int_type
         296               0 :       eof()
         297               0 :       { 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

Generated by: LCOV version 1.7