libstdc++
|
00001 // Locale support -*- C++ -*- 00002 00003 // Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 00004 // 2006, 2007, 2008, 2009, 2010, 2011 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 bits/locale_facets.h 00028 * This is an internal header file, included by other library headers. 00029 * Do not attempt to use it directly. @headername{locale} 00030 */ 00031 00032 // 00033 // ISO C++ 14882: 22.1 Locales 00034 // 00035 00036 #ifndef _LOCALE_FACETS_H 00037 #define _LOCALE_FACETS_H 1 00038 00039 #pragma GCC system_header 00040 00041 #include <cwctype> // For wctype_t 00042 #include <cctype> 00043 #include <bits/ctype_base.h> 00044 #include <iosfwd> 00045 #include <bits/ios_base.h> // For ios_base, ios_base::iostate 00046 #include <streambuf> 00047 #include <bits/cpp_type_traits.h> 00048 #include <ext/type_traits.h> 00049 #include <ext/numeric_traits.h> 00050 #include <bits/streambuf_iterator.h> 00051 00052 namespace std _GLIBCXX_VISIBILITY(default) 00053 { 00054 _GLIBCXX_BEGIN_NAMESPACE_VERSION 00055 00056 // NB: Don't instantiate required wchar_t facets if no wchar_t support. 00057 #ifdef _GLIBCXX_USE_WCHAR_T 00058 # define _GLIBCXX_NUM_FACETS 28 00059 #else 00060 # define _GLIBCXX_NUM_FACETS 14 00061 #endif 00062 00063 // Convert string to numeric value of type _Tp and store results. 00064 // NB: This is specialized for all required types, there is no 00065 // generic definition. 00066 template<typename _Tp> 00067 void 00068 __convert_to_v(const char*, _Tp&, ios_base::iostate&, 00069 const __c_locale&) throw(); 00070 00071 // Explicit specializations for required types. 00072 template<> 00073 void 00074 __convert_to_v(const char*, float&, ios_base::iostate&, 00075 const __c_locale&) throw(); 00076 00077 template<> 00078 void 00079 __convert_to_v(const char*, double&, ios_base::iostate&, 00080 const __c_locale&) throw(); 00081 00082 template<> 00083 void 00084 __convert_to_v(const char*, long double&, ios_base::iostate&, 00085 const __c_locale&) throw(); 00086 00087 // NB: __pad is a struct, rather than a function, so it can be 00088 // partially-specialized. 00089 template<typename _CharT, typename _Traits> 00090 struct __pad 00091 { 00092 static void 00093 _S_pad(ios_base& __io, _CharT __fill, _CharT* __news, 00094 const _CharT* __olds, streamsize __newlen, streamsize __oldlen); 00095 }; 00096 00097 // Used by both numeric and monetary facets. 00098 // Inserts "group separator" characters into an array of characters. 00099 // It's recursive, one iteration per group. It moves the characters 00100 // in the buffer this way: "xxxx12345" -> "12,345xxx". Call this 00101 // only with __gsize != 0. 00102 template<typename _CharT> 00103 _CharT* 00104 __add_grouping(_CharT* __s, _CharT __sep, 00105 const char* __gbeg, size_t __gsize, 00106 const _CharT* __first, const _CharT* __last); 00107 00108 // This template permits specializing facet output code for 00109 // ostreambuf_iterator. For ostreambuf_iterator, sputn is 00110 // significantly more efficient than incrementing iterators. 00111 template<typename _CharT> 00112 inline 00113 ostreambuf_iterator<_CharT> 00114 __write(ostreambuf_iterator<_CharT> __s, const _CharT* __ws, int __len) 00115 { 00116 __s._M_put(__ws, __len); 00117 return __s; 00118 } 00119 00120 // This is the unspecialized form of the template. 00121 template<typename _CharT, typename _OutIter> 00122 inline 00123 _OutIter 00124 __write(_OutIter __s, const _CharT* __ws, int __len) 00125 { 00126 for (int __j = 0; __j < __len; __j++, ++__s) 00127 *__s = __ws[__j]; 00128 return __s; 00129 } 00130 00131 00132 // 22.2.1.1 Template class ctype 00133 // Include host and configuration specific ctype enums for ctype_base. 00134 00135 /** 00136 * @brief Common base for ctype facet 00137 * 00138 * This template class provides implementations of the public functions 00139 * that forward to the protected virtual functions. 00140 * 00141 * This template also provides abstract stubs for the protected virtual 00142 * functions. 00143 */ 00144 template<typename _CharT> 00145 class __ctype_abstract_base : public locale::facet, public ctype_base 00146 { 00147 public: 00148 // Types: 00149 /// Typedef for the template parameter 00150 typedef _CharT char_type; 00151 00152 /** 00153 * @brief Test char_type classification. 00154 * 00155 * This function finds a mask M for @a __c and compares it to 00156 * mask @a __m. It does so by returning the value of 00157 * ctype<char_type>::do_is(). 00158 * 00159 * @param __c The char_type to compare the mask of. 00160 * @param __m The mask to compare against. 00161 * @return (M & __m) != 0. 00162 */ 00163 bool 00164 is(mask __m, char_type __c) const 00165 { return this->do_is(__m, __c); } 00166 00167 /** 00168 * @brief Return a mask array. 00169 * 00170 * This function finds the mask for each char_type in the range [lo,hi) 00171 * and successively writes it to vec. vec must have as many elements 00172 * as the char array. It does so by returning the value of 00173 * ctype<char_type>::do_is(). 00174 * 00175 * @param __lo Pointer to start of range. 00176 * @param __hi Pointer to end of range. 00177 * @param __vec Pointer to an array of mask storage. 00178 * @return @a __hi. 00179 */ 00180 const char_type* 00181 is(const char_type *__lo, const char_type *__hi, mask *__vec) const 00182 { return this->do_is(__lo, __hi, __vec); } 00183 00184 /** 00185 * @brief Find char_type matching a mask 00186 * 00187 * This function searches for and returns the first char_type c in 00188 * [lo,hi) for which is(m,c) is true. It does so by returning 00189 * ctype<char_type>::do_scan_is(). 00190 * 00191 * @param __m The mask to compare against. 00192 * @param __lo Pointer to start of range. 00193 * @param __hi Pointer to end of range. 00194 * @return Pointer to matching char_type if found, else @a __hi. 00195 */ 00196 const char_type* 00197 scan_is(mask __m, const char_type* __lo, const char_type* __hi) const 00198 { return this->do_scan_is(__m, __lo, __hi); } 00199 00200 /** 00201 * @brief Find char_type not matching a mask 00202 * 00203 * This function searches for and returns the first char_type c in 00204 * [lo,hi) for which is(m,c) is false. It does so by returning 00205 * ctype<char_type>::do_scan_not(). 00206 * 00207 * @param __m The mask to compare against. 00208 * @param __lo Pointer to first char in range. 00209 * @param __hi Pointer to end of range. 00210 * @return Pointer to non-matching char if found, else @a __hi. 00211 */ 00212 const char_type* 00213 scan_not(mask __m, const char_type* __lo, const char_type* __hi) const 00214 { return this->do_scan_not(__m, __lo, __hi); } 00215 00216 /** 00217 * @brief Convert to uppercase. 00218 * 00219 * This function converts the argument to uppercase if possible. 00220 * If not possible (for example, '2'), returns the argument. It does 00221 * so by returning ctype<char_type>::do_toupper(). 00222 * 00223 * @param __c The char_type to convert. 00224 * @return The uppercase char_type if convertible, else @a __c. 00225 */ 00226 char_type 00227 toupper(char_type __c) const 00228 { return this->do_toupper(__c); } 00229 00230 /** 00231 * @brief Convert array to uppercase. 00232 * 00233 * This function converts each char_type in the range [lo,hi) to 00234 * uppercase if possible. Other elements remain untouched. It does so 00235 * by returning ctype<char_type>:: do_toupper(lo, hi). 00236 * 00237 * @param __lo Pointer to start of range. 00238 * @param __hi Pointer to end of range. 00239 * @return @a __hi. 00240 */ 00241 const char_type* 00242 toupper(char_type *__lo, const char_type* __hi) const 00243 { return this->do_toupper(__lo, __hi); } 00244 00245 /** 00246 * @brief Convert to lowercase. 00247 * 00248 * This function converts the argument to lowercase if possible. If 00249 * not possible (for example, '2'), returns the argument. It does so 00250 * by returning ctype<char_type>::do_tolower(c). 00251 * 00252 * @param __c The char_type to convert. 00253 * @return The lowercase char_type if convertible, else @a __c. 00254 */ 00255 char_type 00256 tolower(char_type __c) const 00257 { return this->do_tolower(__c); } 00258 00259 /** 00260 * @brief Convert array to lowercase. 00261 * 00262 * This function converts each char_type in the range [__lo,__hi) to 00263 * lowercase if possible. Other elements remain untouched. It does so 00264 * by returning ctype<char_type>:: do_tolower(__lo, __hi). 00265 * 00266 * @param __lo Pointer to start of range. 00267 * @param __hi Pointer to end of range. 00268 * @return @a __hi. 00269 */ 00270 const char_type* 00271 tolower(char_type* __lo, const char_type* __hi) const 00272 { return this->do_tolower(__lo, __hi); } 00273 00274 /** 00275 * @brief Widen char to char_type 00276 * 00277 * This function converts the char argument to char_type using the 00278 * simplest reasonable transformation. It does so by returning 00279 * ctype<char_type>::do_widen(c). 00280 * 00281 * Note: this is not what you want for codepage conversions. See 00282 * codecvt for that. 00283 * 00284 * @param __c The char to convert. 00285 * @return The converted char_type. 00286 */ 00287 char_type 00288 widen(char __c) const 00289 { return this->do_widen(__c); } 00290 00291 /** 00292 * @brief Widen array to char_type 00293 * 00294 * This function converts each char in the input to char_type using the 00295 * simplest reasonable transformation. It does so by returning 00296 * ctype<char_type>::do_widen(c). 00297 * 00298 * Note: this is not what you want for codepage conversions. See 00299 * codecvt for that. 00300 * 00301 * @param __lo Pointer to start of range. 00302 * @param __hi Pointer to end of range. 00303 * @param __to Pointer to the destination array. 00304 * @return @a __hi. 00305 */ 00306 const char* 00307 widen(const char* __lo, const char* __hi, char_type* __to) const 00308 { return this->do_widen(__lo, __hi, __to); } 00309 00310 /** 00311 * @brief Narrow char_type to char 00312 * 00313 * This function converts the char_type to char using the simplest 00314 * reasonable transformation. If the conversion fails, dfault is 00315 * returned instead. It does so by returning 00316 * ctype<char_type>::do_narrow(__c). 00317 * 00318 * Note: this is not what you want for codepage conversions. See 00319 * codecvt for that. 00320 * 00321 * @param __c The char_type to convert. 00322 * @param __dfault Char to return if conversion fails. 00323 * @return The converted char. 00324 */ 00325 char 00326 narrow(char_type __c, char __dfault) const 00327 { return this->do_narrow(__c, __dfault); } 00328 00329 /** 00330 * @brief Narrow array to char array 00331 * 00332 * This function converts each char_type in the input to char using the 00333 * simplest reasonable transformation and writes the results to the 00334 * destination array. For any char_type in the input that cannot be 00335 * converted, @a dfault is used instead. It does so by returning 00336 * ctype<char_type>::do_narrow(__lo, __hi, __dfault, __to). 00337 * 00338 * Note: this is not what you want for codepage conversions. See 00339 * codecvt for that. 00340 * 00341 * @param __lo Pointer to start of range. 00342 * @param __hi Pointer to end of range. 00343 * @param __dfault Char to use if conversion fails. 00344 * @param __to Pointer to the destination array. 00345 * @return @a __hi. 00346 */ 00347 const char_type* 00348 narrow(const char_type* __lo, const char_type* __hi, 00349 char __dfault, char* __to) const 00350 { return this->do_narrow(__lo, __hi, __dfault, __to); } 00351 00352 protected: 00353 explicit 00354 __ctype_abstract_base(size_t __refs = 0): facet(__refs) { } 00355 00356 virtual 00357 ~__ctype_abstract_base() { } 00358 00359 /** 00360 * @brief Test char_type classification. 00361 * 00362 * This function finds a mask M for @a c and compares it to mask @a m. 00363 * 00364 * do_is() is a hook for a derived facet to change the behavior of 00365 * classifying. do_is() must always return the same result for the 00366 * same input. 00367 * 00368 * @param __c The char_type to find the mask of. 00369 * @param __m The mask to compare against. 00370 * @return (M & __m) != 0. 00371 */ 00372 virtual bool 00373 do_is(mask __m, char_type __c) const = 0; 00374 00375 /** 00376 * @brief Return a mask array. 00377 * 00378 * This function finds the mask for each char_type in the range [lo,hi) 00379 * and successively writes it to vec. vec must have as many elements 00380 * as the input. 00381 * 00382 * do_is() is a hook for a derived facet to change the behavior of 00383 * classifying. do_is() must always return the same result for the 00384 * same input. 00385 * 00386 * @param __lo Pointer to start of range. 00387 * @param __hi Pointer to end of range. 00388 * @param __vec Pointer to an array of mask storage. 00389 * @return @a __hi. 00390 */ 00391 virtual const char_type* 00392 do_is(const char_type* __lo, const char_type* __hi, 00393 mask* __vec) const = 0; 00394 00395 /** 00396 * @brief Find char_type matching mask 00397 * 00398 * This function searches for and returns the first char_type c in 00399 * [__lo,__hi) for which is(__m,c) is true. 00400 * 00401 * do_scan_is() is a hook for a derived facet to change the behavior of 00402 * match searching. do_is() must always return the same result for the 00403 * same input. 00404 * 00405 * @param __m The mask to compare against. 00406 * @param __lo Pointer to start of range. 00407 * @param __hi Pointer to end of range. 00408 * @return Pointer to a matching char_type if found, else @a __hi. 00409 */ 00410 virtual const char_type* 00411 do_scan_is(mask __m, const char_type* __lo, 00412 const char_type* __hi) const = 0; 00413 00414 /** 00415 * @brief Find char_type not matching mask 00416 * 00417 * This function searches for and returns a pointer to the first 00418 * char_type c of [lo,hi) for which is(m,c) is false. 00419 * 00420 * do_scan_is() is a hook for a derived facet to change the behavior of 00421 * match searching. do_is() must always return the same result for the 00422 * same input. 00423 * 00424 * @param __m The mask to compare against. 00425 * @param __lo Pointer to start of range. 00426 * @param __hi Pointer to end of range. 00427 * @return Pointer to a non-matching char_type if found, else @a __hi. 00428 */ 00429 virtual const char_type* 00430 do_scan_not(mask __m, const char_type* __lo, 00431 const char_type* __hi) const = 0; 00432 00433 /** 00434 * @brief Convert to uppercase. 00435 * 00436 * This virtual function converts the char_type argument to uppercase 00437 * if possible. If not possible (for example, '2'), returns the 00438 * argument. 00439 * 00440 * do_toupper() is a hook for a derived facet to change the behavior of 00441 * uppercasing. do_toupper() must always return the same result for 00442 * the same input. 00443 * 00444 * @param __c The char_type to convert. 00445 * @return The uppercase char_type if convertible, else @a __c. 00446 */ 00447 virtual char_type 00448 do_toupper(char_type __c) const = 0; 00449 00450 /** 00451 * @brief Convert array to uppercase. 00452 * 00453 * This virtual function converts each char_type in the range [__lo,__hi) 00454 * to uppercase if possible. Other elements remain untouched. 00455 * 00456 * do_toupper() is a hook for a derived facet to change the behavior of 00457 * uppercasing. do_toupper() must always return the same result for 00458 * the same input. 00459 * 00460 * @param __lo Pointer to start of range. 00461 * @param __hi Pointer to end of range. 00462 * @return @a __hi. 00463 */ 00464 virtual const char_type* 00465 do_toupper(char_type* __lo, const char_type* __hi) const = 0; 00466 00467 /** 00468 * @brief Convert to lowercase. 00469 * 00470 * This virtual function converts the argument to lowercase if 00471 * possible. If not possible (for example, '2'), returns the argument. 00472 * 00473 * do_tolower() is a hook for a derived facet to change the behavior of 00474 * lowercasing. do_tolower() must always return the same result for 00475 * the same input. 00476 * 00477 * @param __c The char_type to convert. 00478 * @return The lowercase char_type if convertible, else @a __c. 00479 */ 00480 virtual char_type 00481 do_tolower(char_type __c) const = 0; 00482 00483 /** 00484 * @brief Convert array to lowercase. 00485 * 00486 * This virtual function converts each char_type in the range [__lo,__hi) 00487 * to lowercase if possible. Other elements remain untouched. 00488 * 00489 * do_tolower() is a hook for a derived facet to change the behavior of 00490 * lowercasing. do_tolower() must always return the same result for 00491 * the same input. 00492 * 00493 * @param __lo Pointer to start of range. 00494 * @param __hi Pointer to end of range. 00495 * @return @a __hi. 00496 */ 00497 virtual const char_type* 00498 do_tolower(char_type* __lo, const char_type* __hi) const = 0; 00499 00500 /** 00501 * @brief Widen char 00502 * 00503 * This virtual function converts the char to char_type using the 00504 * simplest reasonable transformation. 00505 * 00506 * do_widen() is a hook for a derived facet to change the behavior of 00507 * widening. do_widen() must always return the same result for the 00508 * same input. 00509 * 00510 * Note: this is not what you want for codepage conversions. See 00511 * codecvt for that. 00512 * 00513 * @param __c The char to convert. 00514 * @return The converted char_type 00515 */ 00516 virtual char_type 00517 do_widen(char __c) const = 0; 00518 00519 /** 00520 * @brief Widen char array 00521 * 00522 * This function converts each char in the input to char_type using the 00523 * simplest reasonable transformation. 00524 * 00525 * do_widen() is a hook for a derived facet to change the behavior of 00526 * widening. do_widen() must always return the same result for the 00527 * same input. 00528 * 00529 * Note: this is not what you want for codepage conversions. See 00530 * codecvt for that. 00531 * 00532 * @param __lo Pointer to start range. 00533 * @param __hi Pointer to end of range. 00534 * @param __to Pointer to the destination array. 00535 * @return @a __hi. 00536 */ 00537 virtual const char* 00538 do_widen(const char* __lo, const char* __hi, char_type* __to) const = 0; 00539 00540 /** 00541 * @brief Narrow char_type to char 00542 * 00543 * This virtual function converts the argument to char using the 00544 * simplest reasonable transformation. If the conversion fails, dfault 00545 * is returned instead. 00546 * 00547 * do_narrow() is a hook for a derived facet to change the behavior of 00548 * narrowing. do_narrow() must always return the same result for the 00549 * same input. 00550 * 00551 * Note: this is not what you want for codepage conversions. See 00552 * codecvt for that. 00553 * 00554 * @param __c The char_type to convert. 00555 * @param __dfault Char to return if conversion fails. 00556 * @return The converted char. 00557 */ 00558 virtual char 00559 do_narrow(char_type __c, char __dfault) const = 0; 00560 00561 /** 00562 * @brief Narrow char_type array to char 00563 * 00564 * This virtual function converts each char_type in the range 00565 * [__lo,__hi) to char using the simplest reasonable 00566 * transformation and writes the results to the destination 00567 * array. For any element in the input that cannot be 00568 * converted, @a __dfault is used instead. 00569 * 00570 * do_narrow() is a hook for a derived facet to change the behavior of 00571 * narrowing. do_narrow() must always return the same result for the 00572 * same input. 00573 * 00574 * Note: this is not what you want for codepage conversions. See 00575 * codecvt for that. 00576 * 00577 * @param __lo Pointer to start of range. 00578 * @param __hi Pointer to end of range. 00579 * @param __dfault Char to use if conversion fails. 00580 * @param __to Pointer to the destination array. 00581 * @return @a __hi. 00582 */ 00583 virtual const char_type* 00584 do_narrow(const char_type* __lo, const char_type* __hi, 00585 char __dfault, char* __to) const = 0; 00586 }; 00587 00588 /** 00589 * @brief Primary class template ctype facet. 00590 * @ingroup locales 00591 * 00592 * This template class defines classification and conversion functions for 00593 * character sets. It wraps cctype functionality. Ctype gets used by 00594 * streams for many I/O operations. 00595 * 00596 * This template provides the protected virtual functions the developer 00597 * will have to replace in a derived class or specialization to make a 00598 * working facet. The public functions that access them are defined in 00599 * __ctype_abstract_base, to allow for implementation flexibility. See 00600 * ctype<wchar_t> for an example. The functions are documented in 00601 * __ctype_abstract_base. 00602 * 00603 * Note: implementations are provided for all the protected virtual 00604 * functions, but will likely not be useful. 00605 */ 00606 template<typename _CharT> 00607 class ctype : public __ctype_abstract_base<_CharT> 00608 { 00609 public: 00610 // Types: 00611 typedef _CharT char_type; 00612 typedef typename __ctype_abstract_base<_CharT>::mask mask; 00613 00614 /// The facet id for ctype<char_type> 00615 static locale::id id; 00616 00617 explicit 00618 ctype(size_t __refs = 0) : __ctype_abstract_base<_CharT>(__refs) { } 00619 00620 protected: 00621 virtual 00622 ~ctype(); 00623 00624 virtual bool 00625 do_is(mask __m, char_type __c) const; 00626 00627 virtual const char_type* 00628 do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const; 00629 00630 virtual const char_type* 00631 do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const; 00632 00633 virtual const char_type* 00634 do_scan_not(mask __m, const char_type* __lo, 00635 const char_type* __hi) const; 00636 00637 virtual char_type 00638 do_toupper(char_type __c) const; 00639 00640 virtual const char_type* 00641 do_toupper(char_type* __lo, const char_type* __hi) const; 00642 00643 virtual char_type 00644 do_tolower(char_type __c) const; 00645 00646 virtual const char_type* 00647 do_tolower(char_type* __lo, const char_type* __hi) const; 00648 00649 virtual char_type 00650 do_widen(char __c) const; 00651 00652 virtual const char* 00653 do_widen(const char* __lo, const char* __hi, char_type* __dest) const; 00654 00655 virtual char 00656 do_narrow(char_type, char __dfault) const; 00657 00658 virtual const char_type* 00659 do_narrow(const char_type* __lo, const char_type* __hi, 00660 char __dfault, char* __to) const; 00661 }; 00662 00663 template<typename _CharT> 00664 locale::id ctype<_CharT>::id; 00665 00666 /** 00667 * @brief The ctype<char> specialization. 00668 * @ingroup locales 00669 * 00670 * This class defines classification and conversion functions for 00671 * the char type. It gets used by char streams for many I/O 00672 * operations. The char specialization provides a number of 00673 * optimizations as well. 00674 */ 00675 template<> 00676 class ctype<char> : public locale::facet, public ctype_base 00677 { 00678 public: 00679 // Types: 00680 /// Typedef for the template parameter char. 00681 typedef char char_type; 00682 00683 protected: 00684 // Data Members: 00685 __c_locale _M_c_locale_ctype; 00686 bool _M_del; 00687 __to_type _M_toupper; 00688 __to_type _M_tolower; 00689 const mask* _M_table; 00690 mutable char _M_widen_ok; 00691 mutable char _M_widen[1 + static_cast<unsigned char>(-1)]; 00692 mutable char _M_narrow[1 + static_cast<unsigned char>(-1)]; 00693 mutable char _M_narrow_ok; // 0 uninitialized, 1 init, 00694 // 2 memcpy can't be used 00695 00696 public: 00697 /// The facet id for ctype<char> 00698 static locale::id id; 00699 /// The size of the mask table. It is SCHAR_MAX + 1. 00700 static const size_t table_size = 1 + static_cast<unsigned char>(-1); 00701 00702 /** 00703 * @brief Constructor performs initialization. 00704 * 00705 * This is the constructor provided by the standard. 00706 * 00707 * @param __table If non-zero, table is used as the per-char mask. 00708 * Else classic_table() is used. 00709 * @param __del If true, passes ownership of table to this facet. 00710 * @param __refs Passed to the base facet class. 00711 */ 00712 explicit 00713 ctype(const mask* __table = 0, bool __del = false, size_t __refs = 0); 00714 00715 /** 00716 * @brief Constructor performs static initialization. 00717 * 00718 * This constructor is used to construct the initial C locale facet. 00719 * 00720 * @param __cloc Handle to C locale data. 00721 * @param __table If non-zero, table is used as the per-char mask. 00722 * @param __del If true, passes ownership of table to this facet. 00723 * @param __refs Passed to the base facet class. 00724 */ 00725 explicit 00726 ctype(__c_locale __cloc, const mask* __table = 0, bool __del = false, 00727 size_t __refs = 0); 00728 00729 /** 00730 * @brief Test char classification. 00731 * 00732 * This function compares the mask table[c] to @a __m. 00733 * 00734 * @param __c The char to compare the mask of. 00735 * @param __m The mask to compare against. 00736 * @return True if __m & table[__c] is true, false otherwise. 00737 */ 00738 inline bool 00739 is(mask __m, char __c) const; 00740 00741 /** 00742 * @brief Return a mask array. 00743 * 00744 * This function finds the mask for each char in the range [lo, hi) and 00745 * successively writes it to vec. vec must have as many elements as 00746 * the char array. 00747 * 00748 * @param __lo Pointer to start of range. 00749 * @param __hi Pointer to end of range. 00750 * @param __vec Pointer to an array of mask storage. 00751 * @return @a __hi. 00752 */ 00753 inline const char* 00754 is(const char* __lo, const char* __hi, mask* __vec) const; 00755 00756 /** 00757 * @brief Find char matching a mask 00758 * 00759 * This function searches for and returns the first char in [lo,hi) for 00760 * which is(m,char) is true. 00761 * 00762 * @param __m The mask to compare against. 00763 * @param __lo Pointer to start of range. 00764 * @param __hi Pointer to end of range. 00765 * @return Pointer to a matching char if found, else @a __hi. 00766 */ 00767 inline const char* 00768 scan_is(mask __m, const char* __lo, const char* __hi) const; 00769 00770 /** 00771 * @brief Find char not matching a mask 00772 * 00773 * This function searches for and returns a pointer to the first char 00774 * in [__lo,__hi) for which is(m,char) is false. 00775 * 00776 * @param __m The mask to compare against. 00777 * @param __lo Pointer to start of range. 00778 * @param __hi Pointer to end of range. 00779 * @return Pointer to a non-matching char if found, else @a __hi. 00780 */ 00781 inline const char* 00782 scan_not(mask __m, const char* __lo, const char* __hi) const; 00783 00784 /** 00785 * @brief Convert to uppercase. 00786 * 00787 * This function converts the char argument to uppercase if possible. 00788 * If not possible (for example, '2'), returns the argument. 00789 * 00790 * toupper() acts as if it returns ctype<char>::do_toupper(c). 00791 * do_toupper() must always return the same result for the same input. 00792 * 00793 * @param __c The char to convert. 00794 * @return The uppercase char if convertible, else @a __c. 00795 */ 00796 char_type 00797 toupper(char_type __c) const 00798 { return this->do_toupper(__c); } 00799 00800 /** 00801 * @brief Convert array to uppercase. 00802 * 00803 * This function converts each char in the range [__lo,__hi) to uppercase 00804 * if possible. Other chars remain untouched. 00805 * 00806 * toupper() acts as if it returns ctype<char>:: do_toupper(__lo, __hi). 00807 * do_toupper() must always return the same result for the same input. 00808 * 00809 * @param __lo Pointer to first char in range. 00810 * @param __hi Pointer to end of range. 00811 * @return @a __hi. 00812 */ 00813 const char_type* 00814 toupper(char_type *__lo, const char_type* __hi) const 00815 { return this->do_toupper(__lo, __hi); } 00816 00817 /** 00818 * @brief Convert to lowercase. 00819 * 00820 * This function converts the char argument to lowercase if possible. 00821 * If not possible (for example, '2'), returns the argument. 00822 * 00823 * tolower() acts as if it returns ctype<char>::do_tolower(__c). 00824 * do_tolower() must always return the same result for the same input. 00825 * 00826 * @param __c The char to convert. 00827 * @return The lowercase char if convertible, else @a __c. 00828 */ 00829 char_type 00830 tolower(char_type __c) const 00831 { return this->do_tolower(__c); } 00832 00833 /** 00834 * @brief Convert array to lowercase. 00835 * 00836 * This function converts each char in the range [lo,hi) to lowercase 00837 * if possible. Other chars remain untouched. 00838 * 00839 * tolower() acts as if it returns ctype<char>:: do_tolower(__lo, __hi). 00840 * do_tolower() must always return the same result for the same input. 00841 * 00842 * @param __lo Pointer to first char in range. 00843 * @param __hi Pointer to end of range. 00844 * @return @a __hi. 00845 */ 00846 const char_type* 00847 tolower(char_type* __lo, const char_type* __hi) const 00848 { return this->do_tolower(__lo, __hi); } 00849 00850 /** 00851 * @brief Widen char 00852 * 00853 * This function converts the char to char_type using the simplest 00854 * reasonable transformation. For an underived ctype<char> facet, the 00855 * argument will be returned unchanged. 00856 * 00857 * This function works as if it returns ctype<char>::do_widen(c). 00858 * do_widen() must always return the same result for the same input. 00859 * 00860 * Note: this is not what you want for codepage conversions. See 00861 * codecvt for that. 00862 * 00863 * @param __c The char to convert. 00864 * @return The converted character. 00865 */ 00866 char_type 00867 widen(char __c) const 00868 { 00869 if (_M_widen_ok) 00870 return _M_widen[static_cast<unsigned char>(__c)]; 00871 this->_M_widen_init(); 00872 return this->do_widen(__c); 00873 } 00874 00875 /** 00876 * @brief Widen char array 00877 * 00878 * This function converts each char in the input to char using the 00879 * simplest reasonable transformation. For an underived ctype<char> 00880 * facet, the argument will be copied unchanged. 00881 * 00882 * This function works as if it returns ctype<char>::do_widen(c). 00883 * do_widen() must always return the same result for the same input. 00884 * 00885 * Note: this is not what you want for codepage conversions. See 00886 * codecvt for that. 00887 * 00888 * @param __lo Pointer to first char in range. 00889 * @param __hi Pointer to end of range. 00890 * @param __to Pointer to the destination array. 00891 * @return @a __hi. 00892 */ 00893 const char* 00894 widen(const char* __lo, const char* __hi, char_type* __to) const 00895 { 00896 if (_M_widen_ok == 1) 00897 { 00898 __builtin_memcpy(__to, __lo, __hi - __lo); 00899 return __hi; 00900 } 00901 if (!_M_widen_ok) 00902 _M_widen_init(); 00903 return this->do_widen(__lo, __hi, __to); 00904 } 00905 00906 /** 00907 * @brief Narrow char 00908 * 00909 * This function converts the char to char using the simplest 00910 * reasonable transformation. If the conversion fails, dfault is 00911 * returned instead. For an underived ctype<char> facet, @a c 00912 * will be returned unchanged. 00913 * 00914 * This function works as if it returns ctype<char>::do_narrow(c). 00915 * do_narrow() must always return the same result for the same input. 00916 * 00917 * Note: this is not what you want for codepage conversions. See 00918 * codecvt for that. 00919 * 00920 * @param __c The char to convert. 00921 * @param __dfault Char to return if conversion fails. 00922 * @return The converted character. 00923 */ 00924 char 00925 narrow(char_type __c, char __dfault) const 00926 { 00927 if (_M_narrow[static_cast<unsigned char>(__c)]) 00928 return _M_narrow[static_cast<unsigned char>(__c)]; 00929 const char __t = do_narrow(__c, __dfault); 00930 if (__t != __dfault) 00931 _M_narrow[static_cast<unsigned char>(__c)] = __t; 00932 return __t; 00933 } 00934 00935 /** 00936 * @brief Narrow char array 00937 * 00938 * This function converts each char in the input to char using the 00939 * simplest reasonable transformation and writes the results to the 00940 * destination array. For any char in the input that cannot be 00941 * converted, @a dfault is used instead. For an underived ctype<char> 00942 * facet, the argument will be copied unchanged. 00943 * 00944 * This function works as if it returns ctype<char>::do_narrow(lo, hi, 00945 * dfault, to). do_narrow() must always return the same result for the 00946 * same input. 00947 * 00948 * Note: this is not what you want for codepage conversions. See 00949 * codecvt for that. 00950 * 00951 * @param __lo Pointer to start of range. 00952 * @param __hi Pointer to end of range. 00953 * @param __dfault Char to use if conversion fails. 00954 * @param __to Pointer to the destination array. 00955 * @return @a __hi. 00956 */ 00957 const char_type* 00958 narrow(const char_type* __lo, const char_type* __hi, 00959 char __dfault, char* __to) const 00960 { 00961 if (__builtin_expect(_M_narrow_ok == 1, true)) 00962 { 00963 __builtin_memcpy(__to, __lo, __hi - __lo); 00964 return __hi; 00965 } 00966 if (!_M_narrow_ok) 00967 _M_narrow_init(); 00968 return this->do_narrow(__lo, __hi, __dfault, __to); 00969 } 00970 00971 // _GLIBCXX_RESOLVE_LIB_DEFECTS 00972 // DR 695. ctype<char>::classic_table() not accessible. 00973 /// Returns a pointer to the mask table provided to the constructor, or 00974 /// the default from classic_table() if none was provided. 00975 const mask* 00976 table() const throw() 00977 { return _M_table; } 00978 00979 /// Returns a pointer to the C locale mask table. 00980 static const mask* 00981 classic_table() throw(); 00982 protected: 00983 00984 /** 00985 * @brief Destructor. 00986 * 00987 * This function deletes table() if @a del was true in the 00988 * constructor. 00989 */ 00990 virtual 00991 ~ctype(); 00992 00993 /** 00994 * @brief Convert to uppercase. 00995 * 00996 * This virtual function converts the char argument to uppercase if 00997 * possible. If not possible (for example, '2'), returns the argument. 00998 * 00999 * do_toupper() is a hook for a derived facet to change the behavior of 01000 * uppercasing. do_toupper() must always return the same result for 01001 * the same input. 01002 * 01003 * @param __c The char to convert. 01004 * @return The uppercase char if convertible, else @a __c. 01005 */ 01006 virtual char_type 01007 do_toupper(char_type __c) const; 01008 01009 /** 01010 * @brief Convert array to uppercase. 01011 * 01012 * This virtual function converts each char in the range [lo,hi) to 01013 * uppercase if possible. Other chars remain untouched. 01014 * 01015 * do_toupper() is a hook for a derived facet to change the behavior of 01016 * uppercasing. do_toupper() must always return the same result for 01017 * the same input. 01018 * 01019 * @param __lo Pointer to start of range. 01020 * @param __hi Pointer to end of range. 01021 * @return @a __hi. 01022 */ 01023 virtual const char_type* 01024 do_toupper(char_type* __lo, const char_type* __hi) const; 01025 01026 /** 01027 * @brief Convert to lowercase. 01028 * 01029 * This virtual function converts the char argument to lowercase if 01030 * possible. If not possible (for example, '2'), returns the argument. 01031 * 01032 * do_tolower() is a hook for a derived facet to change the behavior of 01033 * lowercasing. do_tolower() must always return the same result for 01034 * the same input. 01035 * 01036 * @param __c The char to convert. 01037 * @return The lowercase char if convertible, else @a __c. 01038 */ 01039 virtual char_type 01040 do_tolower(char_type __c) const; 01041 01042 /** 01043 * @brief Convert array to lowercase. 01044 * 01045 * This virtual function converts each char in the range [lo,hi) to 01046 * lowercase if possible. Other chars remain untouched. 01047 * 01048 * do_tolower() is a hook for a derived facet to change the behavior of 01049 * lowercasing. do_tolower() must always return the same result for 01050 * the same input. 01051 * 01052 * @param __lo Pointer to first char in range. 01053 * @param __hi Pointer to end of range. 01054 * @return @a __hi. 01055 */ 01056 virtual const char_type* 01057 do_tolower(char_type* __lo, const char_type* __hi) const; 01058 01059 /** 01060 * @brief Widen char 01061 * 01062 * This virtual function converts the char to char using the simplest 01063 * reasonable transformation. For an underived ctype<char> facet, the 01064 * argument will be returned unchanged. 01065 * 01066 * do_widen() is a hook for a derived facet to change the behavior of 01067 * widening. do_widen() must always return the same result for the 01068 * same input. 01069 * 01070 * Note: this is not what you want for codepage conversions. See 01071 * codecvt for that. 01072 * 01073 * @param __c The char to convert. 01074 * @return The converted character. 01075 */ 01076 virtual char_type 01077 do_widen(char __c) const 01078 { return __c; } 01079 01080 /** 01081 * @brief Widen char array 01082 * 01083 * This function converts each char in the range [lo,hi) to char using 01084 * the simplest reasonable transformation. For an underived 01085 * ctype<char> facet, the argument will be copied unchanged. 01086 * 01087 * do_widen() is a hook for a derived facet to change the behavior of 01088 * widening. do_widen() must always return the same result for the 01089 * same input. 01090 * 01091 * Note: this is not what you want for codepage conversions. See 01092 * codecvt for that. 01093 * 01094 * @param __lo Pointer to start of range. 01095 * @param __hi Pointer to end of range. 01096 * @param __to Pointer to the destination array. 01097 * @return @a __hi. 01098 */ 01099 virtual const char* 01100 do_widen(const char* __lo, const char* __hi, char_type* __to) const 01101 { 01102 __builtin_memcpy(__to, __lo, __hi - __lo); 01103 return __hi; 01104 } 01105 01106 /** 01107 * @brief Narrow char 01108 * 01109 * This virtual function converts the char to char using the simplest 01110 * reasonable transformation. If the conversion fails, dfault is 01111 * returned instead. For an underived ctype<char> facet, @a c will be 01112 * returned unchanged. 01113 * 01114 * do_narrow() is a hook for a derived facet to change the behavior of 01115 * narrowing. do_narrow() must always return the same result for the 01116 * same input. 01117 * 01118 * Note: this is not what you want for codepage conversions. See 01119 * codecvt for that. 01120 * 01121 * @param __c The char to convert. 01122 * @param __dfault Char to return if conversion fails. 01123 * @return The converted char. 01124 */ 01125 virtual char 01126 do_narrow(char_type __c, char __dfault) const 01127 { return __c; } 01128 01129 /** 01130 * @brief Narrow char array to char array 01131 * 01132 * This virtual function converts each char in the range [lo,hi) to 01133 * char using the simplest reasonable transformation and writes the 01134 * results to the destination array. For any char in the input that 01135 * cannot be converted, @a dfault is used instead. For an underived 01136 * ctype<char> facet, the argument will be copied unchanged. 01137 * 01138 * do_narrow() is a hook for a derived facet to change the behavior of 01139 * narrowing. do_narrow() must always return the same result for the 01140 * same input. 01141 * 01142 * Note: this is not what you want for codepage conversions. See 01143 * codecvt for that. 01144 * 01145 * @param __lo Pointer to start of range. 01146 * @param __hi Pointer to end of range. 01147 * @param __dfault Char to use if conversion fails. 01148 * @param __to Pointer to the destination array. 01149 * @return @a __hi. 01150 */ 01151 virtual const char_type* 01152 do_narrow(const char_type* __lo, const char_type* __hi, 01153 char __dfault, char* __to) const 01154 { 01155 __builtin_memcpy(__to, __lo, __hi - __lo); 01156 return __hi; 01157 } 01158 01159 private: 01160 void _M_narrow_init() const; 01161 void _M_widen_init() const; 01162 }; 01163 01164 #ifdef _GLIBCXX_USE_WCHAR_T 01165 /** 01166 * @brief The ctype<wchar_t> specialization. 01167 * @ingroup locales 01168 * 01169 * This class defines classification and conversion functions for the 01170 * wchar_t type. It gets used by wchar_t streams for many I/O operations. 01171 * The wchar_t specialization provides a number of optimizations as well. 01172 * 01173 * ctype<wchar_t> inherits its public methods from 01174 * __ctype_abstract_base<wchar_t>. 01175 */ 01176 template<> 01177 class ctype<wchar_t> : public __ctype_abstract_base<wchar_t> 01178 { 01179 public: 01180 // Types: 01181 /// Typedef for the template parameter wchar_t. 01182 typedef wchar_t char_type; 01183 typedef wctype_t __wmask_type; 01184 01185 protected: 01186 __c_locale _M_c_locale_ctype; 01187 01188 // Pre-computed narrowed and widened chars. 01189 bool _M_narrow_ok; 01190 char _M_narrow[128]; 01191 wint_t _M_widen[1 + static_cast<unsigned char>(-1)]; 01192 01193 // Pre-computed elements for do_is. 01194 mask _M_bit[16]; 01195 __wmask_type _M_wmask[16]; 01196 01197 public: 01198 // Data Members: 01199 /// The facet id for ctype<wchar_t> 01200 static locale::id id; 01201 01202 /** 01203 * @brief Constructor performs initialization. 01204 * 01205 * This is the constructor provided by the standard. 01206 * 01207 * @param __refs Passed to the base facet class. 01208 */ 01209 explicit 01210 ctype(size_t __refs = 0); 01211 01212 /** 01213 * @brief Constructor performs static initialization. 01214 * 01215 * This constructor is used to construct the initial C locale facet. 01216 * 01217 * @param __cloc Handle to C locale data. 01218 * @param __refs Passed to the base facet class. 01219 */ 01220 explicit 01221 ctype(__c_locale __cloc, size_t __refs = 0); 01222 01223 protected: 01224 __wmask_type 01225 _M_convert_to_wmask(const mask __m) const throw(); 01226 01227 /// Destructor 01228 virtual 01229 ~ctype(); 01230 01231 /** 01232 * @brief Test wchar_t classification. 01233 * 01234 * This function finds a mask M for @a c and compares it to mask @a m. 01235 * 01236 * do_is() is a hook for a derived facet to change the behavior of 01237 * classifying. do_is() must always return the same result for the 01238 * same input. 01239 * 01240 * @param __c The wchar_t to find the mask of. 01241 * @param __m The mask to compare against. 01242 * @return (M & __m) != 0. 01243 */ 01244 virtual bool 01245 do_is(mask __m, char_type __c) const; 01246 01247 /** 01248 * @brief Return a mask array. 01249 * 01250 * This function finds the mask for each wchar_t in the range [lo,hi) 01251 * and successively writes it to vec. vec must have as many elements 01252 * as the input. 01253 * 01254 * do_is() is a hook for a derived facet to change the behavior of 01255 * classifying. do_is() must always return the same result for the 01256 * same input. 01257 * 01258 * @param __lo Pointer to start of range. 01259 * @param __hi Pointer to end of range. 01260 * @param __vec Pointer to an array of mask storage. 01261 * @return @a __hi. 01262 */ 01263 virtual const char_type* 01264 do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const; 01265 01266 /** 01267 * @brief Find wchar_t matching mask 01268 * 01269 * This function searches for and returns the first wchar_t c in 01270 * [__lo,__hi) for which is(__m,c) is true. 01271 * 01272 * do_scan_is() is a hook for a derived facet to change the behavior of 01273 * match searching. do_is() must always return the same result for the 01274 * same input. 01275 * 01276 * @param __m The mask to compare against. 01277 * @param __lo Pointer to start of range. 01278 * @param __hi Pointer to end of range. 01279 * @return Pointer to a matching wchar_t if found, else @a __hi. 01280 */ 01281 virtual const char_type* 01282 do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const; 01283 01284 /** 01285 * @brief Find wchar_t not matching mask 01286 * 01287 * This function searches for and returns a pointer to the first 01288 * wchar_t c of [__lo,__hi) for which is(__m,c) is false. 01289 * 01290 * do_scan_is() is a hook for a derived facet to change the behavior of 01291 * match searching. do_is() must always return the same result for the 01292 * same input. 01293 * 01294 * @param __m The mask to compare against. 01295 * @param __lo Pointer to start of range. 01296 * @param __hi Pointer to end of range. 01297 * @return Pointer to a non-matching wchar_t if found, else @a __hi. 01298 */ 01299 virtual const char_type* 01300 do_scan_not(mask __m, const char_type* __lo, 01301 const char_type* __hi) const; 01302 01303 /** 01304 * @brief Convert to uppercase. 01305 * 01306 * This virtual function converts the wchar_t argument to uppercase if 01307 * possible. If not possible (for example, '2'), returns the argument. 01308 * 01309 * do_toupper() is a hook for a derived facet to change the behavior of 01310 * uppercasing. do_toupper() must always return the same result for 01311 * the same input. 01312 * 01313 * @param __c The wchar_t to convert. 01314 * @return The uppercase wchar_t if convertible, else @a __c. 01315 */ 01316 virtual char_type 01317 do_toupper(char_type __c) const; 01318 01319 /** 01320 * @brief Convert array to uppercase. 01321 * 01322 * This virtual function converts each wchar_t in the range [lo,hi) to 01323 * uppercase if possible. Other elements remain untouched. 01324 * 01325 * do_toupper() is a hook for a derived facet to change the behavior of 01326 * uppercasing. do_toupper() must always return the same result for 01327 * the same input. 01328 * 01329 * @param __lo Pointer to start of range. 01330 * @param __hi Pointer to end of range. 01331 * @return @a __hi. 01332 */ 01333 virtual const char_type* 01334 do_toupper(char_type* __lo, const char_type* __hi) const; 01335 01336 /** 01337 * @brief Convert to lowercase. 01338 * 01339 * This virtual function converts the argument to lowercase if 01340 * possible. If not possible (for example, '2'), returns the argument. 01341 * 01342 * do_tolower() is a hook for a derived facet to change the behavior of 01343 * lowercasing. do_tolower() must always return the same result for 01344 * the same input. 01345 * 01346 * @param __c The wchar_t to convert. 01347 * @return The lowercase wchar_t if convertible, else @a __c. 01348 */ 01349 virtual char_type 01350 do_tolower(char_type __c) const; 01351 01352 /** 01353 * @brief Convert array to lowercase. 01354 * 01355 * This virtual function converts each wchar_t in the range [lo,hi) to 01356 * lowercase if possible. Other elements remain untouched. 01357 * 01358 * do_tolower() is a hook for a derived facet to change the behavior of 01359 * lowercasing. do_tolower() must always return the same result for 01360 * the same input. 01361 * 01362 * @param __lo Pointer to start of range. 01363 * @param __hi Pointer to end of range. 01364 * @return @a __hi. 01365 */ 01366 virtual const char_type* 01367 do_tolower(char_type* __lo, const char_type* __hi) const; 01368 01369 /** 01370 * @brief Widen char to wchar_t 01371 * 01372 * This virtual function converts the char to wchar_t using the 01373 * simplest reasonable transformation. For an underived ctype<wchar_t> 01374 * facet, the argument will be cast to wchar_t. 01375 * 01376 * do_widen() is a hook for a derived facet to change the behavior of 01377 * widening. do_widen() must always return the same result for the 01378 * same input. 01379 * 01380 * Note: this is not what you want for codepage conversions. See 01381 * codecvt for that. 01382 * 01383 * @param __c The char to convert. 01384 * @return The converted wchar_t. 01385 */ 01386 virtual char_type 01387 do_widen(char __c) const; 01388 01389 /** 01390 * @brief Widen char array to wchar_t array 01391 * 01392 * This function converts each char in the input to wchar_t using the 01393 * simplest reasonable transformation. For an underived ctype<wchar_t> 01394 * facet, the argument will be copied, casting each element to wchar_t. 01395 * 01396 * do_widen() is a hook for a derived facet to change the behavior of 01397 * widening. do_widen() must always return the same result for the 01398 * same input. 01399 * 01400 * Note: this is not what you want for codepage conversions. See 01401 * codecvt for that. 01402 * 01403 * @param __lo Pointer to start range. 01404 * @param __hi Pointer to end of range. 01405 * @param __to Pointer to the destination array. 01406 * @return @a __hi. 01407 */ 01408 virtual const char* 01409 do_widen(const char* __lo, const char* __hi, char_type* __to) const; 01410 01411 /** 01412 * @brief Narrow wchar_t to char 01413 * 01414 * This virtual function converts the argument to char using 01415 * the simplest reasonable transformation. If the conversion 01416 * fails, dfault is returned instead. For an underived 01417 * ctype<wchar_t> facet, @a c will be cast to char and 01418 * returned. 01419 * 01420 * do_narrow() is a hook for a derived facet to change the 01421 * behavior of narrowing. do_narrow() must always return the 01422 * same result for the same input. 01423 * 01424 * Note: this is not what you want for codepage conversions. See 01425 * codecvt for that. 01426 * 01427 * @param __c The wchar_t to convert. 01428 * @param __dfault Char to return if conversion fails. 01429 * @return The converted char. 01430 */ 01431 virtual char 01432 do_narrow(char_type __c, char __dfault) const; 01433 01434 /** 01435 * @brief Narrow wchar_t array to char array 01436 * 01437 * This virtual function converts each wchar_t in the range [lo,hi) to 01438 * char using the simplest reasonable transformation and writes the 01439 * results to the destination array. For any wchar_t in the input that 01440 * cannot be converted, @a dfault is used instead. For an underived 01441 * ctype<wchar_t> facet, the argument will be copied, casting each 01442 * element to char. 01443 * 01444 * do_narrow() is a hook for a derived facet to change the behavior of 01445 * narrowing. do_narrow() must always return the same result for the 01446 * same input. 01447 * 01448 * Note: this is not what you want for codepage conversions. See 01449 * codecvt for that. 01450 * 01451 * @param __lo Pointer to start of range. 01452 * @param __hi Pointer to end of range. 01453 * @param __dfault Char to use if conversion fails. 01454 * @param __to Pointer to the destination array. 01455 * @return @a __hi. 01456 */ 01457 virtual const char_type* 01458 do_narrow(const char_type* __lo, const char_type* __hi, 01459 char __dfault, char* __to) const; 01460 01461 // For use at construction time only. 01462 void 01463 _M_initialize_ctype() throw(); 01464 }; 01465 #endif //_GLIBCXX_USE_WCHAR_T 01466 01467 /// class ctype_byname [22.2.1.2]. 01468 template<typename _CharT> 01469 class ctype_byname : public ctype<_CharT> 01470 { 01471 public: 01472 typedef typename ctype<_CharT>::mask mask; 01473 01474 explicit 01475 ctype_byname(const char* __s, size_t __refs = 0); 01476 01477 protected: 01478 virtual 01479 ~ctype_byname() { }; 01480 }; 01481 01482 /// 22.2.1.4 Class ctype_byname specializations. 01483 template<> 01484 class ctype_byname<char> : public ctype<char> 01485 { 01486 public: 01487 explicit 01488 ctype_byname(const char* __s, size_t __refs = 0); 01489 01490 protected: 01491 virtual 01492 ~ctype_byname(); 01493 }; 01494 01495 #ifdef _GLIBCXX_USE_WCHAR_T 01496 template<> 01497 class ctype_byname<wchar_t> : public ctype<wchar_t> 01498 { 01499 public: 01500 explicit 01501 ctype_byname(const char* __s, size_t __refs = 0); 01502 01503 protected: 01504 virtual 01505 ~ctype_byname(); 01506 }; 01507 #endif 01508 01509 _GLIBCXX_END_NAMESPACE_VERSION 01510 } // namespace 01511 01512 // Include host and configuration specific ctype inlines. 01513 #include <bits/ctype_inline.h> 01514 01515 namespace std _GLIBCXX_VISIBILITY(default) 01516 { 01517 _GLIBCXX_BEGIN_NAMESPACE_VERSION 01518 01519 // 22.2.2 The numeric category. 01520 class __num_base 01521 { 01522 public: 01523 // NB: Code depends on the order of _S_atoms_out elements. 01524 // Below are the indices into _S_atoms_out. 01525 enum 01526 { 01527 _S_ominus, 01528 _S_oplus, 01529 _S_ox, 01530 _S_oX, 01531 _S_odigits, 01532 _S_odigits_end = _S_odigits + 16, 01533 _S_oudigits = _S_odigits_end, 01534 _S_oudigits_end = _S_oudigits + 16, 01535 _S_oe = _S_odigits + 14, // For scientific notation, 'e' 01536 _S_oE = _S_oudigits + 14, // For scientific notation, 'E' 01537 _S_oend = _S_oudigits_end 01538 }; 01539 01540 // A list of valid numeric literals for output. This array 01541 // contains chars that will be passed through the current locale's 01542 // ctype<_CharT>.widen() and then used to render numbers. 01543 // For the standard "C" locale, this is 01544 // "-+xX0123456789abcdef0123456789ABCDEF". 01545 static const char* _S_atoms_out; 01546 01547 // String literal of acceptable (narrow) input, for num_get. 01548 // "-+xX0123456789abcdefABCDEF" 01549 static const char* _S_atoms_in; 01550 01551 enum 01552 { 01553 _S_iminus, 01554 _S_iplus, 01555 _S_ix, 01556 _S_iX, 01557 _S_izero, 01558 _S_ie = _S_izero + 14, 01559 _S_iE = _S_izero + 20, 01560 _S_iend = 26 01561 }; 01562 01563 // num_put 01564 // Construct and return valid scanf format for floating point types. 01565 static void 01566 _S_format_float(const ios_base& __io, char* __fptr, char __mod) throw(); 01567 }; 01568 01569 template<typename _CharT> 01570 struct __numpunct_cache : public locale::facet 01571 { 01572 const char* _M_grouping; 01573 size_t _M_grouping_size; 01574 bool _M_use_grouping; 01575 const _CharT* _M_truename; 01576 size_t _M_truename_size; 01577 const _CharT* _M_falsename; 01578 size_t _M_falsename_size; 01579 _CharT _M_decimal_point; 01580 _CharT _M_thousands_sep; 01581 01582 // A list of valid numeric literals for output: in the standard 01583 // "C" locale, this is "-+xX0123456789abcdef0123456789ABCDEF". 01584 // This array contains the chars after having been passed 01585 // through the current locale's ctype<_CharT>.widen(). 01586 _CharT _M_atoms_out[__num_base::_S_oend]; 01587 01588 // A list of valid numeric literals for input: in the standard 01589 // "C" locale, this is "-+xX0123456789abcdefABCDEF" 01590 // This array contains the chars after having been passed 01591 // through the current locale's ctype<_CharT>.widen(). 01592 _CharT _M_atoms_in[__num_base::_S_iend]; 01593 01594 bool _M_allocated; 01595 01596 __numpunct_cache(size_t __refs = 0) 01597 : facet(__refs), _M_grouping(0), _M_grouping_size(0), 01598 _M_use_grouping(false), 01599 _M_truename(0), _M_truename_size(0), _M_falsename(0), 01600 _M_falsename_size(0), _M_decimal_point(_CharT()), 01601 _M_thousands_sep(_CharT()), _M_allocated(false) 01602 { } 01603 01604 ~__numpunct_cache(); 01605 01606 void 01607 _M_cache(const locale& __loc); 01608 01609 private: 01610 __numpunct_cache& 01611 operator=(const __numpunct_cache&); 01612 01613 explicit 01614 __numpunct_cache(const __numpunct_cache&); 01615 }; 01616 01617 template<typename _CharT> 01618 __numpunct_cache<_CharT>::~__numpunct_cache() 01619 { 01620 if (_M_allocated) 01621 { 01622 delete [] _M_grouping; 01623 delete [] _M_truename; 01624 delete [] _M_falsename; 01625 } 01626 } 01627 01628 /** 01629 * @brief Primary class template numpunct. 01630 * @ingroup locales 01631 * 01632 * This facet stores several pieces of information related to printing and 01633 * scanning numbers, such as the decimal point character. It takes a 01634 * template parameter specifying the char type. The numpunct facet is 01635 * used by streams for many I/O operations involving numbers. 01636 * 01637 * The numpunct template uses protected virtual functions to provide the 01638 * actual results. The public accessors forward the call to the virtual 01639 * functions. These virtual functions are hooks for developers to 01640 * implement the behavior they require from a numpunct facet. 01641 */ 01642 template<typename _CharT> 01643 class numpunct : public locale::facet 01644 { 01645 public: 01646 // Types: 01647 //@{ 01648 /// Public typedefs 01649 typedef _CharT char_type; 01650 typedef basic_string<_CharT> string_type; 01651 //@} 01652 typedef __numpunct_cache<_CharT> __cache_type; 01653 01654 protected: 01655 __cache_type* _M_data; 01656 01657 public: 01658 /// Numpunct facet id. 01659 static locale::id id; 01660 01661 /** 01662 * @brief Numpunct constructor. 01663 * 01664 * @param __refs Refcount to pass to the base class. 01665 */ 01666 explicit 01667 numpunct(size_t __refs = 0) 01668 : facet(__refs), _M_data(0) 01669 { _M_initialize_numpunct(); } 01670 01671 /** 01672 * @brief Internal constructor. Not for general use. 01673 * 01674 * This is a constructor for use by the library itself to set up the 01675 * predefined locale facets. 01676 * 01677 * @param __cache __numpunct_cache object. 01678 * @param __refs Refcount to pass to the base class. 01679 */ 01680 explicit 01681 numpunct(__cache_type* __cache, size_t __refs = 0) 01682 : facet(__refs), _M_data(__cache) 01683 { _M_initialize_numpunct(); } 01684 01685 /** 01686 * @brief Internal constructor. Not for general use. 01687 * 01688 * This is a constructor for use by the library itself to set up new 01689 * locales. 01690 * 01691 * @param __cloc The C locale. 01692 * @param __refs Refcount to pass to the base class. 01693 */ 01694 explicit 01695 numpunct(__c_locale __cloc, size_t __refs = 0) 01696 : facet(__refs), _M_data(0) 01697 { _M_initialize_numpunct(__cloc); } 01698 01699 /** 01700 * @brief Return decimal point character. 01701 * 01702 * This function returns a char_type to use as a decimal point. It 01703 * does so by returning returning 01704 * numpunct<char_type>::do_decimal_point(). 01705 * 01706 * @return @a char_type representing a decimal point. 01707 */ 01708 char_type 01709 decimal_point() const 01710 { return this->do_decimal_point(); } 01711 01712 /** 01713 * @brief Return thousands separator character. 01714 * 01715 * This function returns a char_type to use as a thousands 01716 * separator. It does so by returning returning 01717 * numpunct<char_type>::do_thousands_sep(). 01718 * 01719 * @return char_type representing a thousands separator. 01720 */ 01721 char_type 01722 thousands_sep() const 01723 { return this->do_thousands_sep(); } 01724 01725 /** 01726 * @brief Return grouping specification. 01727 * 01728 * This function returns a string representing groupings for the 01729 * integer part of a number. Groupings indicate where thousands 01730 * separators should be inserted in the integer part of a number. 01731 * 01732 * Each char in the return string is interpret as an integer 01733 * rather than a character. These numbers represent the number 01734 * of digits in a group. The first char in the string 01735 * represents the number of digits in the least significant 01736 * group. If a char is negative, it indicates an unlimited 01737 * number of digits for the group. If more chars from the 01738 * string are required to group a number, the last char is used 01739 * repeatedly. 01740 * 01741 * For example, if the grouping() returns "\003\002" and is 01742 * applied to the number 123456789, this corresponds to 01743 * 12,34,56,789. Note that if the string was "32", this would 01744 * put more than 50 digits into the least significant group if 01745 * the character set is ASCII. 01746 * 01747 * The string is returned by calling 01748 * numpunct<char_type>::do_grouping(). 01749 * 01750 * @return string representing grouping specification. 01751 */ 01752 string 01753 grouping() const 01754 { return this->do_grouping(); } 01755 01756 /** 01757 * @brief Return string representation of bool true. 01758 * 01759 * This function returns a string_type containing the text 01760 * representation for true bool variables. It does so by calling 01761 * numpunct<char_type>::do_truename(). 01762 * 01763 * @return string_type representing printed form of true. 01764 */ 01765 string_type 01766 truename() const 01767 { return this->do_truename(); } 01768 01769 /** 01770 * @brief Return string representation of bool false. 01771 * 01772 * This function returns a string_type containing the text 01773 * representation for false bool variables. It does so by calling 01774 * numpunct<char_type>::do_falsename(). 01775 * 01776 * @return string_type representing printed form of false. 01777 */ 01778 string_type 01779 falsename() const 01780 { return this->do_falsename(); } 01781 01782 protected: 01783 /// Destructor. 01784 virtual 01785 ~numpunct(); 01786 01787 /** 01788 * @brief Return decimal point character. 01789 * 01790 * Returns a char_type to use as a decimal point. This function is a 01791 * hook for derived classes to change the value returned. 01792 * 01793 * @return @a char_type representing a decimal point. 01794 */ 01795 virtual char_type 01796 do_decimal_point() const 01797 { return _M_data->_M_decimal_point; } 01798 01799 /** 01800 * @brief Return thousands separator character. 01801 * 01802 * Returns a char_type to use as a thousands separator. This function 01803 * is a hook for derived classes to change the value returned. 01804 * 01805 * @return @a char_type representing a thousands separator. 01806 */ 01807 virtual char_type 01808 do_thousands_sep() const 01809 { return _M_data->_M_thousands_sep; } 01810 01811 /** 01812 * @brief Return grouping specification. 01813 * 01814 * Returns a string representing groupings for the integer part of a 01815 * number. This function is a hook for derived classes to change the 01816 * value returned. @see grouping() for details. 01817 * 01818 * @return String representing grouping specification. 01819 */ 01820 virtual string 01821 do_grouping() const 01822 { return _M_data->_M_grouping; } 01823 01824 /** 01825 * @brief Return string representation of bool true. 01826 * 01827 * Returns a string_type containing the text representation for true 01828 * bool variables. This function is a hook for derived classes to 01829 * change the value returned. 01830 * 01831 * @return string_type representing printed form of true. 01832 */ 01833 virtual string_type 01834 do_truename() const 01835 { return _M_data->_M_truename; } 01836 01837 /** 01838 * @brief Return string representation of bool false. 01839 * 01840 * Returns a string_type containing the text representation for false 01841 * bool variables. This function is a hook for derived classes to 01842 * change the value returned. 01843 * 01844 * @return string_type representing printed form of false. 01845 */ 01846 virtual string_type 01847 do_falsename() const 01848 { return _M_data->_M_falsename; } 01849 01850 // For use at construction time only. 01851 void 01852 _M_initialize_numpunct(__c_locale __cloc = 0); 01853 }; 01854 01855 template<typename _CharT> 01856 locale::id numpunct<_CharT>::id; 01857 01858 template<> 01859 numpunct<char>::~numpunct(); 01860 01861 template<> 01862 void 01863 numpunct<char>::_M_initialize_numpunct(__c_locale __cloc); 01864 01865 #ifdef _GLIBCXX_USE_WCHAR_T 01866 template<> 01867 numpunct<wchar_t>::~numpunct(); 01868 01869 template<> 01870 void 01871 numpunct<wchar_t>::_M_initialize_numpunct(__c_locale __cloc); 01872 #endif 01873 01874 /// class numpunct_byname [22.2.3.2]. 01875 template<typename _CharT> 01876 class numpunct_byname : public numpunct<_CharT> 01877 { 01878 public: 01879 typedef _CharT char_type; 01880 typedef basic_string<_CharT> string_type; 01881 01882 explicit 01883 numpunct_byname(const char* __s, size_t __refs = 0) 01884 : numpunct<_CharT>(__refs) 01885 { 01886 if (__builtin_strcmp(__s, "C") != 0 01887 && __builtin_strcmp(__s, "POSIX") != 0) 01888 { 01889 __c_locale __tmp; 01890 this->_S_create_c_locale(__tmp, __s); 01891 this->_M_initialize_numpunct(__tmp); 01892 this->_S_destroy_c_locale(__tmp); 01893 } 01894 } 01895 01896 protected: 01897 virtual 01898 ~numpunct_byname() { } 01899 }; 01900 01901 _GLIBCXX_BEGIN_NAMESPACE_LDBL 01902 01903 /** 01904 * @brief Primary class template num_get. 01905 * @ingroup locales 01906 * 01907 * This facet encapsulates the code to parse and return a number 01908 * from a string. It is used by the istream numeric extraction 01909 * operators. 01910 * 01911 * The num_get template uses protected virtual functions to provide the 01912 * actual results. The public accessors forward the call to the virtual 01913 * functions. These virtual functions are hooks for developers to 01914 * implement the behavior they require from the num_get facet. 01915 */ 01916 template<typename _CharT, typename _InIter> 01917 class num_get : public locale::facet 01918 { 01919 public: 01920 // Types: 01921 //@{ 01922 /// Public typedefs 01923 typedef _CharT char_type; 01924 typedef _InIter iter_type; 01925 //@} 01926 01927 /// Numpunct facet id. 01928 static locale::id id; 01929 01930 /** 01931 * @brief Constructor performs initialization. 01932 * 01933 * This is the constructor provided by the standard. 01934 * 01935 * @param __refs Passed to the base facet class. 01936 */ 01937 explicit 01938 num_get(size_t __refs = 0) : facet(__refs) { } 01939 01940 /** 01941 * @brief Numeric parsing. 01942 * 01943 * Parses the input stream into the bool @a v. It does so by calling 01944 * num_get::do_get(). 01945 * 01946 * If ios_base::boolalpha is set, attempts to read 01947 * ctype<CharT>::truename() or ctype<CharT>::falsename(). Sets 01948 * @a v to true or false if successful. Sets err to 01949 * ios_base::failbit if reading the string fails. Sets err to 01950 * ios_base::eofbit if the stream is emptied. 01951 * 01952 * If ios_base::boolalpha is not set, proceeds as with reading a long, 01953 * except if the value is 1, sets @a v to true, if the value is 0, sets 01954 * @a v to false, and otherwise set err to ios_base::failbit. 01955 * 01956 * @param __in Start of input stream. 01957 * @param __end End of input stream. 01958 * @param __io Source of locale and flags. 01959 * @param __err Error flags to set. 01960 * @param __v Value to format and insert. 01961 * @return Iterator after reading. 01962 */ 01963 iter_type 01964 get(iter_type __in, iter_type __end, ios_base& __io, 01965 ios_base::iostate& __err, bool& __v) const 01966 { return this->do_get(__in, __end, __io, __err, __v); } 01967 01968 //@{ 01969 /** 01970 * @brief Numeric parsing. 01971 * 01972 * Parses the input stream into the integral variable @a v. It does so 01973 * by calling num_get::do_get(). 01974 * 01975 * Parsing is affected by the flag settings in @a io. 01976 * 01977 * The basic parse is affected by the value of io.flags() & 01978 * ios_base::basefield. If equal to ios_base::oct, parses like the 01979 * scanf %o specifier. Else if equal to ios_base::hex, parses like %X 01980 * specifier. Else if basefield equal to 0, parses like the %i 01981 * specifier. Otherwise, parses like %d for signed and %u for unsigned 01982 * types. The matching type length modifier is also used. 01983 * 01984 * Digit grouping is interpreted according to numpunct::grouping() and 01985 * numpunct::thousands_sep(). If the pattern of digit groups isn't 01986 * consistent, sets err to ios_base::failbit. 01987 * 01988 * If parsing the string yields a valid value for @a v, @a v is set. 01989 * Otherwise, sets err to ios_base::failbit and leaves @a v unaltered. 01990 * Sets err to ios_base::eofbit if the stream is emptied. 01991 * 01992 * @param __in Start of input stream. 01993 * @param __end End of input stream. 01994 * @param __io Source of locale and flags. 01995 * @param __err Error flags to set. 01996 * @param __v Value to format and insert. 01997 * @return Iterator after reading. 01998 */ 01999 iter_type 02000 get(iter_type __in, iter_type __end, ios_base& __io, 02001 ios_base::iostate& __err, long& __v) const 02002 { return this->do_get(__in, __end, __io, __err, __v); } 02003 02004 iter_type 02005 get(iter_type __in, iter_type __end, ios_base& __io, 02006 ios_base::iostate& __err, unsigned short& __v) const 02007 { return this->do_get(__in, __end, __io, __err, __v); } 02008 02009 iter_type 02010 get(iter_type __in, iter_type __end, ios_base& __io, 02011 ios_base::iostate& __err, unsigned int& __v) const 02012 { return this->do_get(__in, __end, __io, __err, __v); } 02013 02014 iter_type 02015 get(iter_type __in, iter_type __end, ios_base& __io, 02016 ios_base::iostate& __err, unsigned long& __v) const 02017 { return this->do_get(__in, __end, __io, __err, __v); } 02018 02019 #ifdef _GLIBCXX_USE_LONG_LONG 02020 iter_type 02021 get(iter_type __in, iter_type __end, ios_base& __io, 02022 ios_base::iostate& __err, long long& __v) const 02023 { return this->do_get(__in, __end, __io, __err, __v); } 02024 02025 iter_type 02026 get(iter_type __in, iter_type __end, ios_base& __io, 02027 ios_base::iostate& __err, unsigned long long& __v) const 02028 { return this->do_get(__in, __end, __io, __err, __v); } 02029 #endif 02030 //@} 02031 02032 //@{ 02033 /** 02034 * @brief Numeric parsing. 02035 * 02036 * Parses the input stream into the integral variable @a v. It does so 02037 * by calling num_get::do_get(). 02038 * 02039 * The input characters are parsed like the scanf %g specifier. The 02040 * matching type length modifier is also used. 02041 * 02042 * The decimal point character used is numpunct::decimal_point(). 02043 * Digit grouping is interpreted according to numpunct::grouping() and 02044 * numpunct::thousands_sep(). If the pattern of digit groups isn't 02045 * consistent, sets err to ios_base::failbit. 02046 * 02047 * If parsing the string yields a valid value for @a v, @a v is set. 02048 * Otherwise, sets err to ios_base::failbit and leaves @a v unaltered. 02049 * Sets err to ios_base::eofbit if the stream is emptied. 02050 * 02051 * @param __in Start of input stream. 02052 * @param __end End of input stream. 02053 * @param __io Source of locale and flags. 02054 * @param __err Error flags to set. 02055 * @param __v Value to format and insert. 02056 * @return Iterator after reading. 02057 */ 02058 iter_type 02059 get(iter_type __in, iter_type __end, ios_base& __io, 02060 ios_base::iostate& __err, float& __v) const 02061 { return this->do_get(__in, __end, __io, __err, __v); } 02062 02063 iter_type 02064 get(iter_type __in, iter_type __end, ios_base& __io, 02065 ios_base::iostate& __err, double& __v) const 02066 { return this->do_get(__in, __end, __io, __err, __v); } 02067 02068 iter_type 02069 get(iter_type __in, iter_type __end, ios_base& __io, 02070 ios_base::iostate& __err, long double& __v) const 02071 { return this->do_get(__in, __end, __io, __err, __v); } 02072 //@} 02073 02074 /** 02075 * @brief Numeric parsing. 02076 * 02077 * Parses the input stream into the pointer variable @a v. It does so 02078 * by calling num_get::do_get(). 02079 * 02080 * The input characters are parsed like the scanf %p specifier. 02081 * 02082 * Digit grouping is interpreted according to numpunct::grouping() and 02083 * numpunct::thousands_sep(). If the pattern of digit groups isn't 02084 * consistent, sets err to ios_base::failbit. 02085 * 02086 * Note that the digit grouping effect for pointers is a bit ambiguous 02087 * in the standard and shouldn't be relied on. See DR 344. 02088 * 02089 * If parsing the string yields a valid value for @a v, @a v is set. 02090 * Otherwise, sets err to ios_base::failbit and leaves @a v unaltered. 02091 * Sets err to ios_base::eofbit if the stream is emptied. 02092 * 02093 * @param __in Start of input stream. 02094 * @param __end End of input stream. 02095 * @param __io Source of locale and flags. 02096 * @param __err Error flags to set. 02097 * @param __v Value to format and insert. 02098 * @return Iterator after reading. 02099 */ 02100 iter_type 02101 get(iter_type __in, iter_type __end, ios_base& __io, 02102 ios_base::iostate& __err, void*& __v) const 02103 { return this->do_get(__in, __end, __io, __err, __v); } 02104 02105 protected: 02106 /// Destructor. 02107 virtual ~num_get() { } 02108 02109 iter_type 02110 _M_extract_float(iter_type, iter_type, ios_base&, ios_base::iostate&, 02111 string&) const; 02112 02113 template<typename _ValueT> 02114 iter_type 02115 _M_extract_int(iter_type, iter_type, ios_base&, ios_base::iostate&, 02116 _ValueT&) const; 02117 02118 template<typename _CharT2> 02119 typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, int>::__type 02120 _M_find(const _CharT2*, size_t __len, _CharT2 __c) const 02121 { 02122 int __ret = -1; 02123 if (__len <= 10) 02124 { 02125 if (__c >= _CharT2('0') && __c < _CharT2(_CharT2('0') + __len)) 02126 __ret = __c - _CharT2('0'); 02127 } 02128 else 02129 { 02130 if (__c >= _CharT2('0') && __c <= _CharT2('9')) 02131 __ret = __c - _CharT2('0'); 02132 else if (__c >= _CharT2('a') && __c <= _CharT2('f')) 02133 __ret = 10 + (__c - _CharT2('a')); 02134 else if (__c >= _CharT2('A') && __c <= _CharT2('F')) 02135 __ret = 10 + (__c - _CharT2('A')); 02136 } 02137 return __ret; 02138 } 02139 02140 template<typename _CharT2> 02141 typename __gnu_cxx::__enable_if<!__is_char<_CharT2>::__value, 02142 int>::__type 02143 _M_find(const _CharT2* __zero, size_t __len, _CharT2 __c) const 02144 { 02145 int __ret = -1; 02146 const char_type* __q = char_traits<_CharT2>::find(__zero, __len, __c); 02147 if (__q) 02148 { 02149 __ret = __q - __zero; 02150 if (__ret > 15) 02151 __ret -= 6; 02152 } 02153 return __ret; 02154 } 02155 02156 //@{ 02157 /** 02158 * @brief Numeric parsing. 02159 * 02160 * Parses the input stream into the variable @a v. This function is a 02161 * hook for derived classes to change the value returned. @see get() 02162 * for more details. 02163 * 02164 * @param __beg Start of input stream. 02165 * @param __end End of input stream. 02166 * @param __io Source of locale and flags. 02167 * @param __err Error flags to set. 02168 * @param __v Value to format and insert. 02169 * @return Iterator after reading. 02170 */ 02171 virtual iter_type 02172 do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, bool&) const; 02173 02174 virtual iter_type 02175 do_get(iter_type __beg, iter_type __end, ios_base& __io, 02176 ios_base::iostate& __err, long& __v) const 02177 { return _M_extract_int(__beg, __end, __io, __err, __v); } 02178 02179 virtual iter_type 02180 do_get(iter_type __beg, iter_type __end, ios_base& __io, 02181 ios_base::iostate& __err, unsigned short& __v) const 02182 { return _M_extract_int(__beg, __end, __io, __err, __v); } 02183 02184 virtual iter_type 02185 do_get(iter_type __beg, iter_type __end, ios_base& __io, 02186 ios_base::iostate& __err, unsigned int& __v) const 02187 { return _M_extract_int(__beg, __end, __io, __err, __v); } 02188 02189 virtual iter_type 02190 do_get(iter_type __beg, iter_type __end, ios_base& __io, 02191 ios_base::iostate& __err, unsigned long& __v) const 02192 { return _M_extract_int(__beg, __end, __io, __err, __v); } 02193 02194 #ifdef _GLIBCXX_USE_LONG_LONG 02195 virtual iter_type 02196 do_get(iter_type __beg, iter_type __end, ios_base& __io, 02197 ios_base::iostate& __err, long long& __v) const 02198 { return _M_extract_int(__beg, __end, __io, __err, __v); } 02199 02200 virtual iter_type 02201 do_get(iter_type __beg, iter_type __end, ios_base& __io, 02202 ios_base::iostate& __err, unsigned long long& __v) const 02203 { return _M_extract_int(__beg, __end, __io, __err, __v); } 02204 #endif 02205 02206 virtual iter_type 02207 do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, float&) const; 02208 02209 virtual iter_type 02210 do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, 02211 double&) const; 02212 02213 // XXX GLIBCXX_ABI Deprecated 02214 #if defined _GLIBCXX_LONG_DOUBLE_COMPAT && defined __LONG_DOUBLE_128__ 02215 virtual iter_type 02216 __do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, 02217 double&) const; 02218 #else 02219 virtual iter_type 02220 do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, 02221 long double&) const; 02222 #endif 02223 02224 virtual iter_type 02225 do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, void*&) const; 02226 02227 // XXX GLIBCXX_ABI Deprecated 02228 #if defined _GLIBCXX_LONG_DOUBLE_COMPAT && defined __LONG_DOUBLE_128__ 02229 virtual iter_type 02230 do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, 02231 long double&) const; 02232 #endif 02233 //@} 02234 }; 02235 02236 template<typename _CharT, typename _InIter> 02237 locale::id num_get<_CharT, _InIter>::id; 02238 02239 02240 /** 02241 * @brief Primary class template num_put. 02242 * @ingroup locales 02243 * 02244 * This facet encapsulates the code to convert a number to a string. It is 02245 * used by the ostream numeric insertion operators. 02246 * 02247 * The num_put template uses protected virtual functions to provide the 02248 * actual results. The public accessors forward the call to the virtual 02249 * functions. These virtual functions are hooks for developers to 02250 * implement the behavior they require from the num_put facet. 02251 */ 02252 template<typename _CharT, typename _OutIter> 02253 class num_put : public locale::facet 02254 { 02255 public: 02256 // Types: 02257 //@{ 02258 /// Public typedefs 02259 typedef _CharT char_type; 02260 typedef _OutIter iter_type; 02261 //@} 02262 02263 /// Numpunct facet id. 02264 static locale::id id; 02265 02266 /** 02267 * @brief Constructor performs initialization. 02268 * 02269 * This is the constructor provided by the standard. 02270 * 02271 * @param __refs Passed to the base facet class. 02272 */ 02273 explicit 02274 num_put(size_t __refs = 0) : facet(__refs) { } 02275 02276 /** 02277 * @brief Numeric formatting. 02278 * 02279 * Formats the boolean @a v and inserts it into a stream. It does so 02280 * by calling num_put::do_put(). 02281 * 02282 * If ios_base::boolalpha is set, writes ctype<CharT>::truename() or 02283 * ctype<CharT>::falsename(). Otherwise formats @a v as an int. 02284 * 02285 * @param __s Stream to write to. 02286 * @param __io Source of locale and flags. 02287 * @param __fill Char_type to use for filling. 02288 * @param __v Value to format and insert. 02289 * @return Iterator after writing. 02290 */ 02291 iter_type 02292 put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const 02293 { return this->do_put(__s, __io, __fill, __v); } 02294 02295 //@{ 02296 /** 02297 * @brief Numeric formatting. 02298 * 02299 * Formats the integral value @a v and inserts it into a 02300 * stream. It does so by calling num_put::do_put(). 02301 * 02302 * Formatting is affected by the flag settings in @a io. 02303 * 02304 * The basic format is affected by the value of io.flags() & 02305 * ios_base::basefield. If equal to ios_base::oct, formats like the 02306 * printf %o specifier. Else if equal to ios_base::hex, formats like 02307 * %x or %X with ios_base::uppercase unset or set respectively. 02308 * Otherwise, formats like %d, %ld, %lld for signed and %u, %lu, %llu 02309 * for unsigned values. Note that if both oct and hex are set, neither 02310 * will take effect. 02311 * 02312 * If ios_base::showpos is set, '+' is output before positive values. 02313 * If ios_base::showbase is set, '0' precedes octal values (except 0) 02314 * and '0[xX]' precedes hex values. 02315 * 02316 * Thousands separators are inserted according to numpunct::grouping() 02317 * and numpunct::thousands_sep(). The decimal point character used is 02318 * numpunct::decimal_point(). 02319 * 02320 * If io.width() is non-zero, enough @a fill characters are inserted to 02321 * make the result at least that wide. If 02322 * (io.flags() & ios_base::adjustfield) == ios_base::left, result is 02323 * padded at the end. If ios_base::internal, then padding occurs 02324 * immediately after either a '+' or '-' or after '0x' or '0X'. 02325 * Otherwise, padding occurs at the beginning. 02326 * 02327 * @param __s Stream to write to. 02328 * @param __io Source of locale and flags. 02329 * @param __fill Char_type to use for filling. 02330 * @param __v Value to format and insert. 02331 * @return Iterator after writing. 02332 */ 02333 iter_type 02334 put(iter_type __s, ios_base& __io, char_type __fill, long __v) const 02335 { return this->do_put(__s, __io, __fill, __v); } 02336 02337 iter_type 02338 put(iter_type __s, ios_base& __io, char_type __fill, 02339 unsigned long __v) const 02340 { return this->do_put(__s, __io, __fill, __v); } 02341 02342 #ifdef _GLIBCXX_USE_LONG_LONG 02343 iter_type 02344 put(iter_type __s, ios_base& __io, char_type __fill, long long __v) const 02345 { return this->do_put(__s, __io, __fill, __v); } 02346 02347 iter_type 02348 put(iter_type __s, ios_base& __io, char_type __fill, 02349 unsigned long long __v) const 02350 { return this->do_put(__s, __io, __fill, __v); } 02351 #endif 02352 //@} 02353 02354 //@{ 02355 /** 02356 * @brief Numeric formatting. 02357 * 02358 * Formats the floating point value @a v and inserts it into a stream. 02359 * It does so by calling num_put::do_put(). 02360 * 02361 * Formatting is affected by the flag settings in @a io. 02362 * 02363 * The basic format is affected by the value of io.flags() & 02364 * ios_base::floatfield. If equal to ios_base::fixed, formats like the 02365 * printf %f specifier. Else if equal to ios_base::scientific, formats 02366 * like %e or %E with ios_base::uppercase unset or set respectively. 02367 * Otherwise, formats like %g or %G depending on uppercase. Note that 02368 * if both fixed and scientific are set, the effect will also be like 02369 * %g or %G. 02370 * 02371 * The output precision is given by io.precision(). This precision is 02372 * capped at numeric_limits::digits10 + 2 (different for double and 02373 * long double). The default precision is 6. 02374 * 02375 * If ios_base::showpos is set, '+' is output before positive values. 02376 * If ios_base::showpoint is set, a decimal point will always be 02377 * output. 02378 * 02379 * Thousands separators are inserted according to numpunct::grouping() 02380 * and numpunct::thousands_sep(). The decimal point character used is 02381 * numpunct::decimal_point(). 02382 * 02383 * If io.width() is non-zero, enough @a fill characters are inserted to 02384 * make the result at least that wide. If 02385 * (io.flags() & ios_base::adjustfield) == ios_base::left, result is 02386 * padded at the end. If ios_base::internal, then padding occurs 02387 * immediately after either a '+' or '-' or after '0x' or '0X'. 02388 * Otherwise, padding occurs at the beginning. 02389 * 02390 * @param __s Stream to write to. 02391 * @param __io Source of locale and flags. 02392 * @param __fill Char_type to use for filling. 02393 * @param __v Value to format and insert. 02394 * @return Iterator after writing. 02395 */ 02396 iter_type 02397 put(iter_type __s, ios_base& __io, char_type __fill, double __v) const 02398 { return this->do_put(__s, __io, __fill, __v); } 02399 02400 iter_type 02401 put(iter_type __s, ios_base& __io, char_type __fill, 02402 long double __v) const 02403 { return this->do_put(__s, __io, __fill, __v); } 02404 //@} 02405 02406 /** 02407 * @brief Numeric formatting. 02408 * 02409 * Formats the pointer value @a v and inserts it into a stream. It 02410 * does so by calling num_put::do_put(). 02411 * 02412 * This function formats @a v as an unsigned long with ios_base::hex 02413 * and ios_base::showbase set. 02414 * 02415 * @param __s Stream to write to. 02416 * @param __io Source of locale and flags. 02417 * @param __fill Char_type to use for filling. 02418 * @param __v Value to format and insert. 02419 * @return Iterator after writing. 02420 */ 02421 iter_type 02422 put(iter_type __s, ios_base& __io, char_type __fill, 02423 const void* __v) const 02424 { return this->do_put(__s, __io, __fill, __v); } 02425 02426 protected: 02427 template<typename _ValueT> 02428 iter_type 02429 _M_insert_float(iter_type, ios_base& __io, char_type __fill, 02430 char __mod, _ValueT __v) const; 02431 02432 void 02433 _M_group_float(const char* __grouping, size_t __grouping_size, 02434 char_type __sep, const char_type* __p, char_type* __new, 02435 char_type* __cs, int& __len) const; 02436 02437 template<typename _ValueT> 02438 iter_type 02439 _M_insert_int(iter_type, ios_base& __io, char_type __fill, 02440 _ValueT __v) const; 02441 02442 void 02443 _M_group_int(const char* __grouping, size_t __grouping_size, 02444 char_type __sep, ios_base& __io, char_type* __new, 02445 char_type* __cs, int& __len) const; 02446 02447 void 02448 _M_pad(char_type __fill, streamsize __w, ios_base& __io, 02449 char_type* __new, const char_type* __cs, int& __len) const; 02450 02451 /// Destructor. 02452 virtual 02453 ~num_put() { }; 02454 02455 //@{ 02456 /** 02457 * @brief Numeric formatting. 02458 * 02459 * These functions do the work of formatting numeric values and 02460 * inserting them into a stream. This function is a hook for derived 02461 * classes to change the value returned. 02462 * 02463 * @param __s Stream to write to. 02464 * @param __io Source of locale and flags. 02465 * @param __fill Char_type to use for filling. 02466 * @param __v Value to format and insert. 02467 * @return Iterator after writing. 02468 */ 02469 virtual iter_type 02470 do_put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const; 02471 02472 virtual iter_type 02473 do_put(iter_type __s, ios_base& __io, char_type __fill, long __v) const 02474 { return _M_insert_int(__s, __io, __fill, __v); } 02475 02476 virtual iter_type 02477 do_put(iter_type __s, ios_base& __io, char_type __fill, 02478 unsigned long __v) const 02479 { return _M_insert_int(__s, __io, __fill, __v); } 02480 02481 #ifdef _GLIBCXX_USE_LONG_LONG 02482 virtual iter_type 02483 do_put(iter_type __s, ios_base& __io, char_type __fill, 02484 long long __v) const 02485 { return _M_insert_int(__s, __io, __fill, __v); } 02486 02487 virtual iter_type 02488 do_put(iter_type __s, ios_base& __io, char_type __fill, 02489 unsigned long long __v) const 02490 { return _M_insert_int(__s, __io, __fill, __v); } 02491 #endif 02492 02493 virtual iter_type 02494 do_put(iter_type, ios_base&, char_type, double) const; 02495 02496 // XXX GLIBCXX_ABI Deprecated 02497 #if defined _GLIBCXX_LONG_DOUBLE_COMPAT && defined __LONG_DOUBLE_128__ 02498 virtual iter_type 02499 __do_put(iter_type, ios_base&, char_type, double) const; 02500 #else 02501 virtual iter_type 02502 do_put(iter_type, ios_base&, char_type, long double) const; 02503 #endif 02504 02505 virtual iter_type 02506 do_put(iter_type, ios_base&, char_type, const void*) const; 02507 02508 // XXX GLIBCXX_ABI Deprecated 02509 #if defined _GLIBCXX_LONG_DOUBLE_COMPAT && defined __LONG_DOUBLE_128__ 02510 virtual iter_type 02511 do_put(iter_type, ios_base&, char_type, long double) const; 02512 #endif 02513 //@} 02514 }; 02515 02516 template <typename _CharT, typename _OutIter> 02517 locale::id num_put<_CharT, _OutIter>::id; 02518 02519 _GLIBCXX_END_NAMESPACE_LDBL 02520 02521 // Subclause convenience interfaces, inlines. 02522 // NB: These are inline because, when used in a loop, some compilers 02523 // can hoist the body out of the loop; then it's just as fast as the 02524 // C is*() function. 02525 02526 /// Convenience interface to ctype.is(ctype_base::space, __c). 02527 template<typename _CharT> 02528 inline bool 02529 isspace(_CharT __c, const locale& __loc) 02530 { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::space, __c); } 02531 02532 /// Convenience interface to ctype.is(ctype_base::print, __c). 02533 template<typename _CharT> 02534 inline bool 02535 isprint(_CharT __c, const locale& __loc) 02536 { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::print, __c); } 02537 02538 /// Convenience interface to ctype.is(ctype_base::cntrl, __c). 02539 template<typename _CharT> 02540 inline bool 02541 iscntrl(_CharT __c, const locale& __loc) 02542 { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::cntrl, __c); } 02543 02544 /// Convenience interface to ctype.is(ctype_base::upper, __c). 02545 template<typename _CharT> 02546 inline bool 02547 isupper(_CharT __c, const locale& __loc) 02548 { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::upper, __c); } 02549 02550 /// Convenience interface to ctype.is(ctype_base::lower, __c). 02551 template<typename _CharT> 02552 inline bool 02553 islower(_CharT __c, const locale& __loc) 02554 { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::lower, __c); } 02555 02556 /// Convenience interface to ctype.is(ctype_base::alpha, __c). 02557 template<typename _CharT> 02558 inline bool 02559 isalpha(_CharT __c, const locale& __loc) 02560 { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::alpha, __c); } 02561 02562 /// Convenience interface to ctype.is(ctype_base::digit, __c). 02563 template<typename _CharT> 02564 inline bool 02565 isdigit(_CharT __c, const locale& __loc) 02566 { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::digit, __c); } 02567 02568 /// Convenience interface to ctype.is(ctype_base::punct, __c). 02569 template<typename _CharT> 02570 inline bool 02571 ispunct(_CharT __c, const locale& __loc) 02572 { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::punct, __c); } 02573 02574 /// Convenience interface to ctype.is(ctype_base::xdigit, __c). 02575 template<typename _CharT> 02576 inline bool 02577 isxdigit(_CharT __c, const locale& __loc) 02578 { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::xdigit, __c); } 02579 02580 /// Convenience interface to ctype.is(ctype_base::alnum, __c). 02581 template<typename _CharT> 02582 inline bool 02583 isalnum(_CharT __c, const locale& __loc) 02584 { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::alnum, __c); } 02585 02586 /// Convenience interface to ctype.is(ctype_base::graph, __c). 02587 template<typename _CharT> 02588 inline bool 02589 isgraph(_CharT __c, const locale& __loc) 02590 { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::graph, __c); } 02591 02592 /// Convenience interface to ctype.toupper(__c). 02593 template<typename _CharT> 02594 inline _CharT 02595 toupper(_CharT __c, const locale& __loc) 02596 { return use_facet<ctype<_CharT> >(__loc).toupper(__c); } 02597 02598 /// Convenience interface to ctype.tolower(__c). 02599 template<typename _CharT> 02600 inline _CharT 02601 tolower(_CharT __c, const locale& __loc) 02602 { return use_facet<ctype<_CharT> >(__loc).tolower(__c); } 02603 02604 _GLIBCXX_END_NAMESPACE_VERSION 02605 } // namespace std 02606 02607 # include <bits/locale_facets.tcc> 02608 02609 #endif