libstdc++-v3/config/locale/gnu/ctype_members.cc

   1 // std::ctype implementation details, GNU version -*- C++ -*-
   2
   3 // Copyright (C) 2001, 2002 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 2, 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 // You should have received a copy of the GNU General Public License along
  17 // with this library; see the file COPYING.  If not, write to the Free
  18 // Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
  19 // USA.
  20
  21 // As a special exception, you may use this file as part of a free software
  22 // library without restriction.  Specifically, if other files instantiate
  23 // templates or use macros or inline functions from this file, or you compile
  24 // this file and link it with other files to produce an executable, this
  25 // file does not by itself cause the resulting executable to be covered by
  26 // the GNU General Public License.  This exception does not however
  27 // invalidate any other reasons why the executable file might be covered by
  28 // the GNU General Public License.
  29
  30 //
  31 // ISO C++ 14882: 22.2.1.1.2  ctype virtual functions.
  32 //
  33
  34 // Written by Benjamin Kosnik <bkoz@redhat.com>
  35
  36 #include <locale>
  37 #include <bits/c++locale_internal.h>
  38
  39 namespace std
  40 {
  41   // NB: The other ctype<char> specializations are in src/locale.cc and
  42   // various /config/os/* files.
  43   template<>
  44     ctype_byname<char>::ctype_byname(const char* __s, size_t __refs)
  45     : ctype<char>(0, false, __refs)
  46     {
  47       _S_destroy_c_locale(_M_c_locale_ctype);
  48       _S_create_c_locale(_M_c_locale_ctype, __s);
  49       _M_toupper = _M_c_locale_ctype->__ctype_toupper;
  50       _M_tolower = _M_c_locale_ctype->__ctype_tolower;
  51       _M_table = _M_c_locale_ctype->__ctype_b;
  52     }
  53
  54 #ifdef _GLIBCPP_USE_WCHAR_T
  55   ctype<wchar_t>::__wmask_type
  56   ctype<wchar_t>::_M_convert_to_wmask(const mask __m) const
  57   {
  58     __wmask_type __ret;
  59     switch (__m)
  60       {
  61       case space:
  62         __ret = __wctype_l("space", _M_c_locale_ctype);
  63         break;
  64       case print:
  65         __ret = __wctype_l("print", _M_c_locale_ctype);
  66         break;
  67       case cntrl:
  68         __ret = __wctype_l("cntrl", _M_c_locale_ctype);
  69         break;
  70       case upper:
  71         __ret = __wctype_l("upper", _M_c_locale_ctype);
  72         break;
  73       case lower:
  74         __ret = __wctype_l("lower", _M_c_locale_ctype);
  75         break;
  76       case alpha:
  77         __ret = __wctype_l("alpha", _M_c_locale_ctype);
  78         break;
  79       case digit:
  80         __ret = __wctype_l("digit", _M_c_locale_ctype);
  81         break;
  82       case punct:
  83         __ret = __wctype_l("punct", _M_c_locale_ctype);
  84         break;
  85       case xdigit:
  86         __ret = __wctype_l("xdigit", _M_c_locale_ctype);
  87         break;
  88       case alnum:
  89         __ret = __wctype_l("alnum", _M_c_locale_ctype);
  90         break;
  91       case graph:
  92         __ret = __wctype_l("graph", _M_c_locale_ctype);
  93         break;
  94       default:
  95         __ret = 0;
  96       }
  97     return __ret;
  98   };
  99
 100   wchar_t
 101   ctype<wchar_t>::do_toupper(wchar_t __c) const
 102   { return __towupper_l(__c, _M_c_locale_ctype); }
 103
 104   const wchar_t*
 105   ctype<wchar_t>::do_toupper(wchar_t* __lo, const wchar_t* __hi) const
 106   {
 107     while (__lo < __hi)
 108       {
 109         *__lo = __towupper_l(*__lo, _M_c_locale_ctype);
 110         ++__lo;
 111       }
 112     return __hi;
 113   }
 114
 115   wchar_t
 116   ctype<wchar_t>::do_tolower(wchar_t __c) const
 117   { return __towlower_l(__c, _M_c_locale_ctype); }
 118
 119   const wchar_t*
 120   ctype<wchar_t>::do_tolower(wchar_t* __lo, const wchar_t* __hi) const
 121   {
 122     while (__lo < __hi)
 123       {
 124         *__lo = __towlower_l(*__lo, _M_c_locale_ctype);
 125         ++__lo;
 126       }
 127     return __hi;
 128   }
 129
 130   bool
 131   ctype<wchar_t>::
 132   do_is(mask __m, char_type __c) const
 133   {
 134     return static_cast<bool>(__iswctype_l(__c, _M_convert_to_wmask(__m),
 135                                           _M_c_locale_ctype));
 136   }
 137
 138   const wchar_t*
 139   ctype<wchar_t>::
 140   do_is(const wchar_t* __lo, const wchar_t* __hi, mask* __m) const
 141   {
 142     while (__lo < __hi && !this->do_is(*__m, *__lo))
 143       ++__lo;
 144     return __lo;
 145   }
 146
 147   const wchar_t*
 148   ctype<wchar_t>::
 149   do_scan_is(mask __m, const wchar_t* __lo, const wchar_t* __hi) const
 150   {
 151     while (__lo < __hi && !this->do_is(__m, *__lo))
 152       ++__lo;
 153     return __lo;
 154   }
 155
 156   const wchar_t*
 157   ctype<wchar_t>::
 158   do_scan_not(mask __m, const char_type* __lo, const char_type* __hi) const
 159   {
 160     while (__lo < __hi && this->do_is(__m, *__lo) != 0)
 161       ++__lo;
 162     return __lo;
 163   }
 164
 165   wchar_t
 166   ctype<wchar_t>::
 167   do_widen(char __c) const
 168   {
 169 #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ > 2)
 170     __c_locale __old = __uselocale(_M_c_locale_ctype);
 171 #endif
 172     wchar_t __ret = btowc(__c);
 173 #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ > 2)
 174     __uselocale(__old);
 175 #endif
 176     return __ret;
 177   }
 178
 179   const char*
 180   ctype<wchar_t>::
 181   do_widen(const char* __lo, const char* __hi, wchar_t* __dest) const
 182   {
 183 #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ > 2)
 184     __c_locale __old = __uselocale(_M_c_locale_ctype);
 185 #endif
 186     mbstate_t __state;
 187     memset(static_cast<void*>(&__state), 0, sizeof(mbstate_t));
 188     mbsrtowcs(__dest, &__lo, __hi - __lo, &__state);
 189 #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ > 2)
 190     __uselocale(__old);
 191 #endif
 192     return __hi;
 193   }
 194
 195   char
 196   ctype<wchar_t>::
 197   do_narrow(wchar_t __wc, char __dfault) const
 198   {
 199 #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ > 2)
 200     __c_locale __old = __uselocale(_M_c_locale_ctype);
 201 #endif
 202     int __c = wctob(__wc);
 203 #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ > 2)
 204     __uselocale(__old);
 205 #endif
 206     return (__c == EOF ? __dfault : static_cast<char>(__c));
 207   }
 208
 209   const wchar_t*
 210   ctype<wchar_t>::
 211   do_narrow(const wchar_t* __lo, const wchar_t* __hi, char __dfault,
 212             char* __dest) const
 213   {
 214 #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ > 2)
 215     __c_locale __old = __uselocale(_M_c_locale_ctype);
 216 #endif
 217     size_t __offset = 0;
 218     while (true)
 219       {
 220         const wchar_t* __start = __lo + __offset;
 221         size_t __len = __hi - __start;
 222
 223         mbstate_t __state;
 224         memset(static_cast<void*>(&__state), 0, sizeof(mbstate_t));
 225         size_t __con = wcsrtombs(__dest + __offset, &__start, __len, &__state);
 226         if (__con != __len && __start != 0)
 227           {
 228             __offset = __start - __lo;
 229             __dest[__offset++] = __dfault;
 230           }
 231         else
 232           break;
 233       }
 234 #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ > 2)
 235     __uselocale(__old);
 236 #endif
 237     return __hi;
 238   }
 239 #endif //  _GLIBCPP_USE_WCHAR_T
 240 }