locale_facets.h

Go to the documentation of this file.
00001 // Locale support -*- C++ -*-
00002 
00003 // Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 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

Generated on Tue Dec 2 03:59:26 2008 for libstdc++ by  doxygen 1.5.7.1