ctype_noninline.h

Go to the documentation of this file.
00001 // Locale support -*- C++ -*-
00002 
00003 // Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
00004 // 2006, 2007, 2009
00005 // Free Software Foundation, Inc.
00006 //
00007 // This file is part of the GNU ISO C++ Library.  This library is free
00008 // software; you can redistribute it and/or modify it under the
00009 // terms of the GNU General Public License as published by the
00010 // Free Software Foundation; either version 3, or (at your option)
00011 // any later version.
00012 
00013 // This library is distributed in the hope that it will be useful,
00014 // but WITHOUT ANY WARRANTY; without even the implied warranty of
00015 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00016 // GNU General Public License for more details.
00017 
00018 // Under Section 7 of GPL version 3, you are granted additional
00019 // permissions described in the GCC Runtime Library Exception, version
00020 // 3.1, as published by the Free Software Foundation.
00021 
00022 // You should have received a copy of the GNU General Public License and
00023 // a copy of the GCC Runtime Library Exception along with this program;
00024 // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
00025 // <http://www.gnu.org/licenses/>.
00026 
00027 /** @file ctype_noninline.h
00028  *  This is an internal header file, included by other library headers.
00029  *  You should not attempt to use it directly.
00030  */
00031 
00032 //
00033 // ISO C++ 14882: 22.1  Locales
00034 //
00035   
00036 // Information as gleaned from /usr/include/ctype.h
00037 
00038 #if _GLIBCXX_C_LOCALE_GNU
00039   const ctype_base::mask*
00040   ctype<char>::classic_table() throw()
00041   { return _S_get_c_locale()->__ctype_b; }
00042 #else
00043   const ctype_base::mask*
00044   ctype<char>::classic_table() throw()
00045   {
00046     const ctype_base::mask* __ret;
00047     char* __old = setlocale(LC_CTYPE, NULL);
00048     char* __sav = NULL;
00049     if (__builtin_strcmp(__old, "C"))
00050       {
00051     const size_t __len = __builtin_strlen(__old) + 1;
00052     __sav = new char[__len];
00053     __builtin_memcpy(__sav, __old, __len);
00054     setlocale(LC_CTYPE, "C");
00055       }
00056 #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ > 2)
00057     __ret = *__ctype_b_loc();
00058 #else
00059     __ret = __ctype_b;
00060 #endif
00061     if (__sav)
00062       {
00063     setlocale(LC_CTYPE, __sav);
00064     delete [] __sav;
00065       }
00066     return __ret;
00067   }
00068 #endif
00069 
00070 #if _GLIBCXX_C_LOCALE_GNU
00071   ctype<char>::ctype(__c_locale __cloc, const mask* __table, bool __del, 
00072              size_t __refs) 
00073   : facet(__refs), _M_c_locale_ctype(_S_clone_c_locale(__cloc)), 
00074   _M_del(__table != 0 && __del), 
00075   _M_toupper(_M_c_locale_ctype->__ctype_toupper),  
00076   _M_tolower(_M_c_locale_ctype->__ctype_tolower), 
00077   _M_table(__table ? __table : _M_c_locale_ctype->__ctype_b), 
00078   _M_widen_ok(0), _M_narrow_ok(0) 
00079   {
00080     __builtin_memset(_M_widen, 0, sizeof(_M_widen));
00081     __builtin_memset(_M_narrow, 0, sizeof(_M_narrow));
00082   }
00083 #else
00084   ctype<char>::ctype(__c_locale, const mask* __table, bool __del, 
00085              size_t __refs) 
00086   : facet(__refs), _M_c_locale_ctype(_S_get_c_locale()), 
00087   _M_del(__table != 0 && __del), _M_widen_ok(0), _M_narrow_ok(0)
00088   {
00089     char* __old = setlocale(LC_CTYPE, NULL);
00090     char* __sav = NULL;
00091     if (__builtin_strcmp(__old, "C"))
00092       {    
00093     const size_t __len = __builtin_strlen(__old) + 1;
00094     __sav = new char[__len];
00095     __builtin_memcpy(__sav, __old, __len);    
00096     setlocale(LC_CTYPE, "C");
00097       }
00098 #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ > 2)
00099     _M_toupper = *__ctype_toupper_loc();
00100     _M_tolower = *__ctype_tolower_loc();
00101     _M_table = __table ? __table : *__ctype_b_loc();
00102 #else
00103     _M_toupper = __ctype_toupper;
00104     _M_tolower = __ctype_tolower;
00105     _M_table = __table ? __table : __ctype_b;
00106 #endif
00107     if (__sav)
00108       {
00109     setlocale(LC_CTYPE, __sav);
00110     delete [] __sav;
00111       }
00112     __builtin_memset(_M_widen, 0, sizeof(_M_widen));
00113     __builtin_memset(_M_narrow, 0, sizeof(_M_narrow));
00114   }
00115 #endif
00116 
00117 #if _GLIBCXX_C_LOCALE_GNU
00118   ctype<char>::ctype(const mask* __table, bool __del, size_t __refs) 
00119   : facet(__refs), _M_c_locale_ctype(_S_get_c_locale()), 
00120   _M_del(__table != 0 && __del),
00121   _M_toupper(_M_c_locale_ctype->__ctype_toupper),  
00122   _M_tolower(_M_c_locale_ctype->__ctype_tolower), 
00123   _M_table(__table ? __table : _M_c_locale_ctype->__ctype_b), 
00124   _M_widen_ok(0), _M_narrow_ok(0) 
00125   {
00126     __builtin_memset(_M_widen, 0, sizeof(_M_widen));
00127     __builtin_memset(_M_narrow, 0, sizeof(_M_narrow));
00128   }
00129 #else
00130   ctype<char>::ctype(const mask* __table, bool __del, size_t __refs)
00131   : facet(__refs), _M_c_locale_ctype(_S_get_c_locale()), 
00132   _M_del(__table != 0 && __del), _M_widen_ok(0), _M_narrow_ok(0)
00133   {
00134     char* __old = setlocale(LC_CTYPE, NULL);
00135     char* __sav = NULL;
00136     if (__builtin_strcmp(__old, "C"))
00137       {
00138     const size_t __len = __builtin_strlen(__old) + 1;
00139     __sav = new char[__len];
00140     __builtin_memcpy(__sav, __old, __len);
00141     setlocale(LC_CTYPE, "C");
00142       }
00143 #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ > 2)
00144     _M_toupper = *__ctype_toupper_loc();
00145     _M_tolower = *__ctype_tolower_loc();
00146     _M_table = __table ? __table : *__ctype_b_loc();
00147 #else
00148     _M_toupper = __ctype_toupper;
00149     _M_tolower = __ctype_tolower;
00150     _M_table = __table ? __table : __ctype_b;
00151 #endif
00152     if (__sav)
00153       {
00154     setlocale(LC_CTYPE, __sav);
00155     delete [] __sav;
00156       }
00157     __builtin_memset(_M_widen, 0, sizeof(_M_widen));
00158     __builtin_memset(_M_narrow, 0, sizeof(_M_narrow));
00159   }
00160 #endif
00161 
00162   char
00163   ctype<char>::do_toupper(char __c) const
00164   { return _M_toupper[static_cast<unsigned char>(__c)]; }
00165 
00166   const char*
00167   ctype<char>::do_toupper(char* __low, const char* __high) const
00168   {
00169     while (__low < __high)
00170       {
00171     *__low = _M_toupper[static_cast<unsigned char>(*__low)];
00172     ++__low;
00173       }
00174     return __high;
00175   }
00176 
00177   char
00178   ctype<char>::do_tolower(char __c) const
00179   { return _M_tolower[static_cast<unsigned char>(__c)]; }
00180 
00181   const char* 
00182   ctype<char>::do_tolower(char* __low, const char* __high) const
00183   {
00184     while (__low < __high)
00185       {
00186     *__low = _M_tolower[static_cast<unsigned char>(*__low)];
00187     ++__low;
00188       }
00189     return __high;
00190   }

Generated on Thu Jul 23 21:16:02 2009 for libstdc++ by  doxygen 1.5.8