00001 // Locale support -*- C++ -*- 00002 00003 // Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 00004 // Free Software Foundation, Inc. 00005 // 00006 // This file is part of the GNU ISO C++ Library. This library is free 00007 // software; you can redistribute it and/or modify it under the 00008 // terms of the GNU General Public License as published by the 00009 // Free Software Foundation; either version 2, or (at your option) 00010 // any later version. 00011 00012 // This library is distributed in the hope that it will be useful, 00013 // but WITHOUT ANY WARRANTY; without even the implied warranty of 00014 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 00015 // GNU General Public License for more details. 00016 00017 // You should have received a copy of the GNU General Public License along 00018 // with this library; see the file COPYING. If not, write to the Free 00019 // Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, 00020 // USA. 00021 00022 // As a special exception, you may use this file as part of a free software 00023 // library without restriction. Specifically, if other files instantiate 00024 // templates or use macros or inline functions from this file, or you compile 00025 // this file and link it with other files to produce an executable, this 00026 // file does not by itself cause the resulting executable to be covered by 00027 // the GNU General Public License. This exception does not however 00028 // invalidate any other reasons why the executable file might be covered by 00029 // the GNU General Public License. 00030 00031 // 00032 // ISO C++ 14882: 22.1 Locales 00033 // 00034 00035 /** @file locale_facets.h 00036 * This is an internal header file, included by other library headers. 00037 * You should not attempt to use it directly. 00038 */ 00039 00040 #ifndef _LOCALE_FACETS_H 00041 #define _LOCALE_FACETS_H 1 00042 00043 #pragma GCC system_header 00044 00045 #include <ctime> // For struct tm 00046 #include <cwctype> // For wctype_t 00047 #include <iosfwd> 00048 #include <bits/ios_base.h> // For ios_base, ios_base::iostate 00049 #include <streambuf> 00050 00051 namespace std 00052 { 00053 // NB: Don't instantiate required wchar_t facets if no wchar_t support. 00054 #ifdef _GLIBCXX_USE_WCHAR_T 00055 # define _GLIBCXX_NUM_FACETS 28 00056 #else 00057 # define _GLIBCXX_NUM_FACETS 14 00058 #endif 00059 00060 // Convert string to numeric value of type _Tv and store results. 00061 // NB: This is specialized for all required types, there is no 00062 // generic definition. 00063 template<typename _Tv> 00064 void 00065 __convert_to_v(const char* __in, _Tv& __out, ios_base::iostate& __err, 00066 const __c_locale& __cloc); 00067 00068 // Explicit specializations for required types. 00069 template<> 00070 void 00071 __convert_to_v(const char*, float&, ios_base::iostate&, 00072 const __c_locale&); 00073 00074 template<> 00075 void 00076 __convert_to_v(const char*, double&, ios_base::iostate&, 00077 const __c_locale&); 00078 00079 template<> 00080 void 00081 __convert_to_v(const char*, long double&, ios_base::iostate&, 00082 const __c_locale&); 00083 00084 // NB: __pad is a struct, rather than a function, so it can be 00085 // partially-specialized. 00086 template<typename _CharT, typename _Traits> 00087 struct __pad 00088 { 00089 static void 00090 _S_pad(ios_base& __io, _CharT __fill, _CharT* __news, 00091 const _CharT* __olds, const streamsize __newlen, 00092 const streamsize __oldlen, const bool __num); 00093 }; 00094 00095 // Used by both numeric and monetary facets. 00096 // Inserts "group separator" characters into an array of characters. 00097 // It's recursive, one iteration per group. It moves the characters 00098 // in the buffer this way: "xxxx12345" -> "12,345xxx". Call this 00099 // only with __glen != 0. 00100 template<typename _CharT> 00101 _CharT* 00102 __add_grouping(_CharT* __s, _CharT __sep, 00103 const char* __gbeg, size_t __gsize, 00104 const _CharT* __first, const _CharT* __last); 00105 00106 // This template permits specializing facet output code for 00107 // ostreambuf_iterator. For ostreambuf_iterator, sputn is 00108 // significantly more efficient than incrementing iterators. 00109 template<typename _CharT> 00110 inline 00111 ostreambuf_iterator<_CharT> 00112 __write(ostreambuf_iterator<_CharT> __s, const _CharT* __ws, int __len) 00113 { 00114 __s._M_put(__ws, __len); 00115 return __s; 00116 } 00117 00118 // This is the unspecialized form of the template. 00119 template<typename _CharT, typename _OutIter> 00120 inline 00121 _OutIter 00122 __write(_OutIter __s, const _CharT* __ws, int __len) 00123 { 00124 for (int __j = 0; __j < __len; __j++, ++__s) 00125 *__s = __ws[__j]; 00126 return __s; 00127 } 00128 00129 00130 // 22.2.1.1 Template class ctype 00131 // Include host and configuration specific ctype enums for ctype_base. 00132 #include <bits/ctype_base.h> 00133 00134 // Common base for ctype<_CharT>. 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 abtract 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 mask @a m. 00156 * It does so by returning the value of ctype<char_type>::do_is(). 00157 * 00158 * @param c The char_type to compare the mask of. 00159 * @param m The mask to compare against. 00160 * @return (M & m) != 0. 00161 */ 00162 bool 00163 is(mask __m, char_type __c) const 00164 { return this->do_is(__m, __c); } 00165 00166 /** 00167 * @brief Return a mask array. 00168 * 00169 * This function finds the mask for each char_type in the range [lo,hi) 00170 * and successively writes it to vec. vec must have as many elements 00171 * as the char array. It does so by returning the value of 00172 * ctype<char_type>::do_is(). 00173 * 00174 * @param lo Pointer to start of range. 00175 * @param hi Pointer to end of range. 00176 * @param vec Pointer to an array of mask storage. 00177 * @return @a hi. 00178 */ 00179 const char_type* 00180 is(const char_type *__lo, const char_type *__hi, mask *__vec) const 00181 { return this->do_is(__lo, __hi, __vec); } 00182 00183 /** 00184 * @brief Find char_type matching a mask 00185 * 00186 * This function searches for and returns the first char_type c in 00187 * [lo,hi) for which is(m,c) is true. It does so by returning 00188 * ctype<char_type>::do_scan_is(). 00189 * 00190 * @param m The mask to compare against. 00191 * @param lo Pointer to start of range. 00192 * @param hi Pointer to end of range. 00193 * @return Pointer to matching char_type if found, else @a hi. 00194 */ 00195 const char_type* 00196 scan_is(mask __m, const char_type* __lo, const char_type* __hi) const 00197 { return this->do_scan_is(__m, __lo, __hi); } 00198 00199 /** 00200 * @brief Find char_type not matching a mask 00201 * 00202 * This function searches for and returns the first char_type c in 00203 * [lo,hi) for which is(m,c) is false. It does so by returning 00204 * ctype<char_type>::do_scan_not(). 00205 * 00206 * @param m The mask to compare against. 00207 * @param lo Pointer to first char in range. 00208 * @param hi Pointer to end of range. 00209 * @return Pointer to non-matching char if found, else @a hi. 00210 */ 00211 const char_type* 00212 scan_not(mask __m, const char_type* __lo, const char_type* __hi) const 00213 { return this->do_scan_not(__m, __lo, __hi); } 00214 00215 /** 00216 * @brief Convert to uppercase. 00217 * 00218 * This function converts the argument to uppercase if possible. 00219 * If not possible (for example, '2'), returns the argument. It does 00220 * so by returning ctype<char_type>::do_toupper(). 00221 * 00222 * @param c The char_type to convert. 00223 * @return The uppercase char_type if convertible, else @a c. 00224 */ 00225 char_type 00226 toupper(char_type __c) const 00227 { return this->do_toupper(__c); } 00228 00229 /** 00230 * @brief Convert array to uppercase. 00231 * 00232 * This function converts each char_type in the range [lo,hi) to 00233 * uppercase if possible. Other elements remain untouched. It does so 00234 * by returning ctype<char_type>:: do_toupper(lo, hi). 00235 * 00236 * @param lo Pointer to start of range. 00237 * @param hi Pointer to end of range. 00238 * @return @a hi. 00239 */ 00240 const char_type* 00241 toupper(char_type *__lo, const char_type* __hi) const 00242 { return this->do_toupper(__lo, __hi); } 00243 00244 /** 00245 * @brief Convert to lowercase. 00246 * 00247 * This function converts the argument to lowercase if possible. If 00248 * not possible (for example, '2'), returns the argument. It does so 00249 * by returning ctype<char_type>::do_tolower(c). 00250 * 00251 * @param c The char_type to convert. 00252 * @return The lowercase char_type if convertible, else @a c. 00253 */ 00254 char_type 00255 tolower(char_type __c) const 00256 { return this->do_tolower(__c); } 00257 00258 /** 00259 * @brief Convert array to lowercase. 00260 * 00261 * This function converts each char_type in the range [lo,hi) to 00262 * lowercase if possible. Other elements remain untouched. It does so 00263 * by returning ctype<char_type>:: do_tolower(lo, hi). 00264 * 00265 * @param lo Pointer to start of range. 00266 * @param hi Pointer to end of range. 00267 * @return @a hi. 00268 */ 00269 const char_type* 00270 tolower(char_type* __lo, const char_type* __hi) const 00271 { return this->do_tolower(__lo, __hi); } 00272 00273 /** 00274 * @brief Widen char to char_type 00275 * 00276 * This function converts the char argument to char_type using the 00277 * simplest reasonable transformation. It does so by returning 00278 * ctype<char_type>::do_widen(c). 00279 * 00280 * Note: this is not what you want for codepage conversions. See 00281 * codecvt for that. 00282 * 00283 * @param c The char to convert. 00284 * @return The converted char_type. 00285 */ 00286 char_type 00287 widen(char __c) const 00288 { return this->do_widen(__c); } 00289 00290 /** 00291 * @brief Widen array to char_type 00292 * 00293 * This function converts each char in the input to char_type using the 00294 * simplest reasonable transformation. It does so by returning 00295 * ctype<char_type>::do_widen(c). 00296 * 00297 * Note: this is not what you want for codepage conversions. See 00298 * codecvt for that. 00299 * 00300 * @param lo Pointer to start of range. 00301 * @param hi Pointer to end of range. 00302 * @param to Pointer to the destination array. 00303 * @return @a hi. 00304 */ 00305 const char* 00306 widen(const char* __lo, const char* __hi, char_type* __to) const 00307 { return this->do_widen(__lo, __hi, __to); } 00308 00309 /** 00310 * @brief Narrow char_type to char 00311 * 00312 * This function converts the char_type to char using the simplest 00313 * reasonable transformation. If the conversion fails, dfault is 00314 * returned instead. It does so by returning 00315 * ctype<char_type>::do_narrow(c). 00316 * 00317 * Note: this is not what you want for codepage conversions. See 00318 * codecvt for that. 00319 * 00320 * @param c The char_type to convert. 00321 * @param dfault Char to return if conversion fails. 00322 * @return The converted char. 00323 */ 00324 char 00325 narrow(char_type __c, char __dfault) const 00326 { return this->do_narrow(__c, __dfault); } 00327 00328 /** 00329 * @brief Narrow array to char array 00330 * 00331 * This function converts each char_type in the input to char using the 00332 * simplest reasonable transformation and writes the results to the 00333 * destination array. For any char_type in the input that cannot be 00334 * converted, @a dfault is used instead. It does so by returning 00335 * ctype<char_type>::do_narrow(lo, hi, dfault, to). 00336 * 00337 * Note: this is not what you want for codepage conversions. See 00338 * codecvt for that. 00339 * 00340 * @param lo Pointer to start of range. 00341 * @param hi Pointer to end of range. 00342 * @param dfault Char to use if conversion fails. 00343 * @param to Pointer to the destination array. 00344 * @return @a hi. 00345 */ 00346 const char_type* 00347 narrow(const char_type* __lo, const char_type* __hi, 00348 char __dfault, char *__to) const 00349 { return this->do_narrow(__lo, __hi, __dfault, __to); } 00350 00351 protected: 00352 explicit 00353 __ctype_abstract_base(size_t __refs = 0): facet(__refs) { } 00354 00355 virtual 00356 ~__ctype_abstract_base() { } 00357 00358 /** 00359 * @brief Test char_type classification. 00360 * 00361 * This function finds a mask M for @a c and compares it to mask @a m. 00362 * 00363 * do_is() is a hook for a derived facet to change the behavior of 00364 * classifying. do_is() must always return the same result for the 00365 * same input. 00366 * 00367 * @param c The char_type to find the mask of. 00368 * @param m The mask to compare against. 00369 * @return (M & m) != 0. 00370 */ 00371 virtual bool 00372 do_is(mask __m, char_type __c) const = 0; 00373 00374 /** 00375 * @brief Return a mask array. 00376 * 00377 * This function finds the mask for each char_type in the range [lo,hi) 00378 * and successively writes it to vec. vec must have as many elements 00379 * as the input. 00380 * 00381 * do_is() is a hook for a derived facet to change the behavior of 00382 * classifying. do_is() must always return the same result for the 00383 * same input. 00384 * 00385 * @param lo Pointer to start of range. 00386 * @param hi Pointer to end of range. 00387 * @param vec Pointer to an array of mask storage. 00388 * @return @a hi. 00389 */ 00390 virtual const char_type* 00391 do_is(const char_type* __lo, const char_type* __hi, 00392 mask* __vec) const = 0; 00393 00394 /** 00395 * @brief Find char_type matching mask 00396 * 00397 * This function searches for and returns the first char_type c in 00398 * [lo,hi) for which is(m,c) is true. 00399 * 00400 * do_scan_is() is a hook for a derived facet to change the behavior of 00401 * match searching. do_is() must always return the same result for the 00402 * same input. 00403 * 00404 * @param m The mask to compare against. 00405 * @param lo Pointer to start of range. 00406 * @param hi Pointer to end of range. 00407 * @return Pointer to a matching char_type if found, else @a hi. 00408 */ 00409 virtual const char_type* 00410 do_scan_is(mask __m, const char_type* __lo, 00411 const char_type* __hi) const = 0; 00412 00413 /** 00414 * @brief Find char_type not matching mask 00415 * 00416 * This function searches for and returns a pointer to the first 00417 * char_type c of [lo,hi) for which is(m,c) is false. 00418 * 00419 * do_scan_is() is a hook for a derived facet to change the behavior of 00420 * match searching. do_is() must always return the same result for the 00421 * same input. 00422 * 00423 * @param m The mask to compare against. 00424 * @param lo Pointer to start of range. 00425 * @param hi Pointer to end of range. 00426 * @return Pointer to a non-matching char_type if found, else @a hi. 00427 */ 00428 virtual const char_type* 00429 do_scan_not(mask __m, const char_type* __lo, 00430 const char_type* __hi) const = 0; 00431 00432 /** 00433 * @brief Convert to uppercase. 00434 * 00435 * This virtual function converts the char_type argument to uppercase 00436 * if possible. If not possible (for example, '2'), returns the 00437 * argument. 00438 * 00439 * do_toupper() is a hook for a derived facet to change the behavior of 00440 * uppercasing. do_toupper() must always return the same result for 00441 * the same input. 00442 * 00443 * @param c The char_type to convert. 00444 * @return The uppercase char_type if convertible, else @a c. 00445 */ 00446 virtual char_type 00447 do_toupper(char_type) const = 0; 00448 00449 /** 00450 * @brief Convert array to uppercase. 00451 * 00452 * This virtual function converts each char_type in the range [lo,hi) 00453 * to uppercase if possible. Other elements remain untouched. 00454 * 00455 * do_toupper() is a hook for a derived facet to change the behavior of 00456 * uppercasing. do_toupper() must always return the same result for 00457 * the same input. 00458 * 00459 * @param lo Pointer to start of range. 00460 * @param hi Pointer to end of range. 00461 * @return @a hi. 00462 */ 00463 virtual const char_type* 00464 do_toupper(char_type* __lo, const char_type* __hi) const = 0; 00465 00466 /** 00467 * @brief Convert to lowercase. 00468 * 00469 * This virtual function converts the argument to lowercase if 00470 * possible. If not possible (for example, '2'), returns the argument. 00471 * 00472 * do_tolower() is a hook for a derived facet to change the behavior of 00473 * lowercasing. do_tolower() must always return the same result for 00474 * the same input. 00475 * 00476 * @param c The char_type to convert. 00477 * @return The lowercase char_type if convertible, else @a c. 00478 */ 00479 virtual char_type 00480 do_tolower(char_type) const = 0; 00481 00482 /** 00483 * @brief Convert array to lowercase. 00484 * 00485 * This virtual function converts each char_type in the range [lo,hi) 00486 * to lowercase if possible. Other elements remain untouched. 00487 * 00488 * do_tolower() is a hook for a derived facet to change the behavior of 00489 * lowercasing. do_tolower() must always return the same result for 00490 * the same input. 00491 * 00492 * @param lo Pointer to start of range. 00493 * @param hi Pointer to end of range. 00494 * @return @a hi. 00495 */ 00496 virtual const char_type* 00497 do_tolower(char_type* __lo, const char_type* __hi) const = 0; 00498 00499 /** 00500 * @brief Widen char 00501 * 00502 * This virtual function converts the char to char_type using the 00503 * simplest reasonable transformation. 00504 * 00505 * do_widen() is a hook for a derived facet to change the behavior of 00506 * widening. do_widen() must always return the same result for the 00507 * same input. 00508 * 00509 * Note: this is not what you want for codepage conversions. See 00510 * codecvt for that. 00511 * 00512 * @param c The char to convert. 00513 * @return The converted char_type 00514 */ 00515 virtual char_type 00516 do_widen(char) const = 0; 00517 00518 /** 00519 * @brief Widen char array 00520 * 00521 * This function converts each char in the input to char_type using the 00522 * simplest reasonable transformation. 00523 * 00524 * do_widen() is a hook for a derived facet to change the behavior of 00525 * widening. do_widen() must always return the same result for the 00526 * same input. 00527 * 00528 * Note: this is not what you want for codepage conversions. See 00529 * codecvt for that. 00530 * 00531 * @param lo Pointer to start range. 00532 * @param hi Pointer to end of range. 00533 * @param to Pointer to the destination array. 00534 * @return @a hi. 00535 */ 00536 virtual const char* 00537 do_widen(const char* __lo, const char* __hi, 00538 char_type* __dest) 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, 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 [lo,hi) to 00565 * char using the simplest reasonable transformation and writes the 00566 * results to the destination array. For any element in the input that 00567 * cannot be converted, @a dfault is used instead. 00568 * 00569 * do_narrow() is a hook for a derived facet to change the behavior of 00570 * narrowing. do_narrow() must always return the same result for the 00571 * same input. 00572 * 00573 * Note: this is not what you want for codepage conversions. See 00574 * codecvt for that. 00575 * 00576 * @param lo Pointer to start of range. 00577 * @param hi Pointer to end of range. 00578 * @param dfault Char to use if conversion fails. 00579 * @param to Pointer to the destination array. 00580 * @return @a hi. 00581 */ 00582 virtual const char_type* 00583 do_narrow(const char_type* __lo, const char_type* __hi, 00584 char __dfault, char* __dest) const = 0; 00585 }; 00586 00587 // NB: Generic, mostly useless implementation. 00588 /** 00589 * @brief Template ctype facet 00590 * 00591 * This template class defines classification and conversion functions for 00592 * character sets. It wraps <cctype> functionality. Ctype gets used by 00593 * streams for many I/O operations. 00594 * 00595 * This template provides the protected virtual functions the developer 00596 * will have to replace in a derived class or specialization to make a 00597 * working facet. The public functions that access them are defined in 00598 * __ctype_abstract_base, to allow for implementation flexibility. See 00599 * ctype<wchar_t> for an example. The functions are documented in 00600 * __ctype_abstract_base. 00601 * 00602 * Note: implementations are provided for all the protected virtual 00603 * functions, but will likely not be useful. 00604 */ 00605 template<typename _CharT> 00606 class ctype : public __ctype_abstract_base<_CharT> 00607 { 00608 public: 00609 // Types: 00610 typedef _CharT char_type; 00611 typedef typename __ctype_abstract_base<_CharT>::mask mask; 00612 00613 /// The facet id for ctype<char_type> 00614 static locale::id id; 00615 00616 explicit 00617 ctype(size_t __refs = 0) : __ctype_abstract_base<_CharT>(__refs) { } 00618 00619 protected: 00620 virtual 00621 ~ctype(); 00622 00623 virtual bool 00624 do_is(mask __m, char_type __c) const; 00625 00626 virtual const char_type* 00627 do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const; 00628 00629 virtual const char_type* 00630 do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const; 00631 00632 virtual const char_type* 00633 do_scan_not(mask __m, const char_type* __lo, 00634 const char_type* __hi) const; 00635 00636 virtual char_type 00637 do_toupper(char_type __c) const; 00638 00639 virtual const char_type* 00640 do_toupper(char_type* __lo, const char_type* __hi) const; 00641 00642 virtual char_type 00643 do_tolower(char_type __c) const; 00644 00645 virtual const char_type* 00646 do_tolower(char_type* __lo, const char_type* __hi) const; 00647 00648 virtual char_type 00649 do_widen(char __c) const; 00650 00651 virtual const char* 00652 do_widen(const char* __lo, const char* __hi, char_type* __dest) const; 00653 00654 virtual char 00655 do_narrow(char_type, char __dfault) const; 00656 00657 virtual const char_type* 00658 do_narrow(const char_type* __lo, const char_type* __hi, 00659 char __dfault, char* __dest) const; 00660 }; 00661 00662 template<typename _CharT> 00663 locale::id ctype<_CharT>::id; 00664 00665 // 22.2.1.3 ctype<char> specialization. 00666 /** 00667 * @brief The ctype<char> specialization. 00668 * 00669 * This class defines classification and conversion functions for 00670 * the char type. It gets used by char streams for many I/O 00671 * operations. The char specialization provides a number of 00672 * optimizations as well. 00673 */ 00674 template<> 00675 class ctype<char> : public locale::facet, public ctype_base 00676 { 00677 public: 00678 // Types: 00679 /// Typedef for the template parameter char. 00680 typedef char char_type; 00681 00682 protected: 00683 // Data Members: 00684 __c_locale _M_c_locale_ctype; 00685 bool _M_del; 00686 __to_type _M_toupper; 00687 __to_type _M_tolower; 00688 const mask* _M_table; 00689 mutable char _M_widen_ok; 00690 mutable char _M_widen[1 + static_cast<unsigned char>(-1)]; 00691 mutable char _M_narrow[1 + static_cast<unsigned char>(-1)]; 00692 mutable char _M_narrow_ok; // 0 uninitialized, 1 init, 00693 // 2 memcpy can't be used 00694 00695 public: 00696 /// The facet id for ctype<char> 00697 static locale::id id; 00698 /// The size of the mask table. It is SCHAR_MAX + 1. 00699 static const size_t table_size = 1 + static_cast<unsigned char>(-1); 00700 00701 /** 00702 * @brief Constructor performs initialization. 00703 * 00704 * This is the constructor provided by the standard. 00705 * 00706 * @param table If non-zero, table is used as the per-char mask. 00707 * Else classic_table() is used. 00708 * @param del If true, passes ownership of table to this facet. 00709 * @param refs Passed to the base facet class. 00710 */ 00711 explicit 00712 ctype(const mask* __table = 0, bool __del = false, size_t __refs = 0); 00713 00714 /** 00715 * @brief Constructor performs static initialization. 00716 * 00717 * This constructor is used to construct the initial C locale facet. 00718 * 00719 * @param cloc Handle to C locale data. 00720 * @param table If non-zero, table is used as the per-char mask. 00721 * @param del If true, passes ownership of table to this facet. 00722 * @param refs Passed to the base facet class. 00723 */ 00724 explicit 00725 ctype(__c_locale __cloc, const mask* __table = 0, bool __del = false, 00726 size_t __refs = 0); 00727 00728 /** 00729 * @brief Test char classification. 00730 * 00731 * This function compares the mask table[c] to @a m. 00732 * 00733 * @param c The char to compare the mask of. 00734 * @param m The mask to compare against. 00735 * @return True if m & table[c] is true, false otherwise. 00736 */ 00737 inline bool 00738 is(mask __m, char __c) const; 00739 00740 /** 00741 * @brief Return a mask array. 00742 * 00743 * This function finds the mask for each char in the range [lo, hi) and 00744 * successively writes it to vec. vec must have as many elements as 00745 * the char array. 00746 * 00747 * @param lo Pointer to start of range. 00748 * @param hi Pointer to end of range. 00749 * @param vec Pointer to an array of mask storage. 00750 * @return @a hi. 00751 */ 00752 inline const char* 00753 is(const char* __lo, const char* __hi, mask* __vec) const; 00754 00755 /** 00756 * @brief Find char matching a mask 00757 * 00758 * This function searches for and returns the first char in [lo,hi) for 00759 * which is(m,char) is true. 00760 * 00761 * @param m The mask to compare against. 00762 * @param lo Pointer to start of range. 00763 * @param hi Pointer to end of range. 00764 * @return Pointer to a matching char if found, else @a hi. 00765 */ 00766 inline const char* 00767 scan_is(mask __m, const char* __lo, const char* __hi) const; 00768 00769 /** 00770 * @brief Find char not matching a mask 00771 * 00772 * This function searches for and returns a pointer to the first char 00773 * in [lo,hi) for which is(m,char) is false. 00774 * 00775 * @param m The mask to compare against. 00776 * @param lo Pointer to start of range. 00777 * @param hi Pointer to end of range. 00778 * @return Pointer to a non-matching char if found, else @a hi. 00779 */ 00780 inline const char* 00781 scan_not(mask __m, const char* __lo, const char* __hi) const; 00782 00783 /** 00784 * @brief Convert to uppercase. 00785 * 00786 * This function converts the char argument to uppercase if possible. 00787 * If not possible (for example, '2'), returns the argument. 00788 * 00789 * toupper() acts as if it returns ctype<char>::do_toupper(c). 00790 * do_toupper() must always return the same result for the same input. 00791 * 00792 * @param c The char to convert. 00793 * @return The uppercase char if convertible, else @a c. 00794 */ 00795 char_type 00796 toupper(char_type __c) const 00797 { return this->do_toupper(__c); } 00798 00799 /** 00800 * @brief Convert array to uppercase. 00801 * 00802 * This function converts each char in the range [lo,hi) to uppercase 00803 * if possible. Other chars remain untouched. 00804 * 00805 * toupper() acts as if it returns ctype<char>:: do_toupper(lo, hi). 00806 * do_toupper() must always return the same result for the same input. 00807 * 00808 * @param lo Pointer to first char in range. 00809 * @param hi Pointer to end of range. 00810 * @return @a hi. 00811 */ 00812 const char_type* 00813 toupper(char_type *__lo, const char_type* __hi) const 00814 { return this->do_toupper(__lo, __hi); } 00815 00816 /** 00817 * @brief Convert to lowercase. 00818 * 00819 * This function converts the char argument to lowercase if possible. 00820 * If not possible (for example, '2'), returns the argument. 00821 * 00822 * tolower() acts as if it returns ctype<char>::do_tolower(c). 00823 * do_tolower() must always return the same result for the same input. 00824 * 00825 * @param c The char to convert. 00826 * @return The lowercase char if convertible, else @a c. 00827 */ 00828 char_type 00829 tolower(char_type __c) const 00830 { return this->do_tolower(__c); } 00831 00832 /** 00833 * @brief Convert array to lowercase. 00834 * 00835 * This function converts each char in the range [lo,hi) to lowercase 00836 * if possible. Other chars remain untouched. 00837 * 00838 * tolower() acts as if it returns ctype<char>:: do_tolower(lo, hi). 00839 * do_tolower() must always return the same result for the same input. 00840 * 00841 * @param lo Pointer to first char in range. 00842 * @param hi Pointer to end of range. 00843 * @return @a hi. 00844 */ 00845 const char_type* 00846 tolower(char_type* __lo, const char_type* __hi) const 00847 { return this->do_tolower(__lo, __hi); } 00848 00849 /** 00850 * @brief Widen char 00851 * 00852 * This function converts the char to char_type using the simplest 00853 * reasonable transformation. For an underived ctype<char> facet, the 00854 * argument will be returned unchanged. 00855 * 00856 * This function works as if it returns ctype<char>::do_widen(c). 00857 * do_widen() must always return the same result for the same input. 00858 * 00859 * Note: this is not what you want for codepage conversions. See 00860 * codecvt for that. 00861 * 00862 * @param c The char to convert. 00863 * @return The converted character. 00864 */ 00865 char_type 00866 widen(char __c) const 00867 { 00868 if (_M_widen_ok) 00869 return _M_widen[static_cast<unsigned char>(__c)]; 00870 this->_M_widen_init(); 00871 return this->do_widen(__c); 00872 } 00873 00874 /** 00875 * @brief Widen char array 00876 * 00877 * This function converts each char in the input to char using the 00878 * simplest reasonable transformation. For an underived ctype<char> 00879 * facet, the argument will be copied unchanged. 00880 * 00881 * This function works as if it returns ctype<char>::do_widen(c). 00882 * do_widen() must always return the same result for the same input. 00883 * 00884 * Note: this is not what you want for codepage conversions. See 00885 * codecvt for that. 00886 * 00887 * @param lo Pointer to first char in range. 00888 * @param hi Pointer to end of range. 00889 * @param to Pointer to the destination array. 00890 * @return @a hi. 00891 */ 00892 const char* 00893 widen(const char* __lo, const char* __hi, char_type* __to) const 00894 { 00895 if (_M_widen_ok == 1) 00896 { 00897 memcpy(__to, __lo, __hi - __lo); 00898 return __hi; 00899 } 00900 if (!_M_widen_ok) 00901 _M_widen_init(); 00902 return this->do_widen(__lo, __hi, __to); 00903 } 00904 00905 /** 00906 * @brief Narrow char 00907 * 00908 * This function converts the char to char using the simplest 00909 * reasonable transformation. If the conversion fails, dfault is 00910 * returned instead. For an underived ctype<char> facet, @a c 00911 * will be returned unchanged. 00912 * 00913 * This function works as if it returns ctype<char>::do_narrow(c). 00914 * do_narrow() must always return the same result for the same input. 00915 * 00916 * Note: this is not what you want for codepage conversions. See 00917 * codecvt for that. 00918 * 00919 * @param c The char to convert. 00920 * @param dfault Char to return if conversion fails. 00921 * @return The converted character. 00922 */ 00923 char 00924 narrow(char_type __c, char __dfault) const 00925 { 00926 if (_M_narrow[static_cast<unsigned char>(__c)]) 00927 return _M_narrow[static_cast<unsigned char>(__c)]; 00928 const char __t = do_narrow(__c, __dfault); 00929 if (__t != __dfault) 00930 _M_narrow[static_cast<unsigned char>(__c)] = __t; 00931 return __t; 00932 } 00933 00934 /** 00935 * @brief Narrow char array 00936 * 00937 * This function converts each char in the input to char using the 00938 * simplest reasonable transformation and writes the results to the 00939 * destination array. For any char in the input that cannot be 00940 * converted, @a dfault is used instead. For an underived ctype<char> 00941 * facet, the argument will be copied unchanged. 00942 * 00943 * This function works as if it returns ctype<char>::do_narrow(lo, hi, 00944 * dfault, to). do_narrow() must always return the same result for the 00945 * same input. 00946 * 00947 * Note: this is not what you want for codepage conversions. See 00948 * codecvt for that. 00949 * 00950 * @param lo Pointer to start of range. 00951 * @param hi Pointer to end of range. 00952 * @param dfault Char to use if conversion fails. 00953 * @param to Pointer to the destination array. 00954 * @return @a hi. 00955 */ 00956 const char_type* 00957 narrow(const char_type* __lo, const char_type* __hi, 00958 char __dfault, char *__to) const 00959 { 00960 if (__builtin_expect(_M_narrow_ok == 1, true)) 00961 { 00962 memcpy(__to, __lo, __hi - __lo); 00963 return __hi; 00964 } 00965 if (!_M_narrow_ok) 00966 _M_narrow_init(); 00967 return this->do_narrow(__lo, __hi, __dfault, __to); 00968 } 00969 00970 protected: 00971 /// Returns a pointer to the mask table provided to the constructor, or 00972 /// the default from classic_table() if none was provided. 00973 const mask* 00974 table() const throw() 00975 { return _M_table; } 00976 00977 /// Returns a pointer to the C locale mask table. 00978 static const mask* 00979 classic_table() throw(); 00980 00981 /** 00982 * @brief Destructor. 00983 * 00984 * This function deletes table() if @a del was true in the 00985 * constructor. 00986 */ 00987 virtual 00988 ~ctype(); 00989 00990 /** 00991 * @brief Convert to uppercase. 00992 * 00993 * This virtual function converts the char argument to uppercase if 00994 * possible. If not possible (for example, '2'), returns the argument. 00995 * 00996 * do_toupper() is a hook for a derived facet to change the behavior of 00997 * uppercasing. do_toupper() must always return the same result for 00998 * the same input. 00999 * 01000 * @param c The char to convert. 01001 * @return The uppercase char if convertible, else @a c. 01002 */ 01003 virtual char_type 01004 do_toupper(char_type) const; 01005 01006 /** 01007 * @brief Convert array to uppercase. 01008 * 01009 * This virtual function converts each char in the range [lo,hi) to 01010 * uppercase if possible. Other chars remain untouched. 01011 * 01012 * do_toupper() is a hook for a derived facet to change the behavior of 01013 * uppercasing. do_toupper() must always return the same result for 01014 * the same input. 01015 * 01016 * @param lo Pointer to start of range. 01017 * @param hi Pointer to end of range. 01018 * @return @a hi. 01019 */ 01020 virtual const char_type* 01021 do_toupper(char_type* __lo, const char_type* __hi) const; 01022 01023 /** 01024 * @brief Convert to lowercase. 01025 * 01026 * This virtual function converts the char argument to lowercase if 01027 * possible. If not possible (for example, '2'), returns the argument. 01028 * 01029 * do_tolower() is a hook for a derived facet to change the behavior of 01030 * lowercasing. do_tolower() must always return the same result for 01031 * the same input. 01032 * 01033 * @param c The char to convert. 01034 * @return The lowercase char if convertible, else @a c. 01035 */ 01036 virtual char_type 01037 do_tolower(char_type) const; 01038 01039 /** 01040 * @brief Convert array to lowercase. 01041 * 01042 * This virtual function converts each char in the range [lo,hi) to 01043 * lowercase if possible. Other chars remain untouched. 01044 * 01045 * do_tolower() is a hook for a derived facet to change the behavior of 01046 * lowercasing. do_tolower() must always return the same result for 01047 * the same input. 01048 * 01049 * @param lo Pointer to first char in range. 01050 * @param hi Pointer to end of range. 01051 * @return @a hi. 01052 */ 01053 virtual const char_type* 01054 do_tolower(char_type* __lo, const char_type* __hi) const; 01055 01056 /** 01057 * @brief Widen char 01058 * 01059 * This virtual function converts the char to char using the simplest 01060 * reasonable transformation. For an underived ctype<char> facet, the 01061 * argument will be returned unchanged. 01062 * 01063 * do_widen() is a hook for a derived facet to change the behavior of 01064 * widening. do_widen() must always return the same result for the 01065 * same input. 01066 * 01067 * Note: this is not what you want for codepage conversions. See 01068 * codecvt for that. 01069 * 01070 * @param c The char to convert. 01071 * @return The converted character. 01072 */ 01073 virtual char_type 01074 do_widen(char __c) const 01075 { return __c; } 01076 01077 /** 01078 * @brief Widen char array 01079 * 01080 * This function converts each char in the range [lo,hi) to char using 01081 * the simplest reasonable transformation. For an underived 01082 * ctype<char> facet, the argument will be copied unchanged. 01083 * 01084 * do_widen() is a hook for a derived facet to change the behavior of 01085 * widening. do_widen() must always return the same result for the 01086 * same input. 01087 * 01088 * Note: this is not what you want for codepage conversions. See 01089 * codecvt for that. 01090 * 01091 * @param lo Pointer to start of range. 01092 * @param hi Pointer to end of range. 01093 * @param to Pointer to the destination array. 01094 * @return @a hi. 01095 */ 01096 virtual const char* 01097 do_widen(const char* __lo, const char* __hi, char_type* __dest) const 01098 { 01099 memcpy(__dest, __lo, __hi - __lo); 01100 return __hi; 01101 } 01102 01103 /** 01104 * @brief Narrow char 01105 * 01106 * This virtual function converts the char to char using the simplest 01107 * reasonable transformation. If the conversion fails, dfault is 01108 * returned instead. For an underived ctype<char> facet, @a c will be 01109 * returned unchanged. 01110 * 01111 * do_narrow() is a hook for a derived facet to change the behavior of 01112 * narrowing. do_narrow() must always return the same result for the 01113 * same input. 01114 * 01115 * Note: this is not what you want for codepage conversions. See 01116 * codecvt for that. 01117 * 01118 * @param c The char to convert. 01119 * @param dfault Char to return if conversion fails. 01120 * @return The converted char. 01121 */ 01122 virtual char 01123 do_narrow(char_type __c, char) const 01124 { return __c; } 01125 01126 /** 01127 * @brief Narrow char array to char array 01128 * 01129 * This virtual function converts each char in the range [lo,hi) to 01130 * char using the simplest reasonable transformation and writes the 01131 * results to the destination array. For any char in the input that 01132 * cannot be converted, @a dfault is used instead. For an underived 01133 * ctype<char> facet, the argument will be copied unchanged. 01134 * 01135 * do_narrow() is a hook for a derived facet to change the behavior of 01136 * narrowing. do_narrow() must always return the same result for the 01137 * same input. 01138 * 01139 * Note: this is not what you want for codepage conversions. See 01140 * codecvt for that. 01141 * 01142 * @param lo Pointer to start of range. 01143 * @param hi Pointer to end of range. 01144 * @param dfault Char to use if conversion fails. 01145 * @param to Pointer to the destination array. 01146 * @return @a hi. 01147 */ 01148 virtual const char_type* 01149 do_narrow(const char_type* __lo, const char_type* __hi, 01150 char, char* __dest) const 01151 { 01152 memcpy(__dest, __lo, __hi - __lo); 01153 return __hi; 01154 } 01155 01156 private: 01157 01158 void _M_widen_init() const 01159 { 01160 char __tmp[sizeof(_M_widen)]; 01161 for (size_t __i = 0; __i < sizeof(_M_widen); ++__i) 01162 __tmp[__i] = __i; 01163 do_widen(__tmp, __tmp + sizeof(__tmp), _M_widen); 01164 01165 _M_widen_ok = 1; 01166 // Set _M_widen_ok to 2 if memcpy can't be used. 01167 if (memcmp(__tmp, _M_widen, sizeof(_M_widen))) 01168 _M_widen_ok = 2; 01169 } 01170 01171 // Fill in the narrowing cache and flag whether all values are 01172 // valid or not. _M_narrow_ok is set to 2 if memcpy can't 01173 // be used. 01174 void _M_narrow_init() const 01175 { 01176 char __tmp[sizeof(_M_narrow)]; 01177 for (size_t __i = 0; __i < sizeof(_M_narrow); ++__i) 01178 __tmp[__i] = __i; 01179 do_narrow(__tmp, __tmp + sizeof(__tmp), 0, _M_narrow); 01180 01181 _M_narrow_ok = 1; 01182 if (memcmp(__tmp, _M_narrow, sizeof(_M_narrow))) 01183 _M_narrow_ok = 2; 01184 else 01185 { 01186 // Deal with the special case of zero: renarrow with a 01187 // different default and compare. 01188 char __c; 01189 do_narrow(__tmp, __tmp + 1, 1, &__c); 01190 if (__c == 1) 01191 _M_narrow_ok = 2; 01192 } 01193 } 01194 }; 01195 01196 template<> 01197 const ctype<char>& 01198 use_facet<ctype<char> >(const locale& __loc); 01199 01200 #ifdef _GLIBCXX_USE_WCHAR_T 01201 // 22.2.1.3 ctype<wchar_t> specialization 01202 /** 01203 * @brief The ctype<wchar_t> specialization. 01204 * 01205 * This class defines classification and conversion functions for the 01206 * wchar_t type. It gets used by wchar_t streams for many I/O operations. 01207 * The wchar_t specialization provides a number of optimizations as well. 01208 * 01209 * ctype<wchar_t> inherits its public methods from 01210 * __ctype_abstract_base<wchar_t>. 01211 */ 01212 template<> 01213 class ctype<wchar_t> : public __ctype_abstract_base<wchar_t> 01214 { 01215 public: 01216 // Types: 01217 /// Typedef for the template parameter wchar_t. 01218 typedef wchar_t char_type; 01219 typedef wctype_t __wmask_type; 01220 01221 protected: 01222 __c_locale _M_c_locale_ctype; 01223 01224 // Pre-computed narrowed and widened chars. 01225 bool _M_narrow_ok; 01226 char _M_narrow[128]; 01227 wint_t _M_widen[1 + static_cast<unsigned char>(-1)]; 01228 01229 // Pre-computed elements for do_is. 01230 mask _M_bit[16]; 01231 __wmask_type _M_wmask[16]; 01232 01233 public: 01234 // Data Members: 01235 /// The facet id for ctype<wchar_t> 01236 static locale::id id; 01237 01238 /** 01239 * @brief Constructor performs initialization. 01240 * 01241 * This is the constructor provided by the standard. 01242 * 01243 * @param refs Passed to the base facet class. 01244 */ 01245 explicit 01246 ctype(size_t __refs = 0); 01247 01248 /** 01249 * @brief Constructor performs static initialization. 01250 * 01251 * This constructor is used to construct the initial C locale facet. 01252 * 01253 * @param cloc Handle to C locale data. 01254 * @param refs Passed to the base facet class. 01255 */ 01256 explicit 01257 ctype(__c_locale __cloc, size_t __refs = 0); 01258 01259 protected: 01260 __wmask_type 01261 _M_convert_to_wmask(const mask __m) const; 01262 01263 /// Destructor 01264 virtual 01265 ~ctype(); 01266 01267 /** 01268 * @brief Test wchar_t classification. 01269 * 01270 * This function finds a mask M for @a c and compares it to mask @a m. 01271 * 01272 * do_is() is a hook for a derived facet to change the behavior of 01273 * classifying. do_is() must always return the same result for the 01274 * same input. 01275 * 01276 * @param c The wchar_t to find the mask of. 01277 * @param m The mask to compare against. 01278 * @return (M & m) != 0. 01279 */ 01280 virtual bool 01281 do_is(mask __m, char_type __c) const; 01282 01283 /** 01284 * @brief Return a mask array. 01285 * 01286 * This function finds the mask for each wchar_t in the range [lo,hi) 01287 * and successively writes it to vec. vec must have as many elements 01288 * as the input. 01289 * 01290 * do_is() is a hook for a derived facet to change the behavior of 01291 * classifying. do_is() must always return the same result for the 01292 * same input. 01293 * 01294 * @param lo Pointer to start of range. 01295 * @param hi Pointer to end of range. 01296 * @param vec Pointer to an array of mask storage. 01297 * @return @a hi. 01298 */ 01299 virtual const char_type* 01300 do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const; 01301 01302 /** 01303 * @brief Find wchar_t matching mask 01304 * 01305 * This function searches for and returns the first wchar_t c in 01306 * [lo,hi) for which is(m,c) is true. 01307 * 01308 * do_scan_is() is a hook for a derived facet to change the behavior of 01309 * match searching. do_is() must always return the same result for the 01310 * same input. 01311 * 01312 * @param m The mask to compare against. 01313 * @param lo Pointer to start of range. 01314 * @param hi Pointer to end of range. 01315 * @return Pointer to a matching wchar_t if found, else @a hi. 01316 */ 01317 virtual const char_type* 01318 do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const; 01319 01320 /** 01321 * @brief Find wchar_t not matching mask 01322 * 01323 * This function searches for and returns a pointer to the first 01324 * wchar_t c of [lo,hi) for which is(m,c) is false. 01325 * 01326 * do_scan_is() is a hook for a derived facet to change the behavior of 01327 * match searching. do_is() must always return the same result for the 01328 * same input. 01329 * 01330 * @param m The mask to compare against. 01331 * @param lo Pointer to start of range. 01332 * @param hi Pointer to end of range. 01333 * @return Pointer to a non-matching wchar_t if found, else @a hi. 01334 */ 01335 virtual const char_type* 01336 do_scan_not(mask __m, const char_type* __lo, 01337 const char_type* __hi) const; 01338 01339 /** 01340 * @brief Convert to uppercase. 01341 * 01342 * This virtual function converts the wchar_t argument to uppercase if 01343 * possible. If not possible (for example, '2'), returns the argument. 01344 * 01345 * do_toupper() is a hook for a derived facet to change the behavior of 01346 * uppercasing. do_toupper() must always return the same result for 01347 * the same input. 01348 * 01349 * @param c The wchar_t to convert. 01350 * @return The uppercase wchar_t if convertible, else @a c. 01351 */ 01352 virtual char_type 01353 do_toupper(char_type) const; 01354 01355 /** 01356 * @brief Convert array to uppercase. 01357 * 01358 * This virtual function converts each wchar_t in the range [lo,hi) to 01359 * uppercase if possible. Other elements remain untouched. 01360 * 01361 * do_toupper() is a hook for a derived facet to change the behavior of 01362 * uppercasing. do_toupper() must always return the same result for 01363 * the same input. 01364 * 01365 * @param lo Pointer to start of range. 01366 * @param hi Pointer to end of range. 01367 * @return @a hi. 01368 */ 01369 virtual const char_type* 01370 do_toupper(char_type* __lo, const char_type* __hi) const; 01371 01372 /** 01373 * @brief Convert to lowercase. 01374 * 01375 * This virtual function converts the argument to lowercase if 01376 * possible. If not possible (for example, '2'), returns the argument. 01377 * 01378 * do_tolower() is a hook for a derived facet to change the behavior of 01379 * lowercasing. do_tolower() must always return the same result for 01380 * the same input. 01381 * 01382 * @param c The wchar_t to convert. 01383 * @return The lowercase wchar_t if convertible, else @a c. 01384 */ 01385 virtual char_type 01386 do_tolower(char_type) const; 01387 01388 /** 01389 * @brief Convert array to lowercase. 01390 * 01391 * This virtual function converts each wchar_t in the range [lo,hi) to 01392 * lowercase if possible. Other elements remain untouched. 01393 * 01394 * do_tolower() is a hook for a derived facet to change the behavior of 01395 * lowercasing. do_tolower() must always return the same result for 01396 * the same input. 01397 * 01398 * @param lo Pointer to start of range. 01399 * @param hi Pointer to end of range. 01400 * @return @a hi. 01401 */ 01402 virtual const char_type* 01403 do_tolower(char_type* __lo, const char_type* __hi) const; 01404 01405 /** 01406 * @brief Widen char to wchar_t 01407 * 01408 * This virtual function converts the char to wchar_t using the 01409 * simplest reasonable transformation. For an underived ctype<wchar_t> 01410 * facet, the argument will be cast to wchar_t. 01411 * 01412 * do_widen() is a hook for a derived facet to change the behavior of 01413 * widening. do_widen() must always return the same result for the 01414 * same input. 01415 * 01416 * Note: this is not what you want for codepage conversions. See 01417 * codecvt for that. 01418 * 01419 * @param c The char to convert. 01420 * @return The converted wchar_t. 01421 */ 01422 virtual char_type 01423 do_widen(char) const; 01424 01425 /** 01426 * @brief Widen char array to wchar_t array 01427 * 01428 * This function converts each char in the input to wchar_t using the 01429 * simplest reasonable transformation. For an underived ctype<wchar_t> 01430 * facet, the argument will be copied, casting each element to wchar_t. 01431 * 01432 * do_widen() is a hook for a derived facet to change the behavior of 01433 * widening. do_widen() must always return the same result for the 01434 * same input. 01435 * 01436 * Note: this is not what you want for codepage conversions. See 01437 * codecvt for that. 01438 * 01439 * @param lo Pointer to start range. 01440 * @param hi Pointer to end of range. 01441 * @param to Pointer to the destination array. 01442 * @return @a hi. 01443 */ 01444 virtual const char* 01445 do_widen(const char* __lo, const char* __hi, char_type* __dest) const; 01446 01447 /** 01448 * @brief Narrow wchar_t to char 01449 * 01450 * This virtual function converts the argument to char using 01451 * the simplest reasonable transformation. If the conversion 01452 * fails, dfault is returned instead. For an underived 01453 * ctype<wchar_t> facet, @a c will be cast to char and 01454 * returned. 01455 * 01456 * do_narrow() is a hook for a derived facet to change the 01457 * behavior of narrowing. do_narrow() must always return the 01458 * same result for the same input. 01459 * 01460 * Note: this is not what you want for codepage conversions. See 01461 * codecvt for that. 01462 * 01463 * @param c The wchar_t to convert. 01464 * @param dfault Char to return if conversion fails. 01465 * @return The converted char. 01466 */ 01467 virtual char 01468 do_narrow(char_type, char __dfault) const; 01469 01470 /** 01471 * @brief Narrow wchar_t array to char array 01472 * 01473 * This virtual function converts each wchar_t in the range [lo,hi) to 01474 * char using the simplest reasonable transformation and writes the 01475 * results to the destination array. For any wchar_t in the input that 01476 * cannot be converted, @a dfault is used instead. For an underived 01477 * ctype<wchar_t> facet, the argument will be copied, casting each 01478 * element to char. 01479 * 01480 * do_narrow() is a hook for a derived facet to change the behavior of 01481 * narrowing. do_narrow() must always return the same result for the 01482 * same input. 01483 * 01484 * Note: this is not what you want for codepage conversions. See 01485 * codecvt for that. 01486 * 01487 * @param lo Pointer to start of range. 01488 * @param hi Pointer to end of range. 01489 * @param dfault Char to use if conversion fails. 01490 * @param to Pointer to the destination array. 01491 * @return @a hi. 01492 */ 01493 virtual const char_type* 01494 do_narrow(const char_type* __lo, const char_type* __hi, 01495 char __dfault, char* __dest) const; 01496 01497 // For use at construction time only. 01498 void 01499 _M_initialize_ctype(); 01500 }; 01501 01502 template<> 01503 const ctype<wchar_t>& 01504 use_facet<ctype<wchar_t> >(const locale& __loc); 01505 #endif //_GLIBCXX_USE_WCHAR_T 01506 01507 // Include host and configuration specific ctype inlines. 01508 #include <bits/ctype_inline.h> 01509 01510 /// @brief class ctype_byname [22.2.1.2]. 01511 template<typename _CharT> 01512 class ctype_byname : public ctype<_CharT> 01513 { 01514 public: 01515 typedef _CharT char_type; 01516 01517 explicit 01518 ctype_byname(const char* __s, size_t __refs = 0); 01519 01520 protected: 01521 virtual 01522 ~ctype_byname() { }; 01523 }; 01524 01525 /// 22.2.1.4 Class ctype_byname specializations. 01526 template<> 01527 ctype_byname<char>::ctype_byname(const char*, size_t refs); 01528 01529 template<> 01530 ctype_byname<wchar_t>::ctype_byname(const char*, size_t refs); 01531 01532 // 22.2.1.5 Template class codecvt 01533 #include <bits/codecvt.h> 01534 01535 // 22.2.2 The numeric category. 01536 class __num_base 01537 { 01538 public: 01539 // NB: Code depends on the order of _S_atoms_out elements. 01540 // Below are the indices into _S_atoms_out. 01541 enum 01542 { 01543 _S_ominus, 01544 _S_oplus, 01545 _S_ox, 01546 _S_oX, 01547 _S_odigits, 01548 _S_odigits_end = _S_odigits + 16, 01549 _S_oudigits = _S_odigits_end, 01550 _S_oudigits_end = _S_oudigits + 16, 01551 _S_oe = _S_odigits + 14, // For scientific notation, 'e' 01552 _S_oE = _S_oudigits + 14, // For scientific notation, 'E' 01553 _S_oend = _S_oudigits_end 01554 }; 01555 01556 // A list of valid numeric literals for output. This array 01557 // contains chars that will be passed through the current locale's 01558 // ctype<_CharT>.widen() and then used to render numbers. 01559 // For the standard "C" locale, this is 01560 // "-+xX0123456789abcdef0123456789ABCDEF". 01561 static const char* _S_atoms_out; 01562 01563 // String literal of acceptable (narrow) input, for num_get. 01564 // "-+xX0123456789abcdefABCDEF" 01565 static const char* _S_atoms_in; 01566 01567 enum 01568 { 01569 _S_iminus, 01570 _S_iplus, 01571 _S_ix, 01572 _S_iX, 01573 _S_izero, 01574 _S_ie = _S_izero + 14, 01575 _S_iE = _S_izero + 20, 01576 _S_iend = 26 01577 }; 01578 01579 // num_put 01580 // Construct and return valid scanf format for floating point types. 01581 static void 01582 _S_format_float(const ios_base& __io, char* __fptr, char __mod); 01583 }; 01584 01585 template<typename _CharT> 01586 struct __numpunct_cache : public locale::facet 01587 { 01588 const char* _M_grouping; 01589 size_t _M_grouping_size; 01590 bool _M_use_grouping; 01591 const _CharT* _M_truename; 01592 size_t _M_truename_size; 01593 const _CharT* _M_falsename; 01594 size_t _M_falsename_size; 01595 _CharT _M_decimal_point; 01596 _CharT _M_thousands_sep; 01597 01598 // A list of valid numeric literals for output: in the standard 01599 // "C" locale, this is "-+xX0123456789abcdef0123456789ABCDEF". 01600 // This array contains the chars after having been passed 01601 // through the current locale's ctype<_CharT>.widen(). 01602 _CharT _M_atoms_out[__num_base::_S_oend]; 01603 01604 // A list of valid numeric literals for input: in the standard 01605 // "C" locale, this is "-+xX0123456789abcdefABCDEF" 01606 // This array contains the chars after having been passed 01607 // through the current locale's ctype<_CharT>.widen(). 01608 _CharT _M_atoms_in[__num_base::_S_iend]; 01609 01610 bool _M_allocated; 01611 01612 __numpunct_cache(size_t __refs = 0) : facet(__refs), 01613 _M_grouping(NULL), _M_grouping_size(0), _M_use_grouping(false), 01614 _M_truename(NULL), _M_truename_size(0), _M_falsename(NULL), 01615 _M_falsename_size(0), _M_decimal_point(_CharT()), 01616 _M_thousands_sep(_CharT()), _M_allocated(false) 01617 { } 01618 01619 ~__numpunct_cache(); 01620 01621 void 01622 _M_cache(const locale& __loc); 01623 01624 private: 01625 __numpunct_cache& 01626 operator=(const __numpunct_cache&); 01627 01628 explicit 01629 __numpunct_cache(const __numpunct_cache&); 01630 }; 01631 01632 template<typename _CharT> 01633 __numpunct_cache<_CharT>::~__numpunct_cache() 01634 { 01635 if (_M_allocated) 01636 { 01637 delete [] _M_grouping; 01638 delete [] _M_truename; 01639 delete [] _M_falsename; 01640 } 01641 } 01642 01643 /** 01644 * @brief Numpunct facet. 01645 * 01646 * This facet stores several pieces of information related to printing and 01647 * scanning numbers, such as the decimal point character. It takes a 01648 * template parameter specifying the char type. The numpunct facet is 01649 * used by streams for many I/O operations involving numbers. 01650 * 01651 * The numpunct template uses protected virtual functions to provide the 01652 * actual results. The public accessors forward the call to the virtual 01653 * functions. These virtual functions are hooks for developers to 01654 * implement the behavior they require from a numpunct facet. 01655 */ 01656 template<typename _CharT> 01657 class numpunct : public locale::facet 01658 { 01659 public: 01660 // Types: 01661 //@{ 01662 /// Public typedefs 01663 typedef _CharT char_type; 01664 typedef basic_string<_CharT> string_type; 01665 //@} 01666 typedef __numpunct_cache<_CharT> __cache_type; 01667 01668 protected: 01669 __cache_type* _M_data; 01670 01671 public: 01672 /// Numpunct facet id. 01673 static locale::id id; 01674 01675 /** 01676 * @brief Numpunct constructor. 01677 * 01678 * @param refs Refcount to pass to the base class. 01679 */ 01680 explicit 01681 numpunct(size_t __refs = 0) : facet(__refs), _M_data(NULL) 01682 { _M_initialize_numpunct(); } 01683 01684 /** 01685 * @brief Internal constructor. Not for general use. 01686 * 01687 * This is a constructor for use by the library itself to set up the 01688 * predefined locale facets. 01689 * 01690 * @param cache __numpunct_cache object. 01691 * @param refs Refcount to pass to the base class. 01692 */ 01693 explicit 01694 numpunct(__cache_type* __cache, size_t __refs = 0) 01695 : facet(__refs), _M_data(__cache) 01696 { _M_initialize_numpunct(); } 01697 01698 /** 01699 * @brief Internal constructor. Not for general use. 01700 * 01701 * This is a constructor for use by the library itself to set up new 01702 * locales. 01703 * 01704 * @param cloc The "C" locale. 01705 * @param refs Refcount to pass to the base class. 01706 */ 01707 explicit 01708 numpunct(__c_locale __cloc, size_t __refs = 0) 01709 : facet(__refs), _M_data(NULL) 01710 { _M_initialize_numpunct(__cloc); } 01711 01712 /** 01713 * @brief Return decimal point character. 01714 * 01715 * This function returns a char_type to use as a decimal point. It 01716 * does so by returning returning 01717 * numpunct<char_type>::do_decimal_point(). 01718 * 01719 * @return @a char_type representing a decimal point. 01720 */ 01721 char_type 01722 decimal_point() const 01723 { return this->do_decimal_point(); } 01724 01725 /** 01726 * @brief Return thousands separator character. 01727 * 01728 * This function returns a char_type to use as a thousands 01729 * separator. It does so by returning returning 01730 * numpunct<char_type>::do_thousands_sep(). 01731 * 01732 * @return char_type representing a thousands separator. 01733 */ 01734 char_type 01735 thousands_sep() const 01736 { return this->do_thousands_sep(); } 01737 01738 /** 01739 * @brief Return grouping specification. 01740 * 01741 * This function returns a string representing groupings for the 01742 * integer part of a number. Groupings indicate where thousands 01743 * separators should be inserted in the integer part of a number. 01744 * 01745 * Each char in the return string is interpret as an integer 01746 * rather than a character. These numbers represent the number 01747 * of digits in a group. The first char in the string 01748 * represents the number of digits in the least significant 01749 * group. If a char is negative, it indicates an unlimited 01750 * number of digits for the group. If more chars from the 01751 * string are required to group a number, the last char is used 01752 * repeatedly. 01753 * 01754 * For example, if the grouping() returns "\003\002" and is 01755 * applied to the number 123456789, this corresponds to 01756 * 12,34,56,789. Note that if the string was "32", this would 01757 * put more than 50 digits into the least significant group if 01758 * the character set is ASCII. 01759 * 01760 * The string is returned by calling 01761 * numpunct<char_type>::do_grouping(). 01762 * 01763 * @return string representing grouping specification. 01764 */ 01765 string 01766 grouping() const 01767 { return this->do_grouping(); } 01768 01769 /** 01770 * @brief Return string representation of bool true. 01771 * 01772 * This function returns a string_type containing the text 01773 * representation for true bool variables. It does so by calling 01774 * numpunct<char_type>::do_truename(). 01775 * 01776 * @return string_type representing printed form of true. 01777 */ 01778 string_type 01779 truename() const 01780 { return this->do_truename(); } 01781 01782 /** 01783 * @brief Return string representation of bool false. 01784 * 01785 * This function returns a string_type containing the text 01786 * representation for false bool variables. It does so by calling 01787 * numpunct<char_type>::do_falsename(). 01788 * 01789 * @return string_type representing printed form of false. 01790 */ 01791 string_type 01792 falsename() const 01793 { return this->do_falsename(); } 01794 01795 protected: 01796 /// Destructor. 01797 virtual 01798 ~numpunct(); 01799 01800 /** 01801 * @brief Return decimal point character. 01802 * 01803 * Returns a char_type to use as a decimal point. This function is a 01804 * hook for derived classes to change the value returned. 01805 * 01806 * @return @a char_type representing a decimal point. 01807 */ 01808 virtual char_type 01809 do_decimal_point() const 01810 { return _M_data->_M_decimal_point; } 01811 01812 /** 01813 * @brief Return thousands separator character. 01814 * 01815 * Returns a char_type to use as a thousands separator. This function 01816 * is a hook for derived classes to change the value returned. 01817 * 01818 * @return @a char_type representing a thousands separator. 01819 */ 01820 virtual char_type 01821 do_thousands_sep() const 01822 { return _M_data->_M_thousands_sep; } 01823 01824 /** 01825 * @brief Return grouping specification. 01826 * 01827 * Returns a string representing groupings for the integer part of a 01828 * number. This function is a hook for derived classes to change the 01829 * value returned. @see grouping() for details. 01830 * 01831 * @return String representing grouping specification. 01832 */ 01833 virtual string 01834 do_grouping() const 01835 { return _M_data->_M_grouping; } 01836 01837 /** 01838 * @brief Return string representation of bool true. 01839 * 01840 * Returns a string_type containing the text representation for true 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 true. 01845 */ 01846 virtual string_type 01847 do_truename() const 01848 { return _M_data->_M_truename; } 01849 01850 /** 01851 * @brief Return string representation of bool false. 01852 * 01853 * Returns a string_type containing the text representation for false 01854 * bool variables. This function is a hook for derived classes to 01855 * change the value returned. 01856 * 01857 * @return string_type representing printed form of false. 01858 */ 01859 virtual string_type 01860 do_falsename() const 01861 { return _M_data->_M_falsename; } 01862 01863 // For use at construction time only. 01864 void 01865 _M_initialize_numpunct(__c_locale __cloc = NULL); 01866 }; 01867 01868 template<typename _CharT> 01869 locale::id numpunct<_CharT>::id; 01870 01871 template<> 01872 numpunct<char>::~numpunct(); 01873 01874 template<> 01875 void 01876 numpunct<char>::_M_initialize_numpunct(__c_locale __cloc); 01877 01878 #ifdef _GLIBCXX_USE_WCHAR_T 01879 template<> 01880 numpunct<wchar_t>::~numpunct(); 01881 01882 template<> 01883 void 01884 numpunct<wchar_t>::_M_initialize_numpunct(__c_locale __cloc); 01885 #endif 01886 01887 /// @brief class numpunct_byname [22.2.3.2]. 01888 template<typename _CharT> 01889 class numpunct_byname : public numpunct<_CharT> 01890 { 01891 public: 01892 typedef _CharT char_type; 01893 typedef basic_string<_CharT> string_type; 01894 01895 explicit 01896 numpunct_byname(const char* __s, size_t __refs = 0) 01897 : numpunct<_CharT>(__refs) 01898 { 01899 if (std::strcmp(__s, "C") != 0 && std::strcmp(__s, "POSIX") != 0) 01900 { 01901 __c_locale __tmp; 01902 this->_S_create_c_locale(__tmp, __s); 01903 this->_M_initialize_numpunct(__tmp); 01904 this->_S_destroy_c_locale(__tmp); 01905 } 01906 } 01907 01908 protected: 01909 virtual 01910 ~numpunct_byname() { } 01911 }; 01912 01913 _GLIBCXX_BEGIN_LDBL_NAMESPACE 01914 /** 01915 * @brief Facet for parsing number strings. 01916 * 01917 * This facet encapsulates the code to parse and return a number 01918 * from a string. It is used by the istream numeric extraction 01919 * operators. 01920 * 01921 * The num_get template uses protected virtual functions to provide the 01922 * actual results. The public accessors forward the call to the virtual 01923 * functions. These virtual functions are hooks for developers to 01924 * implement the behavior they require from the num_get facet. 01925 */ 01926 template<typename _CharT, typename _InIter> 01927 class num_get : public locale::facet 01928 { 01929 public: 01930 // Types: 01931 //@{ 01932 /// Public typedefs 01933 typedef _CharT char_type; 01934 typedef _InIter iter_type; 01935 //@} 01936 01937 /// Numpunct facet id. 01938 static locale::id id; 01939 01940 /** 01941 * @brief Constructor performs initialization. 01942 * 01943 * This is the constructor provided by the standard. 01944 * 01945 * @param refs Passed to the base facet class. 01946 */ 01947 explicit 01948 num_get(size_t __refs = 0) : facet(__refs) { } 01949 01950 /** 01951 * @brief Numeric parsing. 01952 * 01953 * Parses the input stream into the bool @a v. It does so by calling 01954 * num_get::do_get(). 01955 * 01956 * If ios_base::boolalpha is set, attempts to read 01957 * ctype<CharT>::truename() or ctype<CharT>::falsename(). Sets 01958 * @a v to true or false if successful. Sets err to 01959 * ios_base::failbit if reading the string fails. Sets err to 01960 * ios_base::eofbit if the stream is emptied. 01961 * 01962 * If ios_base::boolalpha is not set, proceeds as with reading a long, 01963 * except if the value is 1, sets @a v to true, if the value is 0, sets 01964 * @a v to false, and otherwise set err to ios_base::failbit. 01965 * 01966 * @param in Start of input stream. 01967 * @param end End of input stream. 01968 * @param io Source of locale and flags. 01969 * @param err Error flags to set. 01970 * @param v Value to format and insert. 01971 * @return Iterator after reading. 01972 */ 01973 iter_type 01974 get(iter_type __in, iter_type __end, ios_base& __io, 01975 ios_base::iostate& __err, bool& __v) const 01976 { return this->do_get(__in, __end, __io, __err, __v); } 01977 01978 //@{ 01979 /** 01980 * @brief Numeric parsing. 01981 * 01982 * Parses the input stream into the integral variable @a v. It does so 01983 * by calling num_get::do_get(). 01984 * 01985 * Parsing is affected by the flag settings in @a io. 01986 * 01987 * The basic parse is affected by the value of io.flags() & 01988 * ios_base::basefield. If equal to ios_base::oct, parses like the 01989 * scanf %o specifier. Else if equal to ios_base::hex, parses like %X 01990 * specifier. Else if basefield equal to 0, parses like the %i 01991 * specifier. Otherwise, parses like %d for signed and %u for unsigned 01992 * types. The matching type length modifier is also used. 01993 * 01994 * Digit grouping is intrepreted according to numpunct::grouping() and 01995 * numpunct::thousands_sep(). If the pattern of digit groups isn't 01996 * consistent, sets err to ios_base::failbit. 01997 * 01998 * If parsing the string yields a valid value for @a v, @a v is set. 01999 * Otherwise, sets err to ios_base::failbit and leaves @a v unaltered. 02000 * Sets err to ios_base::eofbit if the stream is emptied. 02001 * 02002 * @param in Start of input stream. 02003 * @param end End of input stream. 02004 * @param io Source of locale and flags. 02005 * @param err Error flags to set. 02006 * @param v Value to format and insert. 02007 * @return Iterator after reading. 02008 */ 02009 iter_type 02010 get(iter_type __in, iter_type __end, ios_base& __io, 02011 ios_base::iostate& __err, long& __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 short& __v) const 02017 { return this->do_get(__in, __end, __io, __err, __v); } 02018 02019 iter_type 02020 get(iter_type __in, iter_type __end, ios_base& __io, 02021 ios_base::iostate& __err, unsigned int& __v) const 02022 { return this->do_get(__in, __end, __io, __err, __v); } 02023 02024 iter_type 02025 get(iter_type __in, iter_type __end, ios_base& __io, 02026 ios_base::iostate& __err, unsigned long& __v) const 02027 { return this->do_get(__in, __end, __io, __err, __v); } 02028 02029 #ifdef _GLIBCXX_USE_LONG_LONG 02030 iter_type 02031 get(iter_type __in, iter_type __end, ios_base& __io, 02032 ios_base::iostate& __err, long long& __v) const 02033 { return this->do_get(__in, __end, __io, __err, __v); } 02034 02035 iter_type 02036 get(iter_type __in, iter_type __end, ios_base& __io, 02037 ios_base::iostate& __err, unsigned long long& __v) const 02038 { return this->do_get(__in, __end, __io, __err, __v); } 02039 #endif 02040 //@} 02041 02042 //@{ 02043 /** 02044 * @brief Numeric parsing. 02045 * 02046 * Parses the input stream into the integral variable @a v. It does so 02047 * by calling num_get::do_get(). 02048 * 02049 * The input characters are parsed like the scanf %g specifier. The 02050 * matching type length modifier is also used. 02051 * 02052 * The decimal point character used is numpunct::decimal_point(). 02053 * Digit grouping is intrepreted according to numpunct::grouping() and 02054 * numpunct::thousands_sep(). If the pattern of digit groups isn't 02055 * consistent, sets err to ios_base::failbit. 02056 * 02057 * If parsing the string yields a valid value for @a v, @a v is set. 02058 * Otherwise, sets err to ios_base::failbit and leaves @a v unaltered. 02059 * Sets err to ios_base::eofbit if the stream is emptied. 02060 * 02061 * @param in Start of input stream. 02062 * @param end End of input stream. 02063 * @param io Source of locale and flags. 02064 * @param err Error flags to set. 02065 * @param v Value to format and insert. 02066 * @return Iterator after reading. 02067 */ 02068 iter_type 02069 get(iter_type __in, iter_type __end, ios_base& __io, 02070 ios_base::iostate& __err, float& __v) const 02071 { return this->do_get(__in, __end, __io, __err, __v); } 02072 02073 iter_type 02074 get(iter_type __in, iter_type __end, ios_base& __io, 02075 ios_base::iostate& __err, double& __v) const 02076 { return this->do_get(__in, __end, __io, __err, __v); } 02077 02078 iter_type 02079 get(iter_type __in, iter_type __end, ios_base& __io, 02080 ios_base::iostate& __err, long double& __v) const 02081 { return this->do_get(__in, __end, __io, __err, __v); } 02082 //@} 02083 02084 /** 02085 * @brief Numeric parsing. 02086 * 02087 * Parses the input stream into the pointer variable @a v. It does so 02088 * by calling num_get::do_get(). 02089 * 02090 * The input characters are parsed like the scanf %p specifier. 02091 * 02092 * Digit grouping is intrepreted according to numpunct::grouping() and 02093 * numpunct::thousands_sep(). If the pattern of digit groups isn't 02094 * consistent, sets err to ios_base::failbit. 02095 * 02096 * Note that the digit grouping effect for pointers is a bit ambiguous 02097 * in the standard and shouldn't be relied on. See DR 344. 02098 * 02099 * If parsing the string yields a valid value for @a v, @a v is set. 02100 * Otherwise, sets err to ios_base::failbit and leaves @a v unaltered. 02101 * Sets err to ios_base::eofbit if the stream is emptied. 02102 * 02103 * @param in Start of input stream. 02104 * @param end End of input stream. 02105 * @param io Source of locale and flags. 02106 * @param err Error flags to set. 02107 * @param v Value to format and insert. 02108 * @return Iterator after reading. 02109 */ 02110 iter_type 02111 get(iter_type __in, iter_type __end, ios_base& __io, 02112 ios_base::iostate& __err, void*& __v) const 02113 { return this->do_get(__in, __end, __io, __err, __v); } 02114 02115 protected: 02116 /// Destructor. 02117 virtual ~num_get() { } 02118 02119 iter_type 02120 _M_extract_float(iter_type, iter_type, ios_base&, ios_base::iostate&, 02121 string& __xtrc) const; 02122 02123 template<typename _ValueT> 02124 iter_type 02125 _M_extract_int(iter_type, iter_type, ios_base&, ios_base::iostate&, 02126 _ValueT& __v) const; 02127 02128 //@{ 02129 /** 02130 * @brief Numeric parsing. 02131 * 02132 * Parses the input stream into the variable @a v. This function is a 02133 * hook for derived classes to change the value returned. @see get() 02134 * for more details. 02135 * 02136 * @param in Start of input stream. 02137 * @param end End of input stream. 02138 * @param io Source of locale and flags. 02139 * @param err Error flags to set. 02140 * @param v Value to format and insert. 02141 * @return Iterator after reading. 02142 */ 02143 virtual iter_type 02144 do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, bool&) const; 02145 02146 02147 virtual iter_type 02148 do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, long&) const; 02149 02150 virtual iter_type 02151 do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err, 02152 unsigned short&) const; 02153 02154 virtual iter_type 02155 do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err, 02156 unsigned int&) const; 02157 02158 virtual iter_type 02159 do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err, 02160 unsigned long&) const; 02161 02162 #ifdef _GLIBCXX_USE_LONG_LONG 02163 virtual iter_type 02164 do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err, 02165 long long&) const; 02166 02167 virtual iter_type 02168 do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err, 02169 unsigned long long&) const; 02170 #endif 02171 02172 virtual iter_type 02173 do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err, 02174 float&) const; 02175 02176 virtual iter_type 02177 do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err, 02178 double&) const; 02179 02180 // XXX GLIBCXX_ABI Deprecated 02181 #if defined _GLIBCXX_LONG_DOUBLE_COMPAT && defined __LONG_DOUBLE_128__ 02182 virtual iter_type 02183 __do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err, 02184 double&) const; 02185 #else 02186 virtual iter_type 02187 do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err, 02188 long double&) const; 02189 #endif 02190 02191 virtual iter_type 02192 do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err, 02193 void*&) const; 02194 02195 // XXX GLIBCXX_ABI Deprecated 02196 #if defined _GLIBCXX_LONG_DOUBLE_COMPAT && defined __LONG_DOUBLE_128__ 02197 virtual iter_type 02198 do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err, 02199 long double&) const; 02200 #endif 02201 //@} 02202 }; 02203 02204 template<typename _CharT, typename _InIter> 02205 locale::id num_get<_CharT, _InIter>::id; 02206 02207 02208 /** 02209 * @brief Facet for converting numbers to strings. 02210 * 02211 * This facet encapsulates the code to convert a number to a string. It is 02212 * used by the ostream numeric insertion operators. 02213 * 02214 * The num_put template uses protected virtual functions to provide the 02215 * actual results. The public accessors forward the call to the virtual 02216 * functions. These virtual functions are hooks for developers to 02217 * implement the behavior they require from the num_put facet. 02218 */ 02219 template<typename _CharT, typename _OutIter> 02220 class num_put : public locale::facet 02221 { 02222 public: 02223 // Types: 02224 //@{ 02225 /// Public typedefs 02226 typedef _CharT char_type; 02227 typedef _OutIter iter_type; 02228 //@} 02229 02230 /// Numpunct facet id. 02231 static locale::id id; 02232 02233 /** 02234 * @brief Constructor performs initialization. 02235 * 02236 * This is the constructor provided by the standard. 02237 * 02238 * @param refs Passed to the base facet class. 02239 */ 02240 explicit 02241 num_put(size_t __refs = 0) : facet(__refs) { } 02242 02243 /** 02244 * @brief Numeric formatting. 02245 * 02246 * Formats the boolean @a v and inserts it into a stream. It does so 02247 * by calling num_put::do_put(). 02248 * 02249 * If ios_base::boolalpha is set, writes ctype<CharT>::truename() or 02250 * ctype<CharT>::falsename(). Otherwise formats @a v as an int. 02251 * 02252 * @param s Stream to write to. 02253 * @param io Source of locale and flags. 02254 * @param fill Char_type to use for filling. 02255 * @param v Value to format and insert. 02256 * @return Iterator after writing. 02257 */ 02258 iter_type 02259 put(iter_type __s, ios_base& __f, char_type __fill, bool __v) const 02260 { return this->do_put(__s, __f, __fill, __v); } 02261 02262 //@{ 02263 /** 02264 * @brief Numeric formatting. 02265 * 02266 * Formats the integral value @a v and inserts it into a 02267 * stream. It does so by calling num_put::do_put(). 02268 * 02269 * Formatting is affected by the flag settings in @a io. 02270 * 02271 * The basic format is affected by the value of io.flags() & 02272 * ios_base::basefield. If equal to ios_base::oct, formats like the 02273 * printf %o specifier. Else if equal to ios_base::hex, formats like 02274 * %x or %X with ios_base::uppercase unset or set respectively. 02275 * Otherwise, formats like %d, %ld, %lld for signed and %u, %lu, %llu 02276 * for unsigned values. Note that if both oct and hex are set, neither 02277 * will take effect. 02278 * 02279 * If ios_base::showpos is set, '+' is output before positive values. 02280 * If ios_base::showbase is set, '0' precedes octal values (except 0) 02281 * and '0[xX]' precedes hex values. 02282 * 02283 * Thousands separators are inserted according to numpunct::grouping() 02284 * and numpunct::thousands_sep(). The decimal point character used is 02285 * numpunct::decimal_point(). 02286 * 02287 * If io.width() is non-zero, enough @a fill characters are inserted to 02288 * make the result at least that wide. If 02289 * (io.flags() & ios_base::adjustfield) == ios_base::left, result is 02290 * padded at the end. If ios_base::internal, then padding occurs 02291 * immediately after either a '+' or '-' or after '0x' or '0X'. 02292 * Otherwise, padding occurs at the beginning. 02293 * 02294 * @param s Stream to write to. 02295 * @param io Source of locale and flags. 02296 * @param fill Char_type to use for filling. 02297 * @param v Value to format and insert. 02298 * @return Iterator after writing. 02299 */ 02300 iter_type 02301 put(iter_type __s, ios_base& __f, char_type __fill, long __v) const 02302 { return this->do_put(__s, __f, __fill, __v); } 02303 02304 iter_type 02305 put(iter_type __s, ios_base& __f, char_type __fill, 02306 unsigned long __v) const 02307 { return this->do_put(__s, __f, __fill, __v); } 02308 02309 #ifdef _GLIBCXX_USE_LONG_LONG 02310 iter_type 02311 put(iter_type __s, ios_base& __f, char_type __fill, long long __v) const 02312 { return this->do_put(__s, __f, __fill, __v); } 02313 02314 iter_type 02315 put(iter_type __s, ios_base& __f, char_type __fill, 02316 unsigned long long __v) const 02317 { return this->do_put(__s, __f, __fill, __v); } 02318 #endif 02319 //@} 02320 02321 //@{ 02322 /** 02323 * @brief Numeric formatting. 02324 * 02325 * Formats the floating point value @a v and inserts it into a stream. 02326 * It does so by calling num_put::do_put(). 02327 * 02328 * Formatting is affected by the flag settings in @a io. 02329 * 02330 * The basic format is affected by the value of io.flags() & 02331 * ios_base::floatfield. If equal to ios_base::fixed, formats like the 02332 * printf %f specifier. Else if equal to ios_base::scientific, formats 02333 * like %e or %E with ios_base::uppercase unset or set respectively. 02334 * Otherwise, formats like %g or %G depending on uppercase. Note that 02335 * if both fixed and scientific are set, the effect will also be like 02336 * %g or %G. 02337 * 02338 * The output precision is given by io.precision(). This precision is 02339 * capped at numeric_limits::digits10 + 2 (different for double and 02340 * long double). The default precision is 6. 02341 * 02342 * If ios_base::showpos is set, '+' is output before positive values. 02343 * If ios_base::showpoint is set, a decimal point will always be 02344 * output. 02345 * 02346 * Thousands separators are inserted according to numpunct::grouping() 02347 * and numpunct::thousands_sep(). The decimal point character used is 02348 * numpunct::decimal_point(). 02349 * 02350 * If io.width() is non-zero, enough @a fill characters are inserted to 02351 * make the result at least that wide. If 02352 * (io.flags() & ios_base::adjustfield) == ios_base::left, result is 02353 * padded at the end. If ios_base::internal, then padding occurs 02354 * immediately after either a '+' or '-' or after '0x' or '0X'. 02355 * Otherwise, padding occurs at the beginning. 02356 * 02357 * @param s Stream to write to. 02358 * @param io Source of locale and flags. 02359 * @param fill Char_type to use for filling. 02360 * @param v Value to format and insert. 02361 * @return Iterator after writing. 02362 */ 02363 iter_type 02364 put(iter_type __s, ios_base& __f, char_type __fill, double __v) const 02365 { return this->do_put(__s, __f, __fill, __v); } 02366 02367 iter_type 02368 put(iter_type __s, ios_base& __f, char_type __fill, 02369 long double __v) const 02370 { return this->do_put(__s, __f, __fill, __v); } 02371 //@} 02372 02373 /** 02374 * @brief Numeric formatting. 02375 * 02376 * Formats the pointer value @a v and inserts it into a stream. It 02377 * does so by calling num_put::do_put(). 02378 * 02379 * This function formats @a v as an unsigned long with ios_base::hex 02380 * and ios_base::showbase set. 02381 * 02382 * @param s Stream to write to. 02383 * @param io Source of locale and flags. 02384 * @param fill Char_type to use for filling. 02385 * @param v Value to format and insert. 02386 * @return Iterator after writing. 02387 */ 02388 iter_type 02389 put(iter_type __s, ios_base& __f, char_type __fill, 02390 const void* __v) const 02391 { return this->do_put(__s, __f, __fill, __v); } 02392 02393 protected: 02394 template<typename _ValueT> 02395 iter_type 02396 _M_insert_float(iter_type, ios_base& __io, char_type __fill, 02397 char __mod, _ValueT __v) const; 02398 02399 void 02400 _M_group_float(const char* __grouping, size_t __grouping_size, 02401 char_type __sep, const char_type* __p, char_type* __new, 02402 char_type* __cs, int& __len) const; 02403 02404 template<typename _ValueT> 02405 iter_type 02406 _M_insert_int(iter_type, ios_base& __io, char_type __fill, 02407 _ValueT __v) const; 02408 02409 void 02410 _M_group_int(const char* __grouping, size_t __grouping_size, 02411 char_type __sep, ios_base& __io, char_type* __new, 02412 char_type* __cs, int& __len) const; 02413 02414 void 02415 _M_pad(char_type __fill, streamsize __w, ios_base& __io, 02416 char_type* __new, const char_type* __cs, int& __len) const; 02417 02418 /// Destructor. 02419 virtual 02420 ~num_put() { }; 02421 02422 //@{ 02423 /** 02424 * @brief Numeric formatting. 02425 * 02426 * These functions do the work of formatting numeric values and 02427 * inserting them into a stream. This function is a hook for derived 02428 * classes to change the value returned. 02429 * 02430 * @param s Stream to write to. 02431 * @param io Source of locale and flags. 02432 * @param fill Char_type to use for filling. 02433 * @param v Value to format and insert. 02434 * @return Iterator after writing. 02435 */ 02436 virtual iter_type 02437 do_put(iter_type, ios_base&, char_type __fill, bool __v) const; 02438 02439 virtual iter_type 02440 do_put(iter_type, ios_base&, char_type __fill, long __v) const; 02441 02442 virtual iter_type 02443 do_put(iter_type, ios_base&, char_type __fill, unsigned long) const; 02444 02445 #ifdef _GLIBCXX_USE_LONG_LONG 02446 virtual iter_type 02447 do_put(iter_type, ios_base&, char_type __fill, long long __v) const; 02448 02449 virtual iter_type 02450 do_put(iter_type, ios_base&, char_type __fill, unsigned long long) const; 02451 #endif 02452 02453 virtual iter_type 02454 do_put(iter_type, ios_base&, char_type __fill, double __v) const; 02455 02456 // XXX GLIBCXX_ABI Deprecated 02457 #if defined _GLIBCXX_LONG_DOUBLE_COMPAT && defined __LONG_DOUBLE_128__ 02458 virtual iter_type 02459 __do_put(iter_type, ios_base&, char_type __fill, double __v) const; 02460 #else 02461 virtual iter_type 02462 do_put(iter_type, ios_base&, char_type __fill, long double __v) const; 02463 #endif 02464 02465 virtual iter_type 02466 do_put(iter_type, ios_base&, char_type __fill, const void* __v) const; 02467 02468 // XXX GLIBCXX_ABI Deprecated 02469 #if defined _GLIBCXX_LONG_DOUBLE_COMPAT && defined __LONG_DOUBLE_128__ 02470 virtual iter_type 02471 do_put(iter_type, ios_base&, char_type __fill, long double __v) const; 02472 #endif 02473 //@} 02474 }; 02475 02476 template <typename _CharT, typename _OutIter> 02477 locale::id num_put<_CharT, _OutIter>::id; 02478 02479 _GLIBCXX_END_LDBL_NAMESPACE 02480 02481 /** 02482 * @brief Facet for localized string comparison. 02483 * 02484 * This facet encapsulates the code to compare strings in a localized 02485 * manner. 02486 * 02487 * The collate template uses protected virtual functions to provide 02488 * the actual results. The public accessors forward the call to 02489 * the virtual functions. These virtual functions are hooks for 02490 * developers to implement the behavior they require from the 02491 * collate facet. 02492 */ 02493 template<typename _CharT> 02494 class collate : public locale::facet 02495 { 02496 public: 02497 // Types: 02498 //@{ 02499 /// Public typedefs 02500 typedef _CharT char_type; 02501 typedef basic_string<_CharT> string_type; 02502 //@} 02503 02504 protected: 02505 // Underlying "C" library locale information saved from 02506 // initialization, needed by collate_byname as well. 02507 __c_locale _M_c_locale_collate; 02508 02509 public: 02510 /// Numpunct facet id. 02511 static locale::id id; 02512 02513 /** 02514 * @brief Constructor performs initialization. 02515 * 02516 * This is the constructor provided by the standard. 02517 * 02518 * @param refs Passed to the base facet class. 02519 */ 02520 explicit 02521 collate(size_t __refs = 0) 02522 : facet(__refs), _M_c_locale_collate(_S_get_c_locale()) 02523 { } 02524 02525 /** 02526 * @brief Internal constructor. Not for general use. 02527 * 02528 * This is a constructor for use by the library itself to set up new 02529 * locales. 02530 * 02531 * @param cloc The "C" locale. 02532 * @param refs Passed to the base facet class. 02533 */ 02534 explicit 02535 collate(__c_locale __cloc, size_t __refs = 0) 02536 : facet(__refs), _M_c_locale_collate(_S_clone_c_locale(__cloc)) 02537 { } 02538 02539 /** 02540 * @brief Compare two strings. 02541 * 02542 * This function compares two strings and returns the result by calling 02543 * collate::do_compare(). 02544 * 02545 * @param lo1 Start of string 1. 02546 * @param hi1 End of string 1. 02547 * @param lo2 Start of string 2. 02548 * @param hi2 End of string 2. 02549 * @return 1 if string1 > string2, -1 if string1 < string2, else 0. 02550 */ 02551 int 02552 compare(const _CharT* __lo1, const _CharT* __hi1, 02553 const _CharT* __lo2, const _CharT* __hi2) const 02554 { return this->do_compare(__lo1, __hi1, __lo2, __hi2); } 02555 02556 /** 02557 * @brief Transform string to comparable form. 02558 * 02559 * This function is a wrapper for strxfrm functionality. It takes the 02560 * input string and returns a modified string that can be directly 02561 * compared to other transformed strings. In the "C" locale, this 02562 * function just returns a copy of the input string. In some other 02563 * locales, it may replace two chars with one, change a char for 02564 * another, etc. It does so by returning collate::do_transform(). 02565 * 02566 * @param lo Start of string. 02567 * @param hi End of string. 02568 * @return Transformed string_type. 02569 */ 02570 string_type 02571 transform(const _CharT* __lo, const _CharT* __hi) const 02572 { return this->do_transform(__lo, __hi); } 02573 02574 /** 02575 * @brief Return hash of a string. 02576 * 02577 * This function computes and returns a hash on the input string. It 02578 * does so by returning collate::do_hash(). 02579 * 02580 * @param lo Start of string. 02581 * @param hi End of string. 02582 * @return Hash value. 02583 */ 02584 long 02585 hash(const _CharT* __lo, const _CharT* __hi) const 02586 { return this->do_hash(__lo, __hi); } 02587 02588 // Used to abstract out _CharT bits in virtual member functions, below. 02589 int 02590 _M_compare(const _CharT*, const _CharT*) const; 02591 02592 size_t 02593 _M_transform(_CharT*, const _CharT*, size_t) const; 02594 02595 protected: 02596 /// Destructor. 02597 virtual 02598 ~collate() 02599 { _S_destroy_c_locale(_M_c_locale_collate); } 02600 02601 /** 02602 * @brief Compare two strings. 02603 * 02604 * This function is a hook for derived classes to change the value 02605 * returned. @see compare(). 02606 * 02607 * @param lo1 Start of string 1. 02608 * @param hi1 End of string 1. 02609 * @param lo2 Start of string 2. 02610 * @param hi2 End of string 2. 02611 * @return 1 if string1 > string2, -1 if string1 < string2, else 0. 02612 */ 02613 virtual int 02614 do_compare(const _CharT* __lo1, const _CharT* __hi1, 02615 const _CharT* __lo2, const _CharT* __hi2) const; 02616 02617 /** 02618 * @brief Transform string to comparable form. 02619 * 02620 * This function is a hook for derived classes to change the value 02621 * returned. 02622 * 02623 * @param lo1 Start of string 1. 02624 * @param hi1 End of string 1. 02625 * @param lo2 Start of string 2. 02626 * @param hi2 End of string 2. 02627 * @return 1 if string1 > string2, -1 if string1 < string2, else 0. 02628 */ 02629 virtual string_type 02630 do_transform(const _CharT* __lo, const _CharT* __hi) const; 02631 02632 /** 02633 * @brief Return hash of a string. 02634 * 02635 * This function computes and returns a hash on the input string. This 02636 * function is a hook for derived classes to change the value returned. 02637 * 02638 * @param lo Start of string. 02639 * @param hi End of string. 02640 * @return Hash value. 02641 */ 02642 virtual long 02643 do_hash(const _CharT* __lo, const _CharT* __hi) const; 02644 }; 02645 02646 template<typename _CharT> 02647 locale::id collate<_CharT>::id; 02648 02649 // Specializations. 02650 template<> 02651 int 02652 collate<char>::_M_compare(const char*, const char*) const; 02653 02654 template<> 02655 size_t 02656 collate<char>::_M_transform(char*, const char*, size_t) const; 02657 02658 #ifdef _GLIBCXX_USE_WCHAR_T 02659 template<> 02660 int 02661 collate<wchar_t>::_M_compare(const wchar_t*, const wchar_t*) const; 02662 02663 template<> 02664 size_t 02665 collate<wchar_t>::_M_transform(wchar_t*, const wchar_t*, size_t) const; 02666 #endif 02667 02668 /// @brief class collate_byname [22.2.4.2]. 02669 template<typename _CharT> 02670 class collate_byname : public collate<_CharT> 02671 { 02672 public: 02673 //@{ 02674 /// Public typedefs 02675 typedef _CharT char_type; 02676 typedef basic_string<_CharT> string_type; 02677 //@} 02678 02679 explicit 02680 collate_byname(const char* __s, size_t __refs = 0) 02681 : collate<_CharT>(__refs) 02682 { 02683 if (std::strcmp(__s, "C") != 0 && std::strcmp(__s, "POSIX") != 0) 02684 { 02685 this->_S_destroy_c_locale(this->_M_c_locale_collate); 02686 this->_S_create_c_locale(this->_M_c_locale_collate, __s); 02687 } 02688 } 02689 02690 protected: 02691 virtual 02692 ~collate_byname() { } 02693 }; 02694 02695 02696 /** 02697 * @brief Time format ordering data. 02698 * 02699 * This class provides an enum representing different orderings of day, 02700 * month, and year. 02701 */ 02702 class time_base 02703 { 02704 public: 02705 enum dateorder { no_order, dmy, mdy, ymd, ydm }; 02706 }; 02707 02708 template<typename _CharT> 02709 struct __timepunct_cache : public locale::facet 02710 { 02711 // List of all known timezones, with GMT first. 02712 static const _CharT* _S_timezones[14]; 02713 02714 const _CharT* _M_date_format; 02715 const _CharT* _M_date_era_format; 02716 const _CharT* _M_time_format; 02717 const _CharT* _M_time_era_format; 02718 const _CharT* _M_date_time_format; 02719 const _CharT* _M_date_time_era_format; 02720 const _CharT* _M_am; 02721 const _CharT* _M_pm; 02722 const _CharT* _M_am_pm_format; 02723 02724 // Day names, starting with "C"'s Sunday. 02725 const _CharT* _M_day1; 02726 const _CharT* _M_day2; 02727 const _CharT* _M_day3; 02728 const _CharT* _M_day4; 02729 const _CharT* _M_day5; 02730 const _CharT* _M_day6; 02731 const _CharT* _M_day7; 02732 02733 // Abbreviated day names, starting with "C"'s Sun. 02734 const _CharT* _M_aday1; 02735 const _CharT* _M_aday2; 02736 const _CharT* _M_aday3; 02737 const _CharT* _M_aday4; 02738 const _CharT* _M_aday5; 02739 const _CharT* _M_aday6; 02740 const _CharT* _M_aday7; 02741 02742 // Month names, starting with "C"'s January. 02743 const _CharT* _M_month01; 02744 const _CharT* _M_month02; 02745 const _CharT* _M_month03; 02746 const _CharT* _M_month04; 02747 const _CharT* _M_month05; 02748 const _CharT* _M_month06; 02749 const _CharT* _M_month07; 02750 const _CharT* _M_month08; 02751 const _CharT* _M_month09; 02752 const _CharT* _M_month10; 02753 const _CharT* _M_month11; 02754 const _CharT* _M_month12; 02755 02756 // Abbreviated month names, starting with "C"'s Jan. 02757 const _CharT* _M_amonth01; 02758 const _CharT* _M_amonth02; 02759 const _CharT* _M_amonth03; 02760 const _CharT* _M_amonth04; 02761 const _CharT* _M_amonth05; 02762 const _CharT* _M_amonth06; 02763 const _CharT* _M_amonth07; 02764 const _CharT* _M_amonth08; 02765 const _CharT* _M_amonth09; 02766 const _CharT* _M_amonth10; 02767 const _CharT* _M_amonth11; 02768 const _CharT* _M_amonth12; 02769 02770 bool _M_allocated; 02771 02772 __timepunct_cache(size_t __refs = 0) : facet(__refs), 02773 _M_date_format(NULL), _M_date_era_format(NULL), _M_time_format(NULL), 02774 _M_time_era_format(NULL), _M_date_time_format(NULL), 02775 _M_date_time_era_format(NULL), _M_am(NULL), _M_pm(NULL), 02776 _M_am_pm_format(NULL), _M_day1(NULL), _M_day2(NULL), _M_day3(NULL), 02777 _M_day4(NULL), _M_day5(NULL), _M_day6(NULL), _M_day7(NULL), 02778 _M_aday1(NULL), _M_aday2(NULL), _M_aday3(NULL), _M_aday4(NULL), 02779 _M_aday5(NULL), _M_aday6(NULL), _M_aday7(NULL), _M_month01(NULL), 02780 _M_month02(NULL), _M_month03(NULL), _M_month04(NULL), _M_month05(NULL), 02781 _M_month06(NULL), _M_month07(NULL), _M_month08(NULL), _M_month09(NULL), 02782 _M_month10(NULL), _M_month11(NULL), _M_month12(NULL), _M_amonth01(NULL), 02783 _M_amonth02(NULL), _M_amonth03(NULL), _M_amonth04(NULL), 02784 _M_amonth05(NULL), _M_amonth06(NULL), _M_amonth07(NULL), 02785 _M_amonth08(NULL), _M_amonth09(NULL), _M_amonth10(NULL), 02786 _M_amonth11(NULL), _M_amonth12(NULL), _M_allocated(false) 02787 { } 02788 02789 ~__timepunct_cache(); 02790 02791 void 02792 _M_cache(const locale& __loc); 02793 02794 private: 02795 __timepunct_cache& 02796 operator=(const __timepunct_cache&); 02797 02798 explicit 02799 __timepunct_cache(const __timepunct_cache&); 02800 }; 02801 02802 template<typename _CharT> 02803 __timepunct_cache<_CharT>::~__timepunct_cache() 02804 { 02805 if (_M_allocated) 02806 { 02807 // Unused. 02808 } 02809 } 02810 02811 // Specializations. 02812 template<> 02813 const char* 02814 __timepunct_cache<char>::_S_timezones[14]; 02815 02816 #ifdef _GLIBCXX_USE_WCHAR_T 02817 template<> 02818 const wchar_t* 02819 __timepunct_cache<wchar_t>::_S_timezones[14]; 02820 #endif 02821 02822 // Generic. 02823 template<typename _CharT> 02824 const _CharT* __timepunct_cache<_CharT>::_S_timezones[14]; 02825 02826 template<typename _CharT> 02827 class __timepunct : public locale::facet 02828 { 02829 public: 02830 // Types: 02831 typedef _CharT __char_type; 02832 typedef basic_string<_CharT> __string_type; 02833 typedef __timepunct_cache<_CharT> __cache_type; 02834 02835 protected: 02836 __cache_type* _M_data; 02837 __c_locale _M_c_locale_timepunct; 02838 const char* _M_name_timepunct; 02839 02840 public: 02841 /// Numpunct facet id. 02842 static locale::id id; 02843 02844 explicit 02845 __timepunct(size_t __refs = 0); 02846 02847 explicit 02848 __timepunct(__cache_type* __cache, size_t __refs = 0); 02849 02850 /** 02851 * @brief Internal constructor. Not for general use. 02852 * 02853 * This is a constructor for use by the library itself to set up new 02854 * locales. 02855 * 02856 * @param cloc The "C" locale. 02857 * @param s The name of a locale. 02858 * @param refs Passed to the base facet class. 02859 */ 02860 explicit 02861 __timepunct(__c_locale __cloc, const char* __s, size_t __refs = 0); 02862 02863 // FIXME: for error checking purposes _M_put should return the return 02864 // value of strftime/wcsftime. 02865 void 02866 _M_put(_CharT* __s, size_t __maxlen, const _CharT* __format, 02867 const tm* __tm) const; 02868 02869 void 02870 _M_date_formats(const _CharT** __date) const 02871 { 02872 // Always have default first. 02873 __date[0] = _M_data->_M_date_format; 02874 __date[1] = _M_data->_M_date_era_format; 02875 } 02876 02877 void 02878 _M_time_formats(const _CharT** __time) const 02879 { 02880 // Always have default first. 02881 __time[0] = _M_data->_M_time_format; 02882 __time[1] = _M_data->_M_time_era_format; 02883 } 02884 02885 void 02886 _M_date_time_formats(const _CharT** __dt) const 02887 { 02888 // Always have default first. 02889 __dt[0] = _M_data->_M_date_time_format; 02890 __dt[1] = _M_data->_M_date_time_era_format; 02891 } 02892 02893 void 02894 _M_am_pm_format(const _CharT* __ampm) const 02895 { __ampm = _M_data->_M_am_pm_format; } 02896 02897 void 02898 _M_am_pm(const _CharT** __ampm) const 02899 { 02900 __ampm[0] = _M_data->_M_am; 02901 __ampm[1] = _M_data->_M_pm; 02902 } 02903 02904 void 02905 _M_days(const _CharT** __days) const 02906 { 02907 __days[0] = _M_data->_M_day1; 02908 __days[1] = _M_data->_M_day2; 02909 __days[2] = _M_data->_M_day3; 02910 __days[3] = _M_data->_M_day4; 02911 __days[4] = _M_data->_M_day5; 02912 __days[5] = _M_data->_M_day6; 02913 __days[6] = _M_data->_M_day7; 02914 } 02915 02916 void 02917 _M_days_abbreviated(const _CharT** __days) const 02918 { 02919 __days[0] = _M_data->_M_aday1; 02920 __days[1] = _M_data->_M_aday2; 02921 __days[2] = _M_data->_M_aday3; 02922 __days[3] = _M_data->_M_aday4; 02923 __days[4] = _M_data->_M_aday5; 02924 __days[5] = _M_data->_M_aday6; 02925 __days[6] = _M_data->_M_aday7; 02926 } 02927 02928 void 02929 _M_months(const _CharT** __months) const 02930 { 02931 __months[0] = _M_data->_M_month01; 02932 __months[1] = _M_data->_M_month02; 02933 __months[2] = _M_data->_M_month03; 02934 __months[3] = _M_data->_M_month04; 02935 __months[4] = _M_data->_M_month05; 02936 __months[5] = _M_data->_M_month06; 02937 __months[6] = _M_data->_M_month07; 02938 __months[7] = _M_data->_M_month08; 02939 __months[8] = _M_data->_M_month09; 02940 __months[9] = _M_data->_M_month10; 02941 __months[10] = _M_data->_M_month11; 02942 __months[11] = _M_data->_M_month12; 02943 } 02944 02945 void 02946 _M_months_abbreviated(const _CharT** __months) const 02947 { 02948 __months[0] = _M_data->_M_amonth01; 02949 __months[1] = _M_data->_M_amonth02; 02950 __months[2] = _M_data->_M_amonth03; 02951 __months[3] = _M_data->_M_amonth04; 02952 __months[4] = _M_data->_M_amonth05; 02953 __months[5] = _M_data->_M_amonth06; 02954 __months[6] = _M_data->_M_amonth07; 02955 __months[7] = _M_data->_M_amonth08; 02956 __months[8] = _M_data->_M_amonth09; 02957 __months[9] = _M_data->_M_amonth10; 02958 __months[10] = _M_data->_M_amonth11; 02959 __months[11] = _M_data->_M_amonth12; 02960 } 02961 02962 protected: 02963 virtual 02964 ~__timepunct(); 02965 02966 // For use at construction time only. 02967 void 02968 _M_initialize_timepunct(__c_locale __cloc = NULL); 02969 }; 02970 02971 template<typename _CharT> 02972 locale::id __timepunct<_CharT>::id; 02973 02974 // Specializations. 02975 template<> 02976 void 02977 __timepunct<char>::_M_initialize_timepunct(__c_locale __cloc); 02978 02979 template<> 02980 void 02981 __timepunct<char>::_M_put(char*, size_t, const char*, const tm*) const; 02982 02983 #ifdef _GLIBCXX_USE_WCHAR_T 02984 template<> 02985 void 02986 __timepunct<wchar_t>::_M_initialize_timepunct(__c_locale __cloc); 02987 02988 template<> 02989 void 02990 __timepunct<wchar_t>::_M_put(wchar_t*, size_t, const wchar_t*, 02991 const tm*) const; 02992 #endif 02993 02994 // Include host and configuration specific timepunct functions. 02995 #include <bits/time_members.h> 02996 02997 /** 02998 * @brief Facet for parsing dates and times. 02999 * 03000 * This facet encapsulates the code to parse and return a date or 03001 * time from a string. It is used by the istream numeric 03002 * extraction operators. 03003 * 03004 * The time_get template uses protected virtual functions to provide the 03005 * actual results. The public accessors forward the call to the virtual 03006 * functions. These virtual functions are hooks for developers to 03007 * implement the behavior they require from the time_get facet. 03008 */ 03009 template<typename _CharT, typename _InIter> 03010 class time_get : public locale::facet, public time_base 03011 { 03012 public: 03013 // Types: 03014 //@{ 03015 /// Public typedefs 03016 typedef _CharT char_type; 03017 typedef _InIter iter_type; 03018 //@} 03019 typedef basic_string<_CharT> __string_type; 03020 03021 /// Numpunct facet id. 03022 static locale::id id; 03023 03024 /** 03025 * @brief Constructor performs initialization. 03026 * 03027 * This is the constructor provided by the standard. 03028 * 03029 * @param refs Passed to the base facet class. 03030 */ 03031 explicit 03032 time_get(size_t __refs = 0) 03033 : facet (__refs) { } 03034 03035 /** 03036 * @brief Return preferred order of month, day, and year. 03037 * 03038 * This function returns an enum from timebase::dateorder giving the 03039 * preferred ordering if the format "x" given to time_put::put() only 03040 * uses month, day, and year. If the format "x" for the associated 03041 * locale uses other fields, this function returns 03042 * timebase::dateorder::noorder. 03043 * 03044 * NOTE: The library always returns noorder at the moment. 03045 * 03046 * @return A member of timebase::dateorder. 03047 */ 03048 dateorder 03049 date_order() const 03050 { return this->do_date_order(); } 03051 03052 /** 03053 * @brief Parse input time string. 03054 * 03055 * This function parses a time according to the format "x" and puts the 03056 * results into a user-supplied struct tm. The result is returned by 03057 * calling time_get::do_get_time(). 03058 * 03059 * If there is a valid time string according to format "x", @a tm will 03060 * be filled in accordingly and the returned iterator will point to the 03061 * first character beyond the time string. If an error occurs before 03062 * the end, err |= ios_base::failbit. If parsing reads all the 03063 * characters, err |= ios_base::eofbit. 03064 * 03065 * @param beg Start of string to parse. 03066 * @param end End of string to parse. 03067 * @param io Source of the locale. 03068 * @param err Error flags to set. 03069 * @param tm Pointer to struct tm to fill in. 03070 * @return Iterator to first char beyond time string. 03071 */ 03072 iter_type 03073 get_time(iter_type __beg, iter_type __end, ios_base& __io, 03074 ios_base::iostate& __err, tm* __tm) const 03075 { return this->do_get_time(__beg, __end, __io, __err, __tm); } 03076 03077 /** 03078 * @brief Parse input date string. 03079 * 03080 * This function parses a date according to the format "X" and puts the 03081 * results into a user-supplied struct tm. The result is returned by 03082 * calling time_get::do_get_date(). 03083 * 03084 * If there is a valid date string according to format "X", @a tm will 03085 * be filled in accordingly and the returned iterator will point to the 03086 * first character beyond the date string. If an error occurs before 03087 * the end, err |= ios_base::failbit. If parsing reads all the 03088 * characters, err |= ios_base::eofbit. 03089 * 03090 * @param beg Start of string to parse. 03091 * @param end End of string to parse. 03092 * @param io Source of the locale. 03093 * @param err Error flags to set. 03094 * @param tm Pointer to struct tm to fill in. 03095 * @return Iterator to first char beyond date string. 03096 */ 03097 iter_type 03098 get_date(iter_type __beg, iter_type __end, ios_base& __io, 03099 ios_base::iostate& __err, tm* __tm) const 03100 { return this->do_get_date(__beg, __end, __io, __err, __tm); } 03101 03102 /** 03103 * @brief Parse input weekday string. 03104 * 03105 * This function parses a weekday name and puts the results into a 03106 * user-supplied struct tm. The result is returned by calling 03107 * time_get::do_get_weekday(). 03108 * 03109 * Parsing starts by parsing an abbreviated weekday name. If a valid 03110 * abbreviation is followed by a character that would lead to the full 03111 * weekday name, parsing continues until the full name is found or an 03112 * error occurs. Otherwise parsing finishes at the end of the 03113 * abbreviated name. 03114 * 03115 * If an error occurs before the end, err |= ios_base::failbit. If 03116 * parsing reads all the characters, err |= ios_base::eofbit. 03117 * 03118 * @param beg Start of string to parse. 03119 * @param end End of string to parse. 03120 * @param io Source of the locale. 03121 * @param err Error flags to set. 03122 * @param tm Pointer to struct tm to fill in. 03123 * @return Iterator to first char beyond weekday name. 03124 */ 03125 iter_type 03126 get_weekday(iter_type __beg, iter_type __end, ios_base& __io, 03127 ios_base::iostate& __err, tm* __tm) const 03128 { return this->do_get_weekday(__beg, __end, __io, __err, __tm); } 03129 03130 /** 03131 * @brief Parse input month string. 03132 * 03133 * This function parses a month name and puts the results into a 03134 * user-supplied struct tm. The result is returned by calling 03135 * time_get::do_get_monthname(). 03136 * 03137 * Parsing starts by parsing an abbreviated month name. If a valid 03138 * abbreviation is followed by a character that would lead to the full 03139 * month name, parsing continues until the full name is found or an 03140 * error occurs. Otherwise parsing finishes at the end of the 03141 * abbreviated name. 03142 * 03143 * If an error occurs before the end, err |= ios_base::failbit. If 03144 * parsing reads all the characters, err |= 03145 * ios_base::eofbit. 03146 * 03147 * @param beg Start of string to parse. 03148 * @param end End of string to parse. 03149 * @param io Source of the locale. 03150 * @param err Error flags to set. 03151 * @param tm Pointer to struct tm to fill in. 03152 * @return Iterator to first char beyond month name. 03153 */ 03154 iter_type 03155 get_monthname(iter_type __beg, iter_type __end, ios_base& __io, 03156 ios_base::iostate& __err, tm* __tm) const 03157 { return this->do_get_monthname(__beg, __end, __io, __err, __tm); } 03158 03159 /** 03160 * @brief Parse input year string. 03161 * 03162 * This function reads up to 4 characters to parse a year string and 03163 * puts the results into a user-supplied struct tm. The result is 03164 * returned by calling time_get::do_get_year(). 03165 * 03166 * 4 consecutive digits are interpreted as a full year. If there are 03167 * exactly 2 consecutive digits, the library interprets this as the 03168 * number of years since 1900. 03169 * 03170 * If an error occurs before the end, err |= ios_base::failbit. If 03171 * parsing reads all the characters, err |= ios_base::eofbit. 03172 * 03173 * @param beg Start of string to parse. 03174 * @param end End of string to parse. 03175 * @param io Source of the locale. 03176 * @param err Error flags to set. 03177 * @param tm Pointer to struct tm to fill in. 03178 * @return Iterator to first char beyond year. 03179 */ 03180 iter_type 03181 get_year(iter_type __beg, iter_type __end, ios_base& __io, 03182 ios_base::iostate& __err, tm* __tm) const 03183 { return this->do_get_year(__beg, __end, __io, __err, __tm); } 03184 03185 protected: 03186 /// Destructor. 03187 virtual 03188 ~time_get() { } 03189 03190 /** 03191 * @brief Return preferred order of month, day, and year. 03192 * 03193 * This function returns an enum from timebase::dateorder giving the 03194 * preferred ordering if the format "x" given to time_put::put() only 03195 * uses month, day, and year. This function is a hook for derived 03196 * classes to change the value returned. 03197 * 03198 * @return A member of timebase::dateorder. 03199 */ 03200 virtual dateorder 03201 do_date_order() const; 03202 03203 /** 03204 * @brief Parse input time string. 03205 * 03206 * This function parses a time according to the format "x" and puts the 03207 * results into a user-supplied struct tm. This function is a hook for 03208 * derived classes to change the value returned. @see get_time() for 03209 * details. 03210 * 03211 * @param beg Start of string to parse. 03212 * @param end End of string to parse. 03213 * @param io Source of the locale. 03214 * @param err Error flags to set. 03215 * @param tm Pointer to struct tm to fill in. 03216 * @return Iterator to first char beyond time string. 03217 */ 03218 virtual iter_type 03219 do_get_time(iter_type __beg, iter_type __end, ios_base& __io, 03220 ios_base::iostate& __err, tm* __tm) const; 03221 03222 /** 03223 * @brief Parse input date string. 03224 * 03225 * This function parses a date according to the format "X" and puts the 03226 * results into a user-supplied struct tm. This function is a hook for 03227 * derived classes to change the value returned. @see get_date() for 03228 * details. 03229 * 03230 * @param beg Start of string to parse. 03231 * @param end End of string to parse. 03232 * @param io Source of the locale. 03233 * @param err Error flags to set. 03234 * @param tm Pointer to struct tm to fill in. 03235 * @return Iterator to first char beyond date string. 03236 */ 03237 virtual iter_type 03238 do_get_date(iter_type __beg, iter_type __end, ios_base& __io, 03239 ios_base::iostate& __err, tm* __tm) const; 03240 03241 /** 03242 * @brief Parse input weekday string. 03243 * 03244 * This function parses a weekday name and puts the results into a 03245 * user-supplied struct tm. This function is a hook for derived 03246 * classes to change the value returned. @see get_weekday() for 03247 * details. 03248 * 03249 * @param beg Start of string to parse. 03250 * @param end End of string to parse. 03251 * @param io Source of the locale. 03252 * @param err Error flags to set. 03253 * @param tm Pointer to struct tm to fill in. 03254 * @return Iterator to first char beyond weekday name. 03255 */ 03256 virtual iter_type 03257 do_get_weekday(iter_type __beg, iter_type __end, ios_base&, 03258 ios_base::iostate& __err, tm* __tm) const; 03259 03260 /** 03261 * @brief Parse input month string. 03262 * 03263 * This function parses a month name and puts the results into a 03264 * user-supplied struct tm. This function is a hook for derived 03265 * classes to change the value returned. @see get_monthname() for 03266 * details. 03267 * 03268 * @param beg Start of string to parse. 03269 * @param end End of string to parse. 03270 * @param io Source of the locale. 03271 * @param err Error flags to set. 03272 * @param tm Pointer to struct tm to fill in. 03273 * @return Iterator to first char beyond month name. 03274 */ 03275 virtual iter_type 03276 do_get_monthname(iter_type __beg, iter_type __end, ios_base&, 03277 ios_base::iostate& __err, tm* __tm) const; 03278 03279 /** 03280 * @brief Parse input year string. 03281 * 03282 * This function reads up to 4 characters to parse a year string and 03283 * puts the results into a user-supplied struct tm. This function is a 03284 * hook for derived classes to change the value returned. @see 03285 * get_year() for details. 03286 * 03287 * @param beg Start of string to parse. 03288 * @param end End of string to parse. 03289 * @param io Source of the locale. 03290 * @param err Error flags to set. 03291 * @param tm Pointer to struct tm to fill in. 03292 * @return Iterator to first char beyond year. 03293 */ 03294 virtual iter_type 03295 do_get_year(iter_type __beg, iter_type __end, ios_base& __io, 03296 ios_base::iostate& __err, tm* __tm) const; 03297 03298 // Extract numeric component of length __len. 03299 iter_type 03300 _M_extract_num(iter_type __beg, iter_type __end, int& __member, 03301 int __min, int __max, size_t __len, 03302 ios_base& __io, ios_base::iostate& __err) const; 03303 03304 // Extract day or month name, or any unique array of string 03305 // literals in a const _CharT* array. 03306 iter_type 03307 _M_extract_name(iter_type __beg, iter_type __end, int& __member, 03308 const _CharT** __names, size_t __indexlen, 03309 ios_base& __io, ios_base::iostate& __err) const; 03310 03311 // Extract on a component-by-component basis, via __format argument. 03312 iter_type 03313 _M_extract_via_format(iter_type __beg, iter_type __end, ios_base& __io, 03314 ios_base::iostate& __err, tm* __tm, 03315 const _CharT* __format) const; 03316 }; 03317 03318 template<typename _CharT, typename _InIter> 03319 locale::id time_get<_CharT, _InIter>::id; 03320 03321 /// @brief class time_get_byname [22.2.5.2]. 03322 template<typename _CharT, typename _InIter> 03323 class time_get_byname : public time_get<_CharT, _InIter> 03324 { 03325 public: 03326 // Types: 03327 typedef _CharT char_type; 03328 typedef _InIter iter_type; 03329 03330 explicit 03331 time_get_byname(const char*, size_t __refs = 0) 03332 : time_get<_CharT, _InIter>(__refs) { } 03333 03334 protected: 03335 virtual 03336 ~time_get_byname() { } 03337 }; 03338 03339 /** 03340 * @brief Facet for outputting dates and times. 03341 * 03342 * This facet encapsulates the code to format and output dates and times 03343 * according to formats used by strftime(). 03344 * 03345 * The time_put template uses protected virtual functions to provide the 03346 * actual results. The public accessors forward the call to the virtual 03347 * functions. These virtual functions are hooks for developers to 03348 * implement the behavior they require from the time_put facet. 03349 */ 03350 template<typename _CharT, typename _OutIter> 03351 class time_put : public locale::facet 03352 { 03353 public: 03354 // Types: 03355 //@{ 03356 /// Public typedefs 03357 typedef _CharT char_type; 03358 typedef _OutIter iter_type; 03359 //@} 03360 03361 /// Numpunct facet id. 03362 static locale::id id; 03363 03364 /** 03365 * @brief Constructor performs initialization. 03366 * 03367 * This is the constructor provided by the standard. 03368 * 03369 * @param refs Passed to the base facet class. 03370 */ 03371 explicit 03372 time_put(size_t __refs = 0) 03373 : facet(__refs) { } 03374 03375 /** 03376 * @brief Format and output a time or date. 03377 * 03378 * This function formats the data in struct tm according to the 03379 * provided format string. The format string is interpreted as by 03380 * strftime(). 03381 * 03382 * @param s The stream to write to. 03383 * @param io Source of locale. 03384 * @param fill char_type to use for padding. 03385 * @param tm Struct tm with date and time info to format. 03386 * @param beg Start of format string. 03387 * @param end End of format string. 03388 * @return Iterator after writing. 03389 */ 03390 iter_type 03391 put(iter_type __s, ios_base& __io, char_type __fill, const tm* __tm, 03392 const _CharT* __beg, const _CharT* __end) const; 03393 03394 /** 03395 * @brief Format and output a time or date. 03396 * 03397 * This function formats the data in struct tm according to the 03398 * provided format char and optional modifier. The format and modifier 03399 * are interpreted as by strftime(). It does so by returning 03400 * time_put::do_put(). 03401 * 03402 * @param s The stream to write to. 03403 * @param io Source of locale. 03404 * @param fill char_type to use for padding. 03405 * @param tm Struct tm with date and time info to format. 03406 * @param format Format char. 03407 * @param mod Optional modifier char. 03408 * @return Iterator after writing. 03409 */ 03410 iter_type 03411 put(iter_type __s, ios_base& __io, char_type __fill, 03412 const tm* __tm, char __format, char __mod = 0) const 03413 { return this->do_put(__s, __io, __fill, __tm, __format, __mod); } 03414 03415 protected: 03416 /// Destructor. 03417 virtual 03418 ~time_put() 03419 { } 03420 03421 /** 03422 * @brief Format and output a time or date. 03423 * 03424 * This function formats the data in struct tm according to the 03425 * provided format char and optional modifier. This function is a hook 03426 * for derived classes to change the value returned. @see put() for 03427 * more details. 03428 * 03429 * @param s The stream to write to. 03430 * @param io Source of locale. 03431 * @param fill char_type to use for padding. 03432 * @param tm Struct tm with date and time info to format. 03433 * @param format Format char. 03434 * @param mod Optional modifier char. 03435 * @return Iterator after writing. 03436 */ 03437 virtual iter_type 03438 do_put(iter_type __s, ios_base& __io, char_type __fill, const tm* __tm, 03439 char __format, char __mod) const; 03440 }; 03441 03442 template<typename _CharT, typename _OutIter> 03443 locale::id time_put<_CharT, _OutIter>::id; 03444 03445 /// @brief class time_put_byname [22.2.5.4]. 03446 template<typename _CharT, typename _OutIter> 03447 class time_put_byname : public time_put<_CharT, _OutIter> 03448 { 03449 public: 03450 // Types: 03451 typedef _CharT char_type; 03452 typedef _OutIter iter_type; 03453 03454 explicit 03455 time_put_byname(const char*, size_t __refs = 0) 03456 : time_put<_CharT, _OutIter>(__refs) 03457 { }; 03458 03459 protected: 03460 virtual 03461 ~time_put_byname() { } 03462 }; 03463 03464 03465 /** 03466 * @brief Money format ordering data. 03467 * 03468 * This class contains an ordered array of 4 fields to represent the 03469 * pattern for formatting a money amount. Each field may contain one entry 03470 * from the part enum. symbol, sign, and value must be present and the 03471 * remaining field must contain either none or space. @see 03472 * moneypunct::pos_format() and moneypunct::neg_format() for details of how 03473 * these fields are interpreted. 03474 */ 03475 class money_base 03476 { 03477 public: 03478 enum part { none, space, symbol, sign, value }; 03479 struct pattern { char field[4]; }; 03480 03481 static const pattern _S_default_pattern; 03482 03483 enum 03484 { 03485 _S_minus, 03486 _S_zero, 03487 _S_end = 11 03488 }; 03489 03490 // String literal of acceptable (narrow) input/output, for 03491 // money_get/money_put. "-0123456789" 03492 static const char* _S_atoms; 03493 03494 // Construct and return valid pattern consisting of some combination of: 03495 // space none symbol sign value 03496 static pattern 03497 _S_construct_pattern(char __precedes, char __space, char __posn); 03498 }; 03499 03500 template<typename _CharT, bool _Intl> 03501 struct __moneypunct_cache : public locale::facet 03502 { 03503 const char* _M_grouping; 03504 size_t _M_grouping_size; 03505 bool _M_use_grouping; 03506 _CharT _M_decimal_point; 03507 _CharT _M_thousands_sep; 03508 const _CharT* _M_curr_symbol; 03509 size_t _M_curr_symbol_size; 03510 const _CharT* _M_positive_sign; 03511 size_t _M_positive_sign_size; 03512 const _CharT* _M_negative_sign; 03513 size_t _M_negative_sign_size; 03514 int _M_frac_digits; 03515 money_base::pattern _M_pos_format; 03516 money_base::pattern _M_neg_format; 03517 03518 // A list of valid numeric literals for input and output: in the standard 03519 // "C" locale, this is "-0123456789". This array contains the chars after 03520 // having been passed through the current locale's ctype<_CharT>.widen(). 03521 _CharT _M_atoms[money_base::_S_end]; 03522 03523 bool _M_allocated; 03524 03525 __moneypunct_cache(size_t __refs = 0) : facet(__refs), 03526 _M_grouping(NULL), _M_grouping_size(0), _M_use_grouping(false), 03527 _M_decimal_point(_CharT()), _M_thousands_sep(_CharT()), 03528 _M_curr_symbol(NULL), _M_curr_symbol_size(0), 03529 _M_positive_sign(NULL), _M_positive_sign_size(0), 03530 _M_negative_sign(NULL), _M_negative_sign_size(0), 03531 _M_frac_digits(0), 03532 _M_pos_format(money_base::pattern()), 03533 _M_neg_format(money_base::pattern()), _M_allocated(false) 03534 { } 03535 03536 ~__moneypunct_cache(); 03537 03538 void 03539 _M_cache(const locale& __loc); 03540 03541 private: 03542 __moneypunct_cache& 03543 operator=(const __moneypunct_cache&); 03544 03545 explicit 03546 __moneypunct_cache(const __moneypunct_cache&); 03547 }; 03548 03549 template<typename _CharT, bool _Intl> 03550 __moneypunct_cache<_CharT, _Intl>::~__moneypunct_cache() 03551 { 03552 if (_M_allocated) 03553 { 03554 delete [] _M_grouping; 03555 delete [] _M_curr_symbol; 03556 delete [] _M_positive_sign; 03557 delete [] _M_negative_sign; 03558 } 03559 } 03560 03561 /** 03562 * @brief Facet for formatting data for money amounts. 03563 * 03564 * This facet encapsulates the punctuation, grouping and other formatting 03565 * features of money amount string representations. 03566 */ 03567 template<typename _CharT, bool _Intl> 03568 class moneypunct : public locale::facet, public money_base 03569 { 03570 public: 03571 // Types: 03572 //@{ 03573 /// Public typedefs 03574 typedef _CharT char_type; 03575 typedef basic_string<_CharT> string_type; 03576 //@} 03577 typedef __moneypunct_cache<_CharT, _Intl> __cache_type; 03578 03579 private: 03580 __cache_type* _M_data; 03581 03582 public: 03583 /// This value is provided by the standard, but no reason for its 03584 /// existence. 03585 static const bool intl = _Intl; 03586 /// Numpunct facet id. 03587 static locale::id id; 03588 03589 /** 03590 * @brief Constructor performs initialization. 03591 * 03592 * This is the constructor provided by the standard. 03593 * 03594 * @param refs Passed to the base facet class. 03595 */ 03596 explicit 03597 moneypunct(size_t __refs = 0) : facet(__refs), _M_data(NULL) 03598 { _M_initialize_moneypunct(); } 03599 03600 /** 03601 * @brief Constructor performs initialization. 03602 * 03603 * This is an internal constructor. 03604 * 03605 * @param cache Cache for optimization. 03606 * @param refs Passed to the base facet class. 03607 */ 03608 explicit 03609 moneypunct(__cache_type* __cache, size_t __refs = 0) 03610 : facet(__refs), _M_data(__cache) 03611 { _M_initialize_moneypunct(); } 03612 03613 /** 03614 * @brief Internal constructor. Not for general use. 03615 * 03616 * This is a constructor for use by the library itself to set up new 03617 * locales. 03618 * 03619 * @param cloc The "C" locale. 03620 * @param s The name of a locale. 03621 * @param refs Passed to the base facet class. 03622 */ 03623 explicit 03624 moneypunct(__c_locale __cloc, const char* __s, size_t __refs = 0) 03625 : facet(__refs), _M_data(NULL) 03626 { _M_initialize_moneypunct(__cloc, __s); } 03627 03628 /** 03629 * @brief Return decimal point character. 03630 * 03631 * This function returns a char_type to use as a decimal point. It 03632 * does so by returning returning 03633 * moneypunct<char_type>::do_decimal_point(). 03634 * 03635 * @return @a char_type representing a decimal point. 03636 */ 03637 char_type 03638 decimal_point() const 03639 { return this->do_decimal_point(); } 03640 03641 /** 03642 * @brief Return thousands separator character. 03643 * 03644 * This function returns a char_type to use as a thousands 03645 * separator. It does so by returning returning 03646 * moneypunct<char_type>::do_thousands_sep(). 03647 * 03648 * @return char_type representing a thousands separator. 03649 */ 03650 char_type 03651 thousands_sep() const 03652 { return this->do_thousands_sep(); } 03653 03654 /** 03655 * @brief Return grouping specification. 03656 * 03657 * This function returns a string representing groupings for the 03658 * integer part of an amount. Groupings indicate where thousands 03659 * separators should be inserted. 03660 * 03661 * Each char in the return string is interpret as an integer rather 03662 * than a character. These numbers represent the number of digits in a 03663 * group. The first char in the string represents the number of digits 03664 * in the least significant group. If a char is negative, it indicates 03665 * an unlimited number of digits for the group. If more chars from the 03666 * string are required to group a number, the last char is used 03667 * repeatedly. 03668 * 03669 * For example, if the grouping() returns "\003\002" and is applied to 03670 * the number 123456789, this corresponds to 12,34,56,789. Note that 03671 * if the string was "32", this would put more than 50 digits into the 03672 * least significant group if the character set is ASCII. 03673 * 03674 * The string is returned by calling 03675 * moneypunct<char_type>::do_grouping(). 03676 * 03677 * @return string representing grouping specification. 03678 */ 03679 string 03680 grouping() const 03681 { return this->do_grouping(); } 03682 03683 /** 03684 * @brief Return currency symbol string. 03685 * 03686 * This function returns a string_type to use as a currency symbol. It 03687 * does so by returning returning 03688 * moneypunct<char_type>::do_curr_symbol(). 03689 * 03690 * @return @a string_type representing a currency symbol. 03691 */ 03692 string_type 03693 curr_symbol() const 03694 { return this->do_curr_symbol(); } 03695 03696 /** 03697 * @brief Return positive sign string. 03698 * 03699 * This function returns a string_type to use as a sign for positive 03700 * amounts. It does so by returning returning 03701 * moneypunct<char_type>::do_positive_sign(). 03702 * 03703 * If the return value contains more than one character, the first 03704 * character appears in the position indicated by pos_format() and the 03705 * remainder appear at the end of the formatted string. 03706 * 03707 * @return @a string_type representing a positive sign. 03708 */ 03709 string_type 03710 positive_sign() const 03711 { return this->do_positive_sign(); } 03712 03713 /** 03714 * @brief Return negative sign string. 03715 * 03716 * This function returns a string_type to use as a sign for negative 03717 * amounts. It does so by returning returning 03718 * moneypunct<char_type>::do_negative_sign(). 03719 * 03720 * If the return value contains more than one character, the first 03721 * character appears in the position indicated by neg_format() and the 03722 * remainder appear at the end of the formatted string. 03723 * 03724 * @return @a string_type representing a negative sign. 03725 */ 03726 string_type 03727 negative_sign() const 03728 { return this->do_negative_sign(); } 03729 03730 /** 03731 * @brief Return number of digits in fraction. 03732 * 03733 * This function returns the exact number of digits that make up the 03734 * fractional part of a money amount. It does so by returning 03735 * returning moneypunct<char_type>::do_frac_digits(). 03736 * 03737 * The fractional part of a money amount is optional. But if it is 03738 * present, there must be frac_digits() digits. 03739 * 03740 * @return Number of digits in amount fraction. 03741 */ 03742 int 03743 frac_digits() const 03744 { return this->do_frac_digits(); } 03745 03746 //@{ 03747 /** 03748 * @brief Return pattern for money values. 03749 * 03750 * This function returns a pattern describing the formatting of a 03751 * positive or negative valued money amount. It does so by returning 03752 * returning moneypunct<char_type>::do_pos_format() or 03753 * moneypunct<char_type>::do_neg_format(). 03754 * 03755 * The pattern has 4 fields describing the ordering of symbol, sign, 03756 * value, and none or space. There must be one of each in the pattern. 03757 * The none and space enums may not appear in the first field and space 03758 * may not appear in the final field. 03759 * 03760 * The parts of a money string must appear in the order indicated by 03761 * the fields of the pattern. The symbol field indicates that the 03762 * value of curr_symbol() may be present. The sign field indicates 03763 * that the value of positive_sign() or negative_sign() must be 03764 * present. The value field indicates that the absolute value of the 03765 * money amount is present. none indicates 0 or more whitespace 03766 * characters, except at the end, where it permits no whitespace. 03767 * space indicates that 1 or more whitespace characters must be 03768 * present. 03769 * 03770 * For example, for the US locale and pos_format() pattern 03771 * {symbol,sign,value,none}, curr_symbol() == '$' positive_sign() == 03772 * '+', and value 10.01, and options set to force the symbol, the 03773 * corresponding string is "$+10.01". 03774 * 03775 * @return Pattern for money values. 03776 */ 03777 pattern 03778 pos_format() const 03779 { return this->do_pos_format(); } 03780 03781 pattern 03782 neg_format() const 03783 { return this->do_neg_format(); } 03784 //@} 03785 03786 protected: 03787 /// Destructor. 03788 virtual 03789 ~moneypunct(); 03790 03791 /** 03792 * @brief Return decimal point character. 03793 * 03794 * Returns a char_type to use as a decimal point. This function is a 03795 * hook for derived classes to change the value returned. 03796 * 03797 * @return @a char_type representing a decimal point. 03798 */ 03799 virtual char_type 03800 do_decimal_point() const 03801 { return _M_data->_M_decimal_point; } 03802 03803 /** 03804 * @brief Return thousands separator character. 03805 * 03806 * Returns a char_type to use as a thousands separator. This function 03807 * is a hook for derived classes to change the value returned. 03808 * 03809 * @return @a char_type representing a thousands separator. 03810 */ 03811 virtual char_type 03812 do_thousands_sep() const 03813 { return _M_data->_M_thousands_sep; } 03814 03815 /** 03816 * @brief Return grouping specification. 03817 * 03818 * Returns a string representing groupings for the integer part of a 03819 * number. This function is a hook for derived classes to change the 03820 * value returned. @see grouping() for details. 03821 * 03822 * @return String representing grouping specification. 03823 */ 03824 virtual string 03825 do_grouping() const 03826 { return _M_data->_M_grouping; } 03827 03828 /** 03829 * @brief Return currency symbol string. 03830 * 03831 * This function returns a string_type to use as a currency symbol. 03832 * This function is a hook for derived classes to change the value 03833 * returned. @see curr_symbol() for details. 03834 * 03835 * @return @a string_type representing a currency symbol. 03836 */ 03837 virtual string_type 03838 do_curr_symbol() const 03839 { return _M_data->_M_curr_symbol; } 03840 03841 /** 03842 * @brief Return positive sign string. 03843 * 03844 * This function returns a string_type to use as a sign for positive 03845 * amounts. This function is a hook for derived classes to change the 03846 * value returned. @see positive_sign() for details. 03847 * 03848 * @return @a string_type representing a positive sign. 03849 */ 03850 virtual string_type 03851 do_positive_sign() const 03852 { return _M_data->_M_positive_sign; } 03853 03854 /** 03855 * @brief Return negative sign string. 03856 * 03857 * This function returns a string_type to use as a sign for negative 03858 * amounts. This function is a hook for derived classes to change the 03859 * value returned. @see negative_sign() for details. 03860 * 03861 * @return @a string_type representing a negative sign. 03862 */ 03863 virtual string_type 03864 do_negative_sign() const 03865 { return _M_data->_M_negative_sign; } 03866 03867 /** 03868 * @brief Return number of digits in fraction. 03869 * 03870 * This function returns the exact number of digits that make up the 03871 * fractional part of a money amount. This function is a hook for 03872 * derived classes to change the value returned. @see frac_digits() 03873 * for details. 03874 * 03875 * @return Number of digits in amount fraction. 03876 */ 03877 virtual int 03878 do_frac_digits() const 03879 { return _M_data->_M_frac_digits; } 03880 03881 /** 03882 * @brief Return pattern for money values. 03883 * 03884 * This function returns a pattern describing the formatting of a 03885 * positive valued money amount. This function is a hook for derived 03886 * classes to change the value returned. @see pos_format() for 03887 * details. 03888 * 03889 * @return Pattern for money values. 03890 */ 03891 virtual pattern 03892 do_pos_format() const 03893 { return _M_data->_M_pos_format; } 03894 03895 /** 03896 * @brief Return pattern for money values. 03897 * 03898 * This function returns a pattern describing the formatting of a 03899 * negative valued money amount. This function is a hook for derived 03900 * classes to change the value returned. @see neg_format() for 03901 * details. 03902 * 03903 * @return Pattern for money values. 03904 */ 03905 virtual pattern 03906 do_neg_format() const 03907 { return _M_data->_M_neg_format; } 03908 03909 // For use at construction time only. 03910 void 03911 _M_initialize_moneypunct(__c_locale __cloc = NULL, 03912 const char* __name = NULL); 03913 }; 03914 03915 template<typename _CharT, bool _Intl> 03916 locale::id moneypunct<_CharT, _Intl>::id; 03917 03918 template<typename _CharT, bool _Intl> 03919 const bool moneypunct<_CharT, _Intl>::intl; 03920 03921 template<> 03922 moneypunct<char, true>::~moneypunct(); 03923 03924 template<> 03925 moneypunct<char, false>::~moneypunct(); 03926 03927 template<> 03928 void 03929 moneypunct<char, true>::_M_initialize_moneypunct(__c_locale, const char*); 03930 03931 template<> 03932 void 03933 moneypunct<char, false>::_M_initialize_moneypunct(__c_locale, const char*); 03934 03935 #ifdef _GLIBCXX_USE_WCHAR_T 03936 template<> 03937 moneypunct<wchar_t, true>::~moneypunct(); 03938 03939 template<> 03940 moneypunct<wchar_t, false>::~moneypunct(); 03941 03942 template<> 03943 void 03944 moneypunct<wchar_t, true>::_M_initialize_moneypunct(__c_locale, 03945 const char*); 03946 03947 template<> 03948 void 03949 moneypunct<wchar_t, false>::_M_initialize_moneypunct(__c_locale, 03950 const char*); 03951 #endif 03952 03953 /// @brief class moneypunct_byname [22.2.6.4]. 03954 template<typename _CharT, bool _Intl> 03955 class moneypunct_byname : public moneypunct<_CharT, _Intl> 03956 { 03957 public: 03958 typedef _CharT char_type; 03959 typedef basic_string<_CharT> string_type; 03960 03961 static const bool intl = _Intl; 03962 03963 explicit 03964 moneypunct_byname(const char* __s, size_t __refs = 0) 03965 : moneypunct<_CharT, _Intl>(__refs) 03966 { 03967 if (std::strcmp(__s, "C") != 0 && std::strcmp(__s, "POSIX") != 0) 03968 { 03969 __c_locale __tmp; 03970 this->_S_create_c_locale(__tmp, __s); 03971 this->_M_initialize_moneypunct(__tmp); 03972 this->_S_destroy_c_locale(__tmp); 03973 } 03974 } 03975 03976 protected: 03977 virtual 03978 ~moneypunct_byname() { } 03979 }; 03980 03981 template<typename _CharT, bool _Intl> 03982 const bool moneypunct_byname<_CharT, _Intl>::intl; 03983 03984 _GLIBCXX_BEGIN_LDBL_NAMESPACE 03985 /** 03986 * @brief Facet for parsing monetary amounts. 03987 * 03988 * This facet encapsulates the code to parse and return a monetary 03989 * amount from a string. 03990 * 03991 * The money_get template uses protected virtual functions to 03992 * provide the actual results. The public accessors forward the 03993 * call to the virtual functions. These virtual functions are 03994 * hooks for developers to implement the behavior they require from 03995 * the money_get facet. 03996 */ 03997 template<typename _CharT, typename _InIter> 03998 class money_get : public locale::facet 03999 { 04000 public: 04001 // Types: 04002 //@{ 04003 /// Public typedefs 04004 typedef _CharT char_type; 04005 typedef _InIter iter_type; 04006 typedef basic_string<_CharT> string_type; 04007 //@} 04008 04009 /// Numpunct facet id. 04010 static locale::id id; 04011 04012 /** 04013 * @brief Constructor performs initialization. 04014 * 04015 * This is the constructor provided by the standard. 04016 * 04017 * @param refs Passed to the base facet class. 04018 */ 04019 explicit 04020 money_get(size_t __refs = 0) : facet(__refs) { } 04021 04022 /** 04023 * @brief Read and parse a monetary value. 04024 * 04025 * This function reads characters from @a s, interprets them as a 04026 * monetary value according to moneypunct and ctype facets retrieved 04027 * from io.getloc(), and returns the result in @a units as an integral 04028 * value moneypunct::frac_digits() * the actual amount. For example, 04029 * the string $10.01 in a US locale would store 1001 in @a units. 04030 * 04031 * Any characters not part of a valid money amount are not consumed. 04032 * 04033 * If a money value cannot be parsed from the input stream, sets 04034 * err=(err|io.failbit). If the stream is consumed before finishing 04035 * parsing, sets err=(err|io.failbit|io.eofbit). @a units is 04036 * unchanged if parsing fails. 04037 * 04038 * This function works by returning the result of do_get(). 04039 * 04040 * @param s Start of characters to parse. 04041 * @param end End of characters to parse. 04042 * @param intl Parameter to use_facet<moneypunct<CharT,intl> >. 04043 * @param io Source of facets and io state. 04044 * @param err Error field to set if parsing fails. 04045 * @param units Place to store result of parsing. 04046 * @return Iterator referencing first character beyond valid money 04047 * amount. 04048 */ 04049 iter_type 04050 get(iter_type __s, iter_type __end, bool __intl, ios_base& __io, 04051 ios_base::iostate& __err, long double& __units) const 04052 { return this->do_get(__s, __end, __intl, __io, __err, __units); } 04053 04054 /** 04055 * @brief Read and parse a monetary value. 04056 * 04057 * This function reads characters from @a s, interprets them as a 04058 * monetary value according to moneypunct and ctype facets retrieved 04059 * from io.getloc(), and returns the result in @a digits. For example, 04060 * the string $10.01 in a US locale would store "1001" in @a digits. 04061 * 04062 * Any characters not part of a valid money amount are not consumed. 04063 * 04064 * If a money value cannot be parsed from the input stream, sets 04065 * err=(err|io.failbit). If the stream is consumed before finishing 04066 * parsing, sets err=(err|io.failbit|io.eofbit). 04067 * 04068 * This function works by returning the result of do_get(). 04069 * 04070 * @param s Start of characters to parse. 04071 * @param end End of characters to parse. 04072 * @param intl Parameter to use_facet<moneypunct<CharT,intl> >. 04073 * @param io Source of facets and io state. 04074 * @param err Error field to set if parsing fails. 04075 * @param digits Place to store result of parsing. 04076 * @return Iterator referencing first character beyond valid money 04077 * amount. 04078 */ 04079 iter_type 04080 get(iter_type __s, iter_type __end, bool __intl, ios_base& __io, 04081 ios_base::iostate& __err, string_type& __digits) const 04082 { return this->do_get(__s, __end, __intl, __io, __err, __digits); } 04083 04084 protected: 04085 /// Destructor. 04086 virtual 04087 ~money_get() { } 04088 04089 /** 04090 * @brief Read and parse a monetary value. 04091 * 04092 * This function reads and parses characters representing a monetary 04093 * value. This function is a hook for derived classes to change the 04094 * value returned. @see get() for details. 04095 */ 04096 // XXX GLIBCXX_ABI Deprecated 04097 #if defined _GLIBCXX_LONG_DOUBLE_COMPAT && defined __LONG_DOUBLE_128__ 04098 virtual iter_type 04099 __do_get(iter_type __s, iter_type __end, bool __intl, ios_base& __io, 04100 ios_base::iostate& __err, double& __units) const; 04101 #else 04102 virtual iter_type 04103 do_get(iter_type __s, iter_type __end, bool __intl, ios_base& __io, 04104 ios_base::iostate& __err, long double& __units) const; 04105 #endif 04106 04107 /** 04108 * @brief Read and parse a monetary value. 04109 * 04110 * This function reads and parses characters representing a monetary 04111 * value. This function is a hook for derived classes to change the 04112 * value returned. @see get() for details. 04113 */ 04114 virtual iter_type 04115 do_get(iter_type __s, iter_type __end, bool __intl, ios_base& __io, 04116 ios_base::iostate& __err, string_type& __digits) const; 04117 04118 // XXX GLIBCXX_ABI Deprecated 04119 #if defined _GLIBCXX_LONG_DOUBLE_COMPAT && defined __LONG_DOUBLE_128__ 04120 virtual iter_type 04121 do_get(iter_type __s, iter_type __end, bool __intl, ios_base& __io, 04122 ios_base::iostate& __err, long double& __units) const; 04123 #endif 04124 04125 template<bool _Intl> 04126 iter_type 04127 _M_extract(iter_type __s, iter_type __end, ios_base& __io, 04128 ios_base::iostate& __err, string& __digits) const; 04129 }; 04130 04131 template<typename _CharT, typename _InIter> 04132 locale::id money_get<_CharT, _InIter>::id; 04133 04134 /** 04135 * @brief Facet for outputting monetary amounts. 04136 * 04137 * This facet encapsulates the code to format and output a monetary 04138 * amount. 04139 * 04140 * The money_put template uses protected virtual functions to 04141 * provide the actual results. The public accessors forward the 04142 * call to the virtual functions. These virtual functions are 04143 * hooks for developers to implement the behavior they require from 04144 * the money_put facet. 04145 */ 04146 template<typename _CharT, typename _OutIter> 04147 class money_put : public locale::facet 04148 { 04149 public: 04150 //@{ 04151 /// Public typedefs 04152 typedef _CharT char_type; 04153 typedef _OutIter iter_type; 04154 typedef basic_string<_CharT> string_type; 04155 //@} 04156 04157 /// Numpunct facet id. 04158 static locale::id id; 04159 04160 /** 04161 * @brief Constructor performs initialization. 04162 * 04163 * This is the constructor provided by the standard. 04164 * 04165 * @param refs Passed to the base facet class. 04166 */ 04167 explicit 04168 money_put(size_t __refs = 0) : facet(__refs) { } 04169 04170 /** 04171 * @brief Format and output a monetary value. 04172 * 04173 * This function formats @a units as a monetary value according to 04174 * moneypunct and ctype facets retrieved from io.getloc(), and writes 04175 * the resulting characters to @a s. For example, the value 1001 in a 04176 * US locale would write "$10.01" to @a s. 04177 * 04178 * This function works by returning the result of do_put(). 04179 * 04180 * @param s The stream to write to. 04181 * @param intl Parameter to use_facet<moneypunct<CharT,intl> >. 04182 * @param io Source of facets and io state. 04183 * @param fill char_type to use for padding. 04184 * @param units Place to store result of parsing. 04185 * @return Iterator after writing. 04186 */ 04187 iter_type 04188 put(iter_type __s, bool __intl, ios_base& __io, 04189 char_type __fill, long double __units) const 04190 { return this->do_put(__s, __intl, __io, __fill, __units); } 04191 04192 /** 04193 * @brief Format and output a monetary value. 04194 * 04195 * This function formats @a digits as a monetary value according to 04196 * moneypunct and ctype facets retrieved from io.getloc(), and writes 04197 * the resulting characters to @a s. For example, the string "1001" in 04198 * a US locale would write "$10.01" to @a s. 04199 * 04200 * This function works by returning the result of do_put(). 04201 * 04202 * @param s The stream to write to. 04203 * @param intl Parameter to use_facet<moneypunct<CharT,intl> >. 04204 * @param io Source of facets and io state. 04205 * @param fill char_type to use for padding. 04206 * @param units Place to store result of parsing. 04207 * @return Iterator after writing. 04208 */ 04209 iter_type 04210 put(iter_type __s, bool __intl, ios_base& __io, 04211 char_type __fill, const string_type& __digits) const 04212 { return this->do_put(__s, __intl, __io, __fill, __digits); } 04213 04214 protected: 04215 /// Destructor. 04216 virtual 04217 ~money_put() { } 04218 04219 /** 04220 * @brief Format and output a monetary value. 04221 * 04222 * This function formats @a units as a monetary value according to 04223 * moneypunct and ctype facets retrieved from io.getloc(), and writes 04224 * the resulting characters to @a s. For example, the value 1001 in a 04225 * US locale would write "$10.01" to @a s. 04226 * 04227 * This function is a hook for derived classes to change the value 04228 * returned. @see put(). 04229 * 04230 * @param s The stream to write to. 04231 * @param intl Parameter to use_facet<moneypunct<CharT,intl> >. 04232 * @param io Source of facets and io state. 04233 * @param fill char_type to use for padding. 04234 * @param units Place to store result of parsing. 04235 * @return Iterator after writing. 04236 */ 04237 // XXX GLIBCXX_ABI Deprecated 04238 #if defined _GLIBCXX_LONG_DOUBLE_COMPAT && defined __LONG_DOUBLE_128__ 04239 virtual iter_type 04240 __do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill, 04241 double __units) const; 04242 #else 04243 virtual iter_type 04244 do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill, 04245 long double __units) const; 04246 #endif 04247 04248 /** 04249 * @brief Format and output a monetary value. 04250 * 04251 * This function formats @a digits as a monetary value according to 04252 * moneypunct and ctype facets retrieved from io.getloc(), and writes 04253 * the resulting characters to @a s. For example, the string "1001" in 04254 * a US locale would write "$10.01" to @a s. 04255 * 04256 * This function is a hook for derived classes to change the value 04257 * returned. @see put(). 04258 * 04259 * @param s The stream to write to. 04260 * @param intl Parameter to use_facet<moneypunct<CharT,intl> >. 04261 * @param io Source of facets and io state. 04262 * @param fill char_type to use for padding. 04263 * @param units Place to store result of parsing. 04264 * @return Iterator after writing. 04265 */ 04266 virtual iter_type 04267 do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill, 04268 const string_type& __digits) const; 04269 04270 // XXX GLIBCXX_ABI Deprecated 04271 #if defined _GLIBCXX_LONG_DOUBLE_COMPAT && defined __LONG_DOUBLE_128__ 04272 virtual iter_type 04273 do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill, 04274 long double __units) const; 04275 #endif 04276 04277 template<bool _Intl> 04278 iter_type 04279 _M_insert(iter_type __s, ios_base& __io, char_type __fill, 04280 const string_type& __digits) const; 04281 }; 04282 04283 template<typename _CharT, typename _OutIter> 04284 locale::id money_put<_CharT, _OutIter>::id; 04285 04286 _GLIBCXX_END_LDBL_NAMESPACE 04287 04288 /** 04289 * @brief Messages facet base class providing catalog typedef. 04290 */ 04291 struct messages_base 04292 { 04293 typedef int catalog; 04294 }; 04295 04296 /** 04297 * @brief Facet for handling message catalogs 04298 * 04299 * This facet encapsulates the code to retrieve messages from 04300 * message catalogs. The only thing defined by the standard for this facet 04301 * is the interface. All underlying functionality is 04302 * implementation-defined. 04303 * 04304 * This library currently implements 3 versions of the message facet. The 04305 * first version (gnu) is a wrapper around gettext, provided by libintl. 04306 * The second version (ieee) is a wrapper around catgets. The final 04307 * version (default) does no actual translation. These implementations are 04308 * only provided for char and wchar_t instantiations. 04309 * 04310 * The messages template uses protected virtual functions to 04311 * provide the actual results. The public accessors forward the 04312 * call to the virtual functions. These virtual functions are 04313 * hooks for developers to implement the behavior they require from 04314 * the messages facet. 04315 */ 04316 template<typename _CharT> 04317 class messages : public locale::facet, public messages_base 04318 { 04319 public: 04320 // Types: 04321 //@{ 04322 /// Public typedefs 04323 typedef _CharT char_type; 04324 typedef basic_string<_CharT> string_type; 04325 //@} 04326 04327 protected: 04328 // Underlying "C" library locale information saved from 04329 // initialization, needed by messages_byname as well. 04330 __c_locale _M_c_locale_messages; 04331 const char* _M_name_messages; 04332 04333 public: 04334 /// Numpunct facet id. 04335 static locale::id id; 04336 04337 /** 04338 * @brief Constructor performs initialization. 04339 * 04340 * This is the constructor provided by the standard. 04341 * 04342 * @param refs Passed to the base facet class. 04343 */ 04344 explicit 04345 messages(size_t __refs = 0); 04346 04347 // Non-standard. 04348 /** 04349 * @brief Internal constructor. Not for general use. 04350 * 04351 * This is a constructor for use by the library itself to set up new 04352 * locales. 04353 * 04354 * @param cloc The "C" locale. 04355 * @param s The name of a locale. 04356 * @param refs Refcount to pass to the base class. 04357 */ 04358 explicit 04359 messages(__c_locale __cloc, const char* __s, size_t __refs = 0); 04360 04361 /* 04362 * @brief Open a message catalog. 04363 * 04364 * This function opens and returns a handle to a message catalog by 04365 * returning do_open(s, loc). 04366 * 04367 * @param s The catalog to open. 04368 * @param loc Locale to use for character set conversions. 04369 * @return Handle to the catalog or value < 0 if open fails. 04370 */ 04371 catalog 04372 open(const basic_string<char>& __s, const locale& __loc) const 04373 { return this->do_open(__s, __loc); } 04374 04375 // Non-standard and unorthodox, yet effective. 04376 /* 04377 * @brief Open a message catalog. 04378 * 04379 * This non-standard function opens and returns a handle to a message 04380 * catalog by returning do_open(s, loc). The third argument provides a 04381 * message catalog root directory for gnu gettext and is ignored 04382 * otherwise. 04383 * 04384 * @param s The catalog to open. 04385 * @param loc Locale to use for character set conversions. 04386 * @param dir Message catalog root directory. 04387 * @return Handle to the catalog or value < 0 if open fails. 04388 */ 04389 catalog 04390 open(const basic_string<char>&, const locale&, const char*) const; 04391 04392 /* 04393 * @brief Look up a string in a message catalog. 04394 * 04395 * This function retrieves and returns a message from a catalog by 04396 * returning do_get(c, set, msgid, s). 04397 * 04398 * For gnu, @a set and @a msgid are ignored. Returns gettext(s). 04399 * For default, returns s. For ieee, returns catgets(c,set,msgid,s). 04400 * 04401 * @param c The catalog to access. 04402 * @param set Implementation-defined. 04403 * @param msgid Implementation-defined. 04404 * @param s Default return value if retrieval fails. 04405 * @return Retrieved message or @a s if get fails. 04406 */ 04407 string_type 04408 get(catalog __c, int __set, int __msgid, const string_type& __s) const 04409 { return this->do_get(__c, __set, __msgid, __s); } 04410 04411 /* 04412 * @brief Close a message catalog. 04413 * 04414 * Closes catalog @a c by calling do_close(c). 04415 * 04416 * @param c The catalog to close. 04417 */ 04418 void 04419 close(catalog __c) const 04420 { return this->do_close(__c); } 04421 04422 protected: 04423 /// Destructor. 04424 virtual 04425 ~messages(); 04426 04427 /* 04428 * @brief Open a message catalog. 04429 * 04430 * This function opens and returns a handle to a message catalog in an 04431 * implementation-defined manner. This function is a hook for derived 04432 * classes to change the value returned. 04433 * 04434 * @param s The catalog to open. 04435 * @param loc Locale to use for character set conversions. 04436 * @return Handle to the opened catalog, value < 0 if open failed. 04437 */ 04438 virtual catalog 04439 do_open(const basic_string<char>&, const locale&) const; 04440 04441 /* 04442 * @brief Look up a string in a message catalog. 04443 * 04444 * This function retrieves and returns a message from a catalog in an 04445 * implementation-defined manner. This function is a hook for derived 04446 * classes to change the value returned. 04447 * 04448 * For gnu, @a set and @a msgid are ignored. Returns gettext(s). 04449 * For default, returns s. For ieee, returns catgets(c,set,msgid,s). 04450 * 04451 * @param c The catalog to access. 04452 * @param set Implementation-defined. 04453 * @param msgid Implementation-defined. 04454 * @param s Default return value if retrieval fails. 04455 * @return Retrieved message or @a s if get fails. 04456 */ 04457 virtual string_type 04458 do_get(catalog, int, int, const string_type& __dfault) const; 04459 04460 /* 04461 * @brief Close a message catalog. 04462 * 04463 * @param c The catalog to close. 04464 */ 04465 virtual void 04466 do_close(catalog) const; 04467 04468 // Returns a locale and codeset-converted string, given a char* message. 04469 char* 04470 _M_convert_to_char(const string_type& __msg) const 04471 { 04472 // XXX 04473 return reinterpret_cast<char*>(const_cast<_CharT*>(__msg.c_str())); 04474 } 04475 04476 // Returns a locale and codeset-converted string, given a char* message. 04477 string_type 04478 _M_convert_from_char(char*) const 04479 { 04480 #if 0 04481 // Length of message string without terminating null. 04482 size_t __len = char_traits<char>::length(__msg) - 1; 04483 04484 // "everybody can easily convert the string using 04485 // mbsrtowcs/wcsrtombs or with iconv()" 04486 04487 // Convert char* to _CharT in locale used to open catalog. 04488 // XXX need additional template parameter on messages class for this.. 04489 // typedef typename codecvt<char, _CharT, _StateT> __codecvt_type; 04490 typedef typename codecvt<char, _CharT, mbstate_t> __codecvt_type; 04491 04492 __codecvt_type::state_type __state; 04493 // XXX may need to initialize state. 04494 //initialize_state(__state._M_init()); 04495 04496 char* __from_next; 04497 // XXX what size for this string? 04498 _CharT* __to = static_cast<_CharT*>(__builtin_alloca(__len + 1)); 04499 const __codecvt_type& __cvt = use_facet<__codecvt_type>(_M_locale_conv); 04500 __cvt.out(__state, __msg, __msg + __len, __from_next, 04501 __to, __to + __len + 1, __to_next); 04502 return string_type(__to); 04503 #endif 04504 #if 0 04505 typedef ctype<_CharT> __ctype_type; 04506 // const __ctype_type& __cvt = use_facet<__ctype_type>(_M_locale_msg); 04507 const __ctype_type& __cvt = use_facet<__ctype_type>(locale()); 04508 // XXX Again, proper length of converted string an issue here. 04509 // For now, assume the converted length is not larger. 04510 _CharT* __dest = static_cast<_CharT*>(__builtin_alloca(__len + 1)); 04511 __cvt.widen(__msg, __msg + __len, __dest); 04512 return basic_string<_CharT>(__dest); 04513 #endif 04514 return string_type(); 04515 } 04516 }; 04517 04518 template<typename _CharT> 04519 locale::id messages<_CharT>::id; 04520 04521 // Specializations for required instantiations. 04522 template<> 04523 string 04524 messages<char>::do_get(catalog, int, int, const string&) const; 04525 04526 #ifdef _GLIBCXX_USE_WCHAR_T 04527 template<> 04528 wstring 04529 messages<wchar_t>::do_get(catalog, int, int, const wstring&) const; 04530 #endif 04531 04532 /// @brief class messages_byname [22.2.7.2]. 04533 template<typename _CharT> 04534 class messages_byname : public messages<_CharT> 04535 { 04536 public: 04537 typedef _CharT char_type; 04538 typedef basic_string<_CharT> string_type; 04539 04540 explicit 04541 messages_byname(const char* __s, size_t __refs = 0); 04542 04543 protected: 04544 virtual 04545 ~messages_byname() 04546 { } 04547 }; 04548 04549 // Include host and configuration specific messages functions. 04550 #include <bits/messages_members.h> 04551 04552 04553 // Subclause convenience interfaces, inlines. 04554 // NB: These are inline because, when used in a loop, some compilers 04555 // can hoist the body out of the loop; then it's just as fast as the 04556 // C is*() function. 04557 04558 /// Convenience interface to ctype.is(ctype_base::space, __c). 04559 template<typename _CharT> 04560 inline bool 04561 isspace(_CharT __c, const locale& __loc) 04562 { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::space, __c); } 04563 04564 /// Convenience interface to ctype.is(ctype_base::print, __c). 04565 template<typename _CharT> 04566 inline bool 04567 isprint(_CharT __c, const locale& __loc) 04568 { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::print, __c); } 04569 04570 /// Convenience interface to ctype.is(ctype_base::cntrl, __c). 04571 template<typename _CharT> 04572 inline bool 04573 iscntrl(_CharT __c, const locale& __loc) 04574 { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::cntrl, __c); } 04575 04576 /// Convenience interface to ctype.is(ctype_base::upper, __c). 04577 template<typename _CharT> 04578 inline bool 04579 isupper(_CharT __c, const locale& __loc) 04580 { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::upper, __c); } 04581 04582 /// Convenience interface to ctype.is(ctype_base::lower, __c). 04583 template<typename _CharT> 04584 inline bool 04585 islower(_CharT __c, const locale& __loc) 04586 { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::lower, __c); } 04587 04588 /// Convenience interface to ctype.is(ctype_base::alpha, __c). 04589 template<typename _CharT> 04590 inline bool 04591 isalpha(_CharT __c, const locale& __loc) 04592 { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::alpha, __c); } 04593 04594 /// Convenience interface to ctype.is(ctype_base::digit, __c). 04595 template<typename _CharT> 04596 inline bool 04597 isdigit(_CharT __c, const locale& __loc) 04598 { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::digit, __c); } 04599 04600 /// Convenience interface to ctype.is(ctype_base::punct, __c). 04601 template<typename _CharT> 04602 inline bool 04603 ispunct(_CharT __c, const locale& __loc) 04604 { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::punct, __c); } 04605 04606 /// Convenience interface to ctype.is(ctype_base::xdigit, __c). 04607 template<typename _CharT> 04608 inline bool 04609 isxdigit(_CharT __c, const locale& __loc) 04610 { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::xdigit, __c); } 04611 04612 /// Convenience interface to ctype.is(ctype_base::alnum, __c). 04613 template<typename _CharT> 04614 inline bool 04615 isalnum(_CharT __c, const locale& __loc) 04616 { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::alnum, __c); } 04617 04618 /// Convenience interface to ctype.is(ctype_base::graph, __c). 04619 template<typename _CharT> 04620 inline bool 04621 isgraph(_CharT __c, const locale& __loc) 04622 { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::graph, __c); } 04623 04624 /// Convenience interface to ctype.toupper(__c). 04625 template<typename _CharT> 04626 inline _CharT 04627 toupper(_CharT __c, const locale& __loc) 04628 { return use_facet<ctype<_CharT> >(__loc).toupper(__c); } 04629 04630 /// Convenience interface to ctype.tolower(__c). 04631 template<typename _CharT> 04632 inline _CharT 04633 tolower(_CharT __c, const locale& __loc) 04634 { return use_facet<ctype<_CharT> >(__loc).tolower(__c); } 04635 } // namespace std 04636 04637 #endif