LCOV - code coverage report
Current view: top level - usr/include/c++/9/bits - locale_facets.h (source / functions) Hit Total Coverage
Test: ROSE Lines: 15 30 50.0 %
Date: 2022-12-08 13:48:47 Functions: 2 3 66.7 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : // Locale support -*- C++ -*-
       2             : 
       3             : // Copyright (C) 1997-2019 Free Software Foundation, Inc.
       4             : //
       5             : // This file is part of the GNU ISO C++ Library.  This library is free
       6             : // software; you can redistribute it and/or modify it under the
       7             : // terms of the GNU General Public License as published by the
       8             : // Free Software Foundation; either version 3, or (at your option)
       9             : // any later version.
      10             : 
      11             : // This library is distributed in the hope that it will be useful,
      12             : // but WITHOUT ANY WARRANTY; without even the implied warranty of
      13             : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      14             : // GNU General Public License for more details.
      15             : 
      16             : // Under Section 7 of GPL version 3, you are granted additional
      17             : // permissions described in the GCC Runtime Library Exception, version
      18             : // 3.1, as published by the Free Software Foundation.
      19             : 
      20             : // You should have received a copy of the GNU General Public License and
      21             : // a copy of the GCC Runtime Library Exception along with this program;
      22             : // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
      23             : // <http://www.gnu.org/licenses/>.
      24             : 
      25             : /** @file bits/locale_facets.h
      26             :  *  This is an internal header file, included by other library headers.
      27             :  *  Do not attempt to use it directly. @headername{locale}
      28             :  */
      29             : 
      30             : //
      31             : // ISO C++ 14882: 22.1  Locales
      32             : //
      33             : 
      34             : #ifndef _LOCALE_FACETS_H
      35             : #define _LOCALE_FACETS_H 1
      36             : 
      37             : #pragma GCC system_header
      38             : 
      39             : #include <cwctype>        // For wctype_t
      40             : #include <cctype>
      41             : #include <bits/ctype_base.h>
      42             : #include <iosfwd>
      43             : #include <bits/ios_base.h>  // For ios_base, ios_base::iostate
      44             : #include <streambuf>
      45             : #include <bits/cpp_type_traits.h>
      46             : #include <ext/type_traits.h>
      47             : #include <ext/numeric_traits.h>
      48             : #include <bits/streambuf_iterator.h>
      49             : 
      50             : namespace std _GLIBCXX_VISIBILITY(default)
      51             : {
      52             : _GLIBCXX_BEGIN_NAMESPACE_VERSION
      53             : 
      54             :   // NB: Don't instantiate required wchar_t facets if no wchar_t support.
      55             : #ifdef _GLIBCXX_USE_WCHAR_T
      56             : # define  _GLIBCXX_NUM_FACETS 28
      57             : # define  _GLIBCXX_NUM_CXX11_FACETS 16
      58             : #else
      59             : # define  _GLIBCXX_NUM_FACETS 14
      60             : # define  _GLIBCXX_NUM_CXX11_FACETS 8
      61             : #endif
      62             : #ifdef _GLIBCXX_USE_CHAR8_T
      63             : # define _GLIBCXX_NUM_UNICODE_FACETS 4
      64             : #else
      65             : # define _GLIBCXX_NUM_UNICODE_FACETS 2
      66             : #endif
      67             : 
      68             :   // Convert string to numeric value of type _Tp and store results.
      69             :   // NB: This is specialized for all required types, there is no
      70             :   // generic definition.
      71             :   template<typename _Tp>
      72             :     void
      73             :     __convert_to_v(const char*, _Tp&, ios_base::iostate&,
      74             :                    const __c_locale&) throw();
      75             : 
      76             :   // Explicit specializations for required types.
      77             :   template<>
      78             :     void
      79             :     __convert_to_v(const char*, float&, ios_base::iostate&,
      80             :                    const __c_locale&) throw();
      81             : 
      82             :   template<>
      83             :     void
      84             :     __convert_to_v(const char*, double&, ios_base::iostate&,
      85             :                    const __c_locale&) throw();
      86             : 
      87             :   template<>
      88             :     void
      89             :     __convert_to_v(const char*, long double&, ios_base::iostate&,
      90             :                    const __c_locale&) throw();
      91             : 
      92             :   // NB: __pad is a struct, rather than a function, so it can be
      93             :   // partially-specialized.
      94             :   template<typename _CharT, typename _Traits>
      95             :     struct __pad
      96             :     {
      97             :       static void
      98             :       _S_pad(ios_base& __io, _CharT __fill, _CharT* __news,
      99             :              const _CharT* __olds, streamsize __newlen, streamsize __oldlen);
     100             :     };
     101             : 
     102             :   // Used by both numeric and monetary facets.
     103             :   // Inserts "group separator" characters into an array of characters.
     104             :   // It's recursive, one iteration per group.  It moves the characters
     105             :   // in the buffer this way: "xxxx12345" -> "12,345xxx".  Call this
     106             :   // only with __gsize != 0.
     107             :   template<typename _CharT>
     108             :     _CharT*
     109             :     __add_grouping(_CharT* __s, _CharT __sep,
     110             :                    const char* __gbeg, size_t __gsize,
     111             :                    const _CharT* __first, const _CharT* __last);
     112             : 
     113             :   // This template permits specializing facet output code for
     114             :   // ostreambuf_iterator.  For ostreambuf_iterator, sputn is
     115             :   // significantly more efficient than incrementing iterators.
     116             :   template<typename _CharT>
     117             :     inline
     118             :     ostreambuf_iterator<_CharT>
     119             :     __write(ostreambuf_iterator<_CharT> __s, const _CharT* __ws, int __len)
     120             :     {
     121             :       __s._M_put(__ws, __len);
     122             :       return __s;
     123             :     }
     124             : 
     125             :   // This is the unspecialized form of the template.
     126             :   template<typename _CharT, typename _OutIter>
     127             :     inline
     128             :     _OutIter
     129             :     __write(_OutIter __s, const _CharT* __ws, int __len)
     130             :     {
     131             :       for (int __j = 0; __j < __len; __j++, ++__s)
     132             :         *__s = __ws[__j];
     133             :       return __s;
     134             :     }
     135             : 
     136             : 
     137             :   // 22.2.1.1  Template class ctype
     138             :   // Include host and configuration specific ctype enums for ctype_base.
     139             : 
     140             :   /**
     141             :    *  @brief  Common base for ctype facet
     142             :    *
     143             :    *  This template class provides implementations of the public functions
     144             :    *  that forward to the protected virtual functions.
     145             :    *
     146             :    *  This template also provides abstract stubs for the protected virtual
     147             :    *  functions.
     148             :   */
     149             :   template<typename _CharT>
     150             :     class __ctype_abstract_base : public locale::facet, public ctype_base
     151             :     {
     152             :     public:
     153             :       // Types:
     154             :       /// Typedef for the template parameter
     155             :       typedef _CharT char_type;
     156             : 
     157             :       /**
     158             :        *  @brief  Test char_type classification.
     159             :        *
     160             :        *  This function finds a mask M for @a __c and compares it to
     161             :        *  mask @a __m.  It does so by returning the value of
     162             :        *  ctype<char_type>::do_is().
     163             :        *
     164             :        *  @param __c  The char_type to compare the mask of.
     165             :        *  @param __m  The mask to compare against.
     166             :        *  @return  (M & __m) != 0.
     167             :       */
     168             :       bool
     169             :       is(mask __m, char_type __c) const
     170             :       { return this->do_is(__m, __c); }
     171             : 
     172             :       /**
     173             :        *  @brief  Return a mask array.
     174             :        *
     175             :        *  This function finds the mask for each char_type in the range [lo,hi)
     176             :        *  and successively writes it to vec.  vec must have as many elements
     177             :        *  as the char array.  It does so by returning the value of
     178             :        *  ctype<char_type>::do_is().
     179             :        *
     180             :        *  @param __lo  Pointer to start of range.
     181             :        *  @param __hi  Pointer to end of range.
     182             :        *  @param __vec  Pointer to an array of mask storage.
     183             :        *  @return  @a __hi.
     184             :       */
     185             :       const char_type*
     186             :       is(const char_type *__lo, const char_type *__hi, mask *__vec) const
     187             :       { return this->do_is(__lo, __hi, __vec); }
     188             : 
     189             :       /**
     190             :        *  @brief  Find char_type matching a mask
     191             :        *
     192             :        *  This function searches for and returns the first char_type c in
     193             :        *  [lo,hi) for which is(m,c) is true.  It does so by returning
     194             :        *  ctype<char_type>::do_scan_is().
     195             :        *
     196             :        *  @param __m  The mask to compare against.
     197             :        *  @param __lo  Pointer to start of range.
     198             :        *  @param __hi  Pointer to end of range.
     199             :        *  @return  Pointer to matching char_type if found, else @a __hi.
     200             :       */
     201             :       const char_type*
     202             :       scan_is(mask __m, const char_type* __lo, const char_type* __hi) const
     203             :       { return this->do_scan_is(__m, __lo, __hi); }
     204             : 
     205             :       /**
     206             :        *  @brief  Find char_type not matching a mask
     207             :        *
     208             :        *  This function searches for and returns the first char_type c in
     209             :        *  [lo,hi) for which is(m,c) is false.  It does so by returning
     210             :        *  ctype<char_type>::do_scan_not().
     211             :        *
     212             :        *  @param __m  The mask to compare against.
     213             :        *  @param __lo  Pointer to first char in range.
     214             :        *  @param __hi  Pointer to end of range.
     215             :        *  @return  Pointer to non-matching char if found, else @a __hi.
     216             :       */
     217             :       const char_type*
     218             :       scan_not(mask __m, const char_type* __lo, const char_type* __hi) const
     219             :       { return this->do_scan_not(__m, __lo, __hi); }
     220             : 
     221             :       /**
     222             :        *  @brief  Convert to uppercase.
     223             :        *
     224             :        *  This function converts the argument to uppercase if possible.
     225             :        *  If not possible (for example, '2'), returns the argument.  It does
     226             :        *  so by returning ctype<char_type>::do_toupper().
     227             :        *
     228             :        *  @param __c  The char_type to convert.
     229             :        *  @return  The uppercase char_type if convertible, else @a __c.
     230             :       */
     231             :       char_type
     232             :       toupper(char_type __c) const
     233             :       { return this->do_toupper(__c); }
     234             : 
     235             :       /**
     236             :        *  @brief  Convert array to uppercase.
     237             :        *
     238             :        *  This function converts each char_type in the range [lo,hi) to
     239             :        *  uppercase if possible.  Other elements remain untouched.  It does so
     240             :        *  by returning ctype<char_type>:: do_toupper(lo, hi).
     241             :        *
     242             :        *  @param __lo  Pointer to start of range.
     243             :        *  @param __hi  Pointer to end of range.
     244             :        *  @return  @a __hi.
     245             :       */
     246             :       const char_type*
     247             :       toupper(char_type *__lo, const char_type* __hi) const
     248             :       { return this->do_toupper(__lo, __hi); }
     249             : 
     250             :       /**
     251             :        *  @brief  Convert to lowercase.
     252             :        *
     253             :        *  This function converts the argument to lowercase if possible.  If
     254             :        *  not possible (for example, '2'), returns the argument.  It does so
     255             :        *  by returning ctype<char_type>::do_tolower(c).
     256             :        *
     257             :        *  @param __c  The char_type to convert.
     258             :        *  @return  The lowercase char_type if convertible, else @a __c.
     259             :       */
     260             :       char_type
     261             :       tolower(char_type __c) const
     262             :       { return this->do_tolower(__c); }
     263             : 
     264             :       /**
     265             :        *  @brief  Convert array to lowercase.
     266             :        *
     267             :        *  This function converts each char_type in the range [__lo,__hi) to
     268             :        *  lowercase if possible.  Other elements remain untouched.  It does so
     269             :        *  by returning ctype<char_type>:: do_tolower(__lo, __hi).
     270             :        *
     271             :        *  @param __lo  Pointer to start of range.
     272             :        *  @param __hi  Pointer to end of range.
     273             :        *  @return  @a __hi.
     274             :       */
     275             :       const char_type*
     276             :       tolower(char_type* __lo, const char_type* __hi) const
     277             :       { return this->do_tolower(__lo, __hi); }
     278             : 
     279             :       /**
     280             :        *  @brief  Widen char to char_type
     281             :        *
     282             :        *  This function converts the char argument to char_type using the
     283             :        *  simplest reasonable transformation.  It does so by returning
     284             :        *  ctype<char_type>::do_widen(c).
     285             :        *
     286             :        *  Note: this is not what you want for codepage conversions.  See
     287             :        *  codecvt for that.
     288             :        *
     289             :        *  @param __c  The char to convert.
     290             :        *  @return  The converted char_type.
     291             :       */
     292             :       char_type
     293             :       widen(char __c) const
     294             :       { return this->do_widen(__c); }
     295             : 
     296             :       /**
     297             :        *  @brief  Widen array to char_type
     298             :        *
     299             :        *  This function converts each char in the input to char_type using the
     300             :        *  simplest reasonable transformation.  It does so by returning
     301             :        *  ctype<char_type>::do_widen(c).
     302             :        *
     303             :        *  Note: this is not what you want for codepage conversions.  See
     304             :        *  codecvt for that.
     305             :        *
     306             :        *  @param __lo  Pointer to start of range.
     307             :        *  @param __hi  Pointer to end of range.
     308             :        *  @param __to  Pointer to the destination array.
     309             :        *  @return  @a __hi.
     310             :       */
     311             :       const char*
     312             :       widen(const char* __lo, const char* __hi, char_type* __to) const
     313             :       { return this->do_widen(__lo, __hi, __to); }
     314             : 
     315             :       /**
     316             :        *  @brief  Narrow char_type to char
     317             :        *
     318             :        *  This function converts the char_type to char using the simplest
     319             :        *  reasonable transformation.  If the conversion fails, dfault is
     320             :        *  returned instead.  It does so by returning
     321             :        *  ctype<char_type>::do_narrow(__c).
     322             :        *
     323             :        *  Note: this is not what you want for codepage conversions.  See
     324             :        *  codecvt for that.
     325             :        *
     326             :        *  @param __c  The char_type to convert.
     327             :        *  @param __dfault  Char to return if conversion fails.
     328             :        *  @return  The converted char.
     329             :       */
     330             :       char
     331             :       narrow(char_type __c, char __dfault) const
     332             :       { return this->do_narrow(__c, __dfault); }
     333             : 
     334             :       /**
     335             :        *  @brief  Narrow array to char array
     336             :        *
     337             :        *  This function converts each char_type in the input to char using the
     338             :        *  simplest reasonable transformation and writes the results to the
     339             :        *  destination array.  For any char_type in the input that cannot be
     340             :        *  converted, @a dfault is used instead.  It does so by returning
     341             :        *  ctype<char_type>::do_narrow(__lo, __hi, __dfault, __to).
     342             :        *
     343             :        *  Note: this is not what you want for codepage conversions.  See
     344             :        *  codecvt for that.
     345             :        *
     346             :        *  @param __lo  Pointer to start of range.
     347             :        *  @param __hi  Pointer to end of range.
     348             :        *  @param __dfault  Char to use if conversion fails.
     349             :        *  @param __to  Pointer to the destination array.
     350             :        *  @return  @a __hi.
     351             :       */
     352             :       const char_type*
     353             :       narrow(const char_type* __lo, const char_type* __hi,
     354             :               char __dfault, char* __to) const
     355             :       { return this->do_narrow(__lo, __hi, __dfault, __to); }
     356             : 
     357             :     protected:
     358             :       explicit
     359             :       __ctype_abstract_base(size_t __refs = 0): facet(__refs) { }
     360             : 
     361             :       virtual
     362             :       ~__ctype_abstract_base() { }
     363             : 
     364             :       /**
     365             :        *  @brief  Test char_type classification.
     366             :        *
     367             :        *  This function finds a mask M for @a c and compares it to mask @a m.
     368             :        *
     369             :        *  do_is() is a hook for a derived facet to change the behavior of
     370             :        *  classifying.  do_is() must always return the same result for the
     371             :        *  same input.
     372             :        *
     373             :        *  @param __c  The char_type to find the mask of.
     374             :        *  @param __m  The mask to compare against.
     375             :        *  @return  (M & __m) != 0.
     376             :       */
     377             :       virtual bool
     378             :       do_is(mask __m, char_type __c) const = 0;
     379             : 
     380             :       /**
     381             :        *  @brief  Return a mask array.
     382             :        *
     383             :        *  This function finds the mask for each char_type in the range [lo,hi)
     384             :        *  and successively writes it to vec.  vec must have as many elements
     385             :        *  as the input.
     386             :        *
     387             :        *  do_is() is a hook for a derived facet to change the behavior of
     388             :        *  classifying.  do_is() must always return the same result for the
     389             :        *  same input.
     390             :        *
     391             :        *  @param __lo  Pointer to start of range.
     392             :        *  @param __hi  Pointer to end of range.
     393             :        *  @param __vec  Pointer to an array of mask storage.
     394             :        *  @return  @a __hi.
     395             :       */
     396             :       virtual const char_type*
     397             :       do_is(const char_type* __lo, const char_type* __hi,
     398             :             mask* __vec) const = 0;
     399             : 
     400             :       /**
     401             :        *  @brief  Find char_type matching mask
     402             :        *
     403             :        *  This function searches for and returns the first char_type c in
     404             :        *  [__lo,__hi) for which is(__m,c) is true.
     405             :        *
     406             :        *  do_scan_is() is a hook for a derived facet to change the behavior of
     407             :        *  match searching.  do_is() must always return the same result for the
     408             :        *  same input.
     409             :        *
     410             :        *  @param __m  The mask to compare against.
     411             :        *  @param __lo  Pointer to start of range.
     412             :        *  @param __hi  Pointer to end of range.
     413             :        *  @return  Pointer to a matching char_type if found, else @a __hi.
     414             :       */
     415             :       virtual const char_type*
     416             :       do_scan_is(mask __m, const char_type* __lo,
     417             :                  const char_type* __hi) const = 0;
     418             : 
     419             :       /**
     420             :        *  @brief  Find char_type not matching mask
     421             :        *
     422             :        *  This function searches for and returns a pointer to the first
     423             :        *  char_type c of [lo,hi) for which is(m,c) is false.
     424             :        *
     425             :        *  do_scan_is() is a hook for a derived facet to change the behavior of
     426             :        *  match searching.  do_is() must always return the same result for the
     427             :        *  same input.
     428             :        *
     429             :        *  @param __m  The mask to compare against.
     430             :        *  @param __lo  Pointer to start of range.
     431             :        *  @param __hi  Pointer to end of range.
     432             :        *  @return  Pointer to a non-matching char_type if found, else @a __hi.
     433             :       */
     434             :       virtual const char_type*
     435             :       do_scan_not(mask __m, const char_type* __lo,
     436             :                   const char_type* __hi) const = 0;
     437             : 
     438             :       /**
     439             :        *  @brief  Convert to uppercase.
     440             :        *
     441             :        *  This virtual function converts the char_type argument to uppercase
     442             :        *  if possible.  If not possible (for example, '2'), returns the
     443             :        *  argument.
     444             :        *
     445             :        *  do_toupper() is a hook for a derived facet to change the behavior of
     446             :        *  uppercasing.  do_toupper() must always return the same result for
     447             :        *  the same input.
     448             :        *
     449             :        *  @param __c  The char_type to convert.
     450             :        *  @return  The uppercase char_type if convertible, else @a __c.
     451             :       */
     452             :       virtual char_type
     453             :       do_toupper(char_type __c) const = 0;
     454             : 
     455             :       /**
     456             :        *  @brief  Convert array to uppercase.
     457             :        *
     458             :        *  This virtual function converts each char_type in the range [__lo,__hi)
     459             :        *  to uppercase if possible.  Other elements remain untouched.
     460             :        *
     461             :        *  do_toupper() is a hook for a derived facet to change the behavior of
     462             :        *  uppercasing.  do_toupper() must always return the same result for
     463             :        *  the same input.
     464             :        *
     465             :        *  @param __lo  Pointer to start of range.
     466             :        *  @param __hi  Pointer to end of range.
     467             :        *  @return  @a __hi.
     468             :       */
     469             :       virtual const char_type*
     470             :       do_toupper(char_type* __lo, const char_type* __hi) const = 0;
     471             : 
     472             :       /**
     473             :        *  @brief  Convert to lowercase.
     474             :        *
     475             :        *  This virtual function converts the argument to lowercase if
     476             :        *  possible.  If not possible (for example, '2'), returns the argument.
     477             :        *
     478             :        *  do_tolower() is a hook for a derived facet to change the behavior of
     479             :        *  lowercasing.  do_tolower() must always return the same result for
     480             :        *  the same input.
     481             :        *
     482             :        *  @param __c  The char_type to convert.
     483             :        *  @return  The lowercase char_type if convertible, else @a __c.
     484             :       */
     485             :       virtual char_type
     486             :       do_tolower(char_type __c) const = 0;
     487             : 
     488             :       /**
     489             :        *  @brief  Convert array to lowercase.
     490             :        *
     491             :        *  This virtual function converts each char_type in the range [__lo,__hi)
     492             :        *  to lowercase if possible.  Other elements remain untouched.
     493             :        *
     494             :        *  do_tolower() is a hook for a derived facet to change the behavior of
     495             :        *  lowercasing.  do_tolower() must always return the same result for
     496             :        *  the same input.
     497             :        *
     498             :        *  @param __lo  Pointer to start of range.
     499             :        *  @param __hi  Pointer to end of range.
     500             :        *  @return  @a __hi.
     501             :       */
     502             :       virtual const char_type*
     503             :       do_tolower(char_type* __lo, const char_type* __hi) const = 0;
     504             : 
     505             :       /**
     506             :        *  @brief  Widen char
     507             :        *
     508             :        *  This virtual function converts the char to char_type using the
     509             :        *  simplest reasonable transformation.
     510             :        *
     511             :        *  do_widen() is a hook for a derived facet to change the behavior of
     512             :        *  widening.  do_widen() must always return the same result for the
     513             :        *  same input.
     514             :        *
     515             :        *  Note: this is not what you want for codepage conversions.  See
     516             :        *  codecvt for that.
     517             :        *
     518             :        *  @param __c  The char to convert.
     519             :        *  @return  The converted char_type
     520             :       */
     521             :       virtual char_type
     522             :       do_widen(char __c) const = 0;
     523             : 
     524             :       /**
     525             :        *  @brief  Widen char array
     526             :        *
     527             :        *  This function converts each char in the input to char_type using the
     528             :        *  simplest reasonable transformation.
     529             :        *
     530             :        *  do_widen() is a hook for a derived facet to change the behavior of
     531             :        *  widening.  do_widen() must always return the same result for the
     532             :        *  same input.
     533             :        *
     534             :        *  Note: this is not what you want for codepage conversions.  See
     535             :        *  codecvt for that.
     536             :        *
     537             :        *  @param __lo  Pointer to start range.
     538             :        *  @param __hi  Pointer to end of range.
     539             :        *  @param __to  Pointer to the destination array.
     540             :        *  @return  @a __hi.
     541             :       */
     542             :       virtual const char*
     543             :       do_widen(const char* __lo, const char* __hi, char_type* __to) const = 0;
     544             : 
     545             :       /**
     546             :        *  @brief  Narrow char_type to char
     547             :        *
     548             :        *  This virtual function converts the argument to char using the
     549             :        *  simplest reasonable transformation.  If the conversion fails, dfault
     550             :        *  is returned instead.
     551             :        *
     552             :        *  do_narrow() is a hook for a derived facet to change the behavior of
     553             :        *  narrowing.  do_narrow() must always return the same result for the
     554             :        *  same input.
     555             :        *
     556             :        *  Note: this is not what you want for codepage conversions.  See
     557             :        *  codecvt for that.
     558             :        *
     559             :        *  @param __c  The char_type to convert.
     560             :        *  @param __dfault  Char to return if conversion fails.
     561             :        *  @return  The converted char.
     562             :       */
     563             :       virtual char
     564             :       do_narrow(char_type __c, char __dfault) const = 0;
     565             : 
     566             :       /**
     567             :        *  @brief  Narrow char_type array to char
     568             :        *
     569             :        *  This virtual function converts each char_type in the range
     570             :        *  [__lo,__hi) to char using the simplest reasonable
     571             :        *  transformation and writes the results to the destination
     572             :        *  array.  For any element in the input that cannot be
     573             :        *  converted, @a __dfault is used instead.
     574             :        *
     575             :        *  do_narrow() is a hook for a derived facet to change the behavior of
     576             :        *  narrowing.  do_narrow() must always return the same result for the
     577             :        *  same input.
     578             :        *
     579             :        *  Note: this is not what you want for codepage conversions.  See
     580             :        *  codecvt for that.
     581             :        *
     582             :        *  @param __lo  Pointer to start of range.
     583             :        *  @param __hi  Pointer to end of range.
     584             :        *  @param __dfault  Char to use if conversion fails.
     585             :        *  @param __to  Pointer to the destination array.
     586             :        *  @return  @a __hi.
     587             :       */
     588             :       virtual const char_type*
     589             :       do_narrow(const char_type* __lo, const char_type* __hi,
     590             :                 char __dfault, char* __to) const = 0;
     591             :     };
     592             : 
     593             :   /**
     594             :    *  @brief  Primary class template ctype facet.
     595             :    *  @ingroup locales
     596             :    *
     597             :    *  This template class defines classification and conversion functions for
     598             :    *  character sets.  It wraps cctype functionality.  Ctype gets used by
     599             :    *  streams for many I/O operations.
     600             :    *
     601             :    *  This template provides the protected virtual functions the developer
     602             :    *  will have to replace in a derived class or specialization to make a
     603             :    *  working facet.  The public functions that access them are defined in
     604             :    *  __ctype_abstract_base, to allow for implementation flexibility.  See
     605             :    *  ctype<wchar_t> for an example.  The functions are documented in
     606             :    *  __ctype_abstract_base.
     607             :    *
     608             :    *  Note: implementations are provided for all the protected virtual
     609             :    *  functions, but will likely not be useful.
     610             :   */
     611             :   template<typename _CharT>
     612             :     class ctype : public __ctype_abstract_base<_CharT>
     613             :     {
     614             :     public:
     615             :       // Types:
     616             :       typedef _CharT                    char_type;
     617             :       typedef typename __ctype_abstract_base<_CharT>::mask mask;
     618             : 
     619             :       /// The facet id for ctype<char_type>
     620             :       static locale::id                 id;
     621             : 
     622             :       explicit
     623             :       ctype(size_t __refs = 0) : __ctype_abstract_base<_CharT>(__refs) { }
     624             : 
     625             :    protected:
     626             :       virtual
     627             :       ~ctype();
     628             : 
     629             :       virtual bool
     630             :       do_is(mask __m, char_type __c) const;
     631             : 
     632             :       virtual const char_type*
     633             :       do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const;
     634             : 
     635             :       virtual const char_type*
     636             :       do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const;
     637             : 
     638             :       virtual const char_type*
     639             :       do_scan_not(mask __m, const char_type* __lo,
     640             :                   const char_type* __hi) const;
     641             : 
     642             :       virtual char_type
     643             :       do_toupper(char_type __c) const;
     644             : 
     645             :       virtual const char_type*
     646             :       do_toupper(char_type* __lo, const char_type* __hi) const;
     647             : 
     648             :       virtual char_type
     649             :       do_tolower(char_type __c) const;
     650             : 
     651             :       virtual const char_type*
     652             :       do_tolower(char_type* __lo, const char_type* __hi) const;
     653             : 
     654             :       virtual char_type
     655             :       do_widen(char __c) const;
     656             : 
     657             :       virtual const char*
     658             :       do_widen(const char* __lo, const char* __hi, char_type* __dest) const;
     659             : 
     660             :       virtual char
     661             :       do_narrow(char_type, char __dfault) const;
     662             : 
     663             :       virtual const char_type*
     664             :       do_narrow(const char_type* __lo, const char_type* __hi,
     665             :                 char __dfault, char* __to) const;
     666             :     };
     667             : 
     668             :   template<typename _CharT>
     669             :     locale::id ctype<_CharT>::id;
     670             : 
     671             :   /**
     672             :    *  @brief  The ctype<char> specialization.
     673             :    *  @ingroup locales
     674             :    *
     675             :    *  This class defines classification and conversion functions for
     676             :    *  the char type.  It gets used by char streams for many I/O
     677             :    *  operations.  The char specialization provides a number of
     678             :    *  optimizations as well.
     679             :   */
     680             :   template<>
     681             :     class ctype<char> : public locale::facet, public ctype_base
     682             :     {
     683             :     public:
     684             :       // Types:
     685             :       /// Typedef for the template parameter char.
     686             :       typedef char              char_type;
     687             : 
     688             :     protected:
     689             :       // Data Members:
     690             :       __c_locale                _M_c_locale_ctype;
     691             :       bool                      _M_del;
     692             :       __to_type                 _M_toupper;
     693             :       __to_type                 _M_tolower;
     694             :       const mask*               _M_table;
     695             :       mutable char              _M_widen_ok;
     696             :       mutable char              _M_widen[1 + static_cast<unsigned char>(-1)];
     697             :       mutable char              _M_narrow[1 + static_cast<unsigned char>(-1)];
     698             :       mutable char              _M_narrow_ok;   // 0 uninitialized, 1 init,
     699             :                                                 // 2 memcpy can't be used
     700             : 
     701             :     public:
     702             :       /// The facet id for ctype<char>
     703             :       static locale::id        id;
     704             :       /// The size of the mask table.  It is SCHAR_MAX + 1.
     705             :       static const size_t      table_size = 1 + static_cast<unsigned char>(-1);
     706             : 
     707             :       /**
     708             :        *  @brief  Constructor performs initialization.
     709             :        *
     710             :        *  This is the constructor provided by the standard.
     711             :        *
     712             :        *  @param __table If non-zero, table is used as the per-char mask.
     713             :        *               Else classic_table() is used.
     714             :        *  @param __del   If true, passes ownership of table to this facet.
     715             :        *  @param __refs  Passed to the base facet class.
     716             :       */
     717             :       explicit
     718             :       ctype(const mask* __table = 0, bool __del = false, size_t __refs = 0);
     719             : 
     720             :       /**
     721             :        *  @brief  Constructor performs static initialization.
     722             :        *
     723             :        *  This constructor is used to construct the initial C locale facet.
     724             :        *
     725             :        *  @param __cloc  Handle to C locale data.
     726             :        *  @param __table If non-zero, table is used as the per-char mask.
     727             :        *  @param __del   If true, passes ownership of table to this facet.
     728             :        *  @param __refs  Passed to the base facet class.
     729             :       */
     730             :       explicit
     731             :       ctype(__c_locale __cloc, const mask* __table = 0, bool __del = false,
     732             :             size_t __refs = 0);
     733             : 
     734             :       /**
     735             :        *  @brief  Test char classification.
     736             :        *
     737             :        *  This function compares the mask table[c] to @a __m.
     738             :        *
     739             :        *  @param __c  The char to compare the mask of.
     740             :        *  @param __m  The mask to compare against.
     741             :        *  @return  True if __m & table[__c] is true, false otherwise.
     742             :       */
     743             :       inline bool
     744             :       is(mask __m, char __c) const;
     745             : 
     746             :       /**
     747             :        *  @brief  Return a mask array.
     748             :        *
     749             :        *  This function finds the mask for each char in the range [lo, hi) and
     750             :        *  successively writes it to vec.  vec must have as many elements as
     751             :        *  the char array.
     752             :        *
     753             :        *  @param __lo  Pointer to start of range.
     754             :        *  @param __hi  Pointer to end of range.
     755             :        *  @param __vec  Pointer to an array of mask storage.
     756             :        *  @return  @a __hi.
     757             :       */
     758             :       inline const char*
     759             :       is(const char* __lo, const char* __hi, mask* __vec) const;
     760             : 
     761             :       /**
     762             :        *  @brief  Find char matching a mask
     763             :        *
     764             :        *  This function searches for and returns the first char in [lo,hi) for
     765             :        *  which is(m,char) is true.
     766             :        *
     767             :        *  @param __m  The mask to compare against.
     768             :        *  @param __lo  Pointer to start of range.
     769             :        *  @param __hi  Pointer to end of range.
     770             :        *  @return  Pointer to a matching char if found, else @a __hi.
     771             :       */
     772             :       inline const char*
     773             :       scan_is(mask __m, const char* __lo, const char* __hi) const;
     774             : 
     775             :       /**
     776             :        *  @brief  Find char not matching a mask
     777             :        *
     778             :        *  This function searches for and returns a pointer to the first char
     779             :        *  in [__lo,__hi) for which is(m,char) is false.
     780             :        *
     781             :        *  @param __m  The mask to compare against.
     782             :        *  @param __lo  Pointer to start of range.
     783             :        *  @param __hi  Pointer to end of range.
     784             :        *  @return  Pointer to a non-matching char if found, else @a __hi.
     785             :       */
     786             :       inline const char*
     787             :       scan_not(mask __m, const char* __lo, const char* __hi) const;
     788             : 
     789             :       /**
     790             :        *  @brief  Convert to uppercase.
     791             :        *
     792             :        *  This function converts the char argument to uppercase if possible.
     793             :        *  If not possible (for example, '2'), returns the argument.
     794             :        *
     795             :        *  toupper() acts as if it returns ctype<char>::do_toupper(c).
     796             :        *  do_toupper() must always return the same result for the same input.
     797             :        *
     798             :        *  @param __c  The char to convert.
     799             :        *  @return  The uppercase char if convertible, else @a __c.
     800             :       */
     801             :       char_type
     802           0 :       toupper(char_type __c) const
     803           0 :       { return this->do_toupper(__c); }
     804             : 
     805             :       /**
     806             :        *  @brief  Convert array to uppercase.
     807             :        *
     808             :        *  This function converts each char in the range [__lo,__hi) to uppercase
     809             :        *  if possible.  Other chars remain untouched.
     810             :        *
     811             :        *  toupper() acts as if it returns ctype<char>:: do_toupper(__lo, __hi).
     812             :        *  do_toupper() must always return the same result for the same input.
     813             :        *
     814             :        *  @param __lo  Pointer to first char in range.
     815             :        *  @param __hi  Pointer to end of range.
     816             :        *  @return  @a __hi.
     817             :       */
     818             :       const char_type*
     819             :       toupper(char_type *__lo, const char_type* __hi) const
     820             :       { return this->do_toupper(__lo, __hi); }
     821             : 
     822             :       /**
     823             :        *  @brief  Convert to lowercase.
     824             :        *
     825             :        *  This function converts the char argument to lowercase if possible.
     826             :        *  If not possible (for example, '2'), returns the argument.
     827             :        *
     828             :        *  tolower() acts as if it returns ctype<char>::do_tolower(__c).
     829             :        *  do_tolower() must always return the same result for the same input.
     830             :        *
     831             :        *  @param __c  The char to convert.
     832             :        *  @return  The lowercase char if convertible, else @a __c.
     833             :       */
     834             :       char_type
     835       14240 :       tolower(char_type __c) const
     836           0 :       { return this->do_tolower(__c); }
     837             : 
     838             :       /**
     839             :        *  @brief  Convert array to lowercase.
     840             :        *
     841             :        *  This function converts each char in the range [lo,hi) to lowercase
     842             :        *  if possible.  Other chars remain untouched.
     843             :        *
     844             :        *  tolower() acts as if it returns ctype<char>:: do_tolower(__lo, __hi).
     845             :        *  do_tolower() must always return the same result for the same input.
     846             :        *
     847             :        *  @param __lo  Pointer to first char in range.
     848             :        *  @param __hi  Pointer to end of range.
     849             :        *  @return  @a __hi.
     850             :       */
     851             :       const char_type*
     852     1212850 :       tolower(char_type* __lo, const char_type* __hi) const
     853     1212850 :       { return this->do_tolower(__lo, __hi); }
     854             : 
     855             :       /**
     856             :        *  @brief  Widen char
     857             :        *
     858             :        *  This function converts the char to char_type using the simplest
     859             :        *  reasonable transformation.  For an underived ctype<char> facet, the
     860             :        *  argument will be returned unchanged.
     861             :        *
     862             :        *  This function works as if it returns ctype<char>::do_widen(c).
     863             :        *  do_widen() must always return the same result for the same input.
     864             :        *
     865             :        *  Note: this is not what you want for codepage conversions.  See
     866             :        *  codecvt for that.
     867             :        *
     868             :        *  @param __c  The char to convert.
     869             :        *  @return  The converted character.
     870             :       */
     871             :       char_type
     872     1973552 :       widen(char __c) const
     873             :       {
     874     1973552 :         if (_M_widen_ok)
     875     1973552 :           return _M_widen[static_cast<unsigned char>(__c)];
     876           0 :         this->_M_widen_init();
     877           0 :         return this->do_widen(__c);
     878             :       }
     879             : 
     880             :       /**
     881             :        *  @brief  Widen char array
     882             :        *
     883             :        *  This function converts each char in the input to char using the
     884             :        *  simplest reasonable transformation.  For an underived ctype<char>
     885             :        *  facet, the argument will be copied unchanged.
     886             :        *
     887             :        *  This function works as if it returns ctype<char>::do_widen(c).
     888             :        *  do_widen() must always return the same result for the same input.
     889             :        *
     890             :        *  Note: this is not what you want for codepage conversions.  See
     891             :        *  codecvt for that.
     892             :        *
     893             :        *  @param __lo  Pointer to first char in range.
     894             :        *  @param __hi  Pointer to end of range.
     895             :        *  @param __to  Pointer to the destination array.
     896             :        *  @return  @a __hi.
     897             :       */
     898             :       const char*
     899             :       widen(const char* __lo, const char* __hi, char_type* __to) const
     900             :       {
     901             :         if (_M_widen_ok == 1)
     902             :           {
     903             :             if (__builtin_expect(__hi != __lo, true))
     904             :               __builtin_memcpy(__to, __lo, __hi - __lo);
     905             :             return __hi;
     906             :           }
     907             :         if (!_M_widen_ok)
     908             :           _M_widen_init();
     909             :         return this->do_widen(__lo, __hi, __to);
     910             :       }
     911             : 
     912             :       /**
     913             :        *  @brief  Narrow char
     914             :        *
     915             :        *  This function converts the char to char using the simplest
     916             :        *  reasonable transformation.  If the conversion fails, dfault is
     917             :        *  returned instead.  For an underived ctype<char> facet, @a c
     918             :        *  will be returned unchanged.
     919             :        *
     920             :        *  This function works as if it returns ctype<char>::do_narrow(c).
     921             :        *  do_narrow() must always return the same result for the same input.
     922             :        *
     923             :        *  Note: this is not what you want for codepage conversions.  See
     924             :        *  codecvt for that.
     925             :        *
     926             :        *  @param __c  The char to convert.
     927             :        *  @param __dfault  Char to return if conversion fails.
     928             :        *  @return  The converted character.
     929             :       */
     930             :       char
     931        4775 :       narrow(char_type __c, char __dfault) const
     932             :       {
     933        4775 :         if (_M_narrow[static_cast<unsigned char>(__c)])
     934             :           return _M_narrow[static_cast<unsigned char>(__c)];
     935         270 :         const char __t = do_narrow(__c, __dfault);
     936         270 :         if (__t != __dfault)
     937         270 :           _M_narrow[static_cast<unsigned char>(__c)] = __t;
     938             :         return __t;
     939             :       }
     940             : 
     941             :       /**
     942             :        *  @brief  Narrow char array
     943             :        *
     944             :        *  This function converts each char in the input to char using the
     945             :        *  simplest reasonable transformation and writes the results to the
     946             :        *  destination array.  For any char in the input that cannot be
     947             :        *  converted, @a dfault is used instead.  For an underived ctype<char>
     948             :        *  facet, the argument will be copied unchanged.
     949             :        *
     950             :        *  This function works as if it returns ctype<char>::do_narrow(lo, hi,
     951             :        *  dfault, to).  do_narrow() must always return the same result for the
     952             :        *  same input.
     953             :        *
     954             :        *  Note: this is not what you want for codepage conversions.  See
     955             :        *  codecvt for that.
     956             :        *
     957             :        *  @param __lo  Pointer to start of range.
     958             :        *  @param __hi  Pointer to end of range.
     959             :        *  @param __dfault  Char to use if conversion fails.
     960             :        *  @param __to  Pointer to the destination array.
     961             :        *  @return  @a __hi.
     962             :       */
     963             :       const char_type*
     964             :       narrow(const char_type* __lo, const char_type* __hi,
     965             :              char __dfault, char* __to) const
     966             :       {
     967             :         if (__builtin_expect(_M_narrow_ok == 1, true))
     968             :           {
     969             :             if (__builtin_expect(__hi != __lo, true))
     970             :               __builtin_memcpy(__to, __lo, __hi - __lo);
     971             :             return __hi;
     972             :           }
     973             :         if (!_M_narrow_ok)
     974             :           _M_narrow_init();
     975             :         return this->do_narrow(__lo, __hi, __dfault, __to);
     976             :       }
     977             : 
     978             :       // _GLIBCXX_RESOLVE_LIB_DEFECTS
     979             :       // DR 695. ctype<char>::classic_table() not accessible.
     980             :       /// Returns a pointer to the mask table provided to the constructor, or
     981             :       /// the default from classic_table() if none was provided.
     982             :       const mask*
     983             :       table() const throw()
     984             :       { return _M_table; }
     985             : 
     986             :       /// Returns a pointer to the C locale mask table.
     987             :       static const mask*
     988             :       classic_table() throw();
     989             :     protected:
     990             : 
     991             :       /**
     992             :        *  @brief  Destructor.
     993             :        *
     994             :        *  This function deletes table() if @a del was true in the
     995             :        *  constructor.
     996             :       */
     997             :       virtual
     998             :       ~ctype();
     999             : 
    1000             :       /**
    1001             :        *  @brief  Convert to uppercase.
    1002             :        *
    1003             :        *  This virtual function converts the char argument to uppercase if
    1004             :        *  possible.  If not possible (for example, '2'), returns the argument.
    1005             :        *
    1006             :        *  do_toupper() is a hook for a derived facet to change the behavior of
    1007             :        *  uppercasing.  do_toupper() must always return the same result for
    1008             :        *  the same input.
    1009             :        *
    1010             :        *  @param __c  The char to convert.
    1011             :        *  @return  The uppercase char if convertible, else @a __c.
    1012             :       */
    1013             :       virtual char_type
    1014             :       do_toupper(char_type __c) const;
    1015             : 
    1016             :       /**
    1017             :        *  @brief  Convert array to uppercase.
    1018             :        *
    1019             :        *  This virtual function converts each char in the range [lo,hi) to
    1020             :        *  uppercase if possible.  Other chars remain untouched.
    1021             :        *
    1022             :        *  do_toupper() is a hook for a derived facet to change the behavior of
    1023             :        *  uppercasing.  do_toupper() must always return the same result for
    1024             :        *  the same input.
    1025             :        *
    1026             :        *  @param __lo  Pointer to start of range.
    1027             :        *  @param __hi  Pointer to end of range.
    1028             :        *  @return  @a __hi.
    1029             :       */
    1030             :       virtual const char_type*
    1031             :       do_toupper(char_type* __lo, const char_type* __hi) const;
    1032             : 
    1033             :       /**
    1034             :        *  @brief  Convert to lowercase.
    1035             :        *
    1036             :        *  This virtual function converts the char argument to lowercase if
    1037             :        *  possible.  If not possible (for example, '2'), returns the argument.
    1038             :        *
    1039             :        *  do_tolower() is a hook for a derived facet to change the behavior of
    1040             :        *  lowercasing.  do_tolower() must always return the same result for
    1041             :        *  the same input.
    1042             :        *
    1043             :        *  @param __c  The char to convert.
    1044             :        *  @return  The lowercase char if convertible, else @a __c.
    1045             :       */
    1046             :       virtual char_type
    1047             :       do_tolower(char_type __c) const;
    1048             : 
    1049             :       /**
    1050             :        *  @brief  Convert array to lowercase.
    1051             :        *
    1052             :        *  This virtual function converts each char in the range [lo,hi) to
    1053             :        *  lowercase if possible.  Other chars remain untouched.
    1054             :        *
    1055             :        *  do_tolower() is a hook for a derived facet to change the behavior of
    1056             :        *  lowercasing.  do_tolower() must always return the same result for
    1057             :        *  the same input.
    1058             :        *
    1059             :        *  @param __lo  Pointer to first char in range.
    1060             :        *  @param __hi  Pointer to end of range.
    1061             :        *  @return  @a __hi.
    1062             :       */
    1063             :       virtual const char_type*
    1064             :       do_tolower(char_type* __lo, const char_type* __hi) const;
    1065             : 
    1066             :       /**
    1067             :        *  @brief  Widen char
    1068             :        *
    1069             :        *  This virtual function converts the char to char using the simplest
    1070             :        *  reasonable transformation.  For an underived ctype<char> facet, the
    1071             :        *  argument will be returned unchanged.
    1072             :        *
    1073             :        *  do_widen() is a hook for a derived facet to change the behavior of
    1074             :        *  widening.  do_widen() must always return the same result for the
    1075             :        *  same input.
    1076             :        *
    1077             :        *  Note: this is not what you want for codepage conversions.  See
    1078             :        *  codecvt for that.
    1079             :        *
    1080             :        *  @param __c  The char to convert.
    1081             :        *  @return  The converted character.
    1082             :       */
    1083             :       virtual char_type
    1084           0 :       do_widen(char __c) const
    1085           0 :       { return __c; }
    1086             : 
    1087             :       /**
    1088             :        *  @brief  Widen char array
    1089             :        *
    1090             :        *  This function converts each char in the range [lo,hi) to char using
    1091             :        *  the simplest reasonable transformation.  For an underived
    1092             :        *  ctype<char> facet, the argument will be copied unchanged.
    1093             :        *
    1094             :        *  do_widen() is a hook for a derived facet to change the behavior of
    1095             :        *  widening.  do_widen() must always return the same result for the
    1096             :        *  same input.
    1097             :        *
    1098             :        *  Note: this is not what you want for codepage conversions.  See
    1099             :        *  codecvt for that.
    1100             :        *
    1101             :        *  @param __lo  Pointer to start of range.
    1102             :        *  @param __hi  Pointer to end of range.
    1103             :        *  @param __to  Pointer to the destination array.
    1104             :        *  @return  @a __hi.
    1105             :       */
    1106             :       virtual const char*
    1107             :       do_widen(const char* __lo, const char* __hi, char_type* __to) const
    1108             :       {
    1109             :         if (__builtin_expect(__hi != __lo, true))
    1110             :           __builtin_memcpy(__to, __lo, __hi - __lo);
    1111             :         return __hi;
    1112             :       }
    1113             : 
    1114             :       /**
    1115             :        *  @brief  Narrow char
    1116             :        *
    1117             :        *  This virtual function converts the char to char using the simplest
    1118             :        *  reasonable transformation.  If the conversion fails, dfault is
    1119             :        *  returned instead.  For an underived ctype<char> facet, @a c will be
    1120             :        *  returned unchanged.
    1121             :        *
    1122             :        *  do_narrow() is a hook for a derived facet to change the behavior of
    1123             :        *  narrowing.  do_narrow() must always return the same result for the
    1124             :        *  same input.
    1125             :        *
    1126             :        *  Note: this is not what you want for codepage conversions.  See
    1127             :        *  codecvt for that.
    1128             :        *
    1129             :        *  @param __c  The char to convert.
    1130             :        *  @param __dfault  Char to return if conversion fails.
    1131             :        *  @return  The converted char.
    1132             :       */
    1133             :       virtual char
    1134         270 :       do_narrow(char_type __c, char __dfault __attribute__((__unused__))) const
    1135         270 :       { return __c; }
    1136             : 
    1137             :       /**
    1138             :        *  @brief  Narrow char array to char array
    1139             :        *
    1140             :        *  This virtual function converts each char in the range [lo,hi) to
    1141             :        *  char using the simplest reasonable transformation and writes the
    1142             :        *  results to the destination array.  For any char in the input that
    1143             :        *  cannot be converted, @a dfault is used instead.  For an underived
    1144             :        *  ctype<char> facet, the argument will be copied unchanged.
    1145             :        *
    1146             :        *  do_narrow() is a hook for a derived facet to change the behavior of
    1147             :        *  narrowing.  do_narrow() must always return the same result for the
    1148             :        *  same input.
    1149             :        *
    1150             :        *  Note: this is not what you want for codepage conversions.  See
    1151             :        *  codecvt for that.
    1152             :        *
    1153             :        *  @param __lo  Pointer to start of range.
    1154             :        *  @param __hi  Pointer to end of range.
    1155             :        *  @param __dfault  Char to use if conversion fails.
    1156             :        *  @param __to  Pointer to the destination array.
    1157             :        *  @return  @a __hi.
    1158             :       */
    1159             :       virtual const char_type*
    1160             :       do_narrow(const char_type* __lo, const char_type* __hi,
    1161             :                 char __dfault __attribute__((__unused__)), char* __to) const
    1162             :       {
    1163             :         if (__builtin_expect(__hi != __lo, true))
    1164             :           __builtin_memcpy(__to, __lo, __hi - __lo);
    1165             :         return __hi;
    1166             :       }
    1167             : 
    1168             :     private:
    1169             :       void _M_narrow_init() const;
    1170             :       void _M_widen_init() const;
    1171             :     };
    1172             : 
    1173             : #ifdef _GLIBCXX_USE_WCHAR_T
    1174             :   /**
    1175             :    *  @brief  The ctype<wchar_t> specialization.
    1176             :    *  @ingroup locales
    1177             :    *
    1178             :    *  This class defines classification and conversion functions for the
    1179             :    *  wchar_t type.  It gets used by wchar_t streams for many I/O operations.
    1180             :    *  The wchar_t specialization provides a number of optimizations as well.
    1181             :    *
    1182             :    *  ctype<wchar_t> inherits its public methods from
    1183             :    *  __ctype_abstract_base<wchar_t>.
    1184             :   */
    1185             :   template<>
    1186             :     class ctype<wchar_t> : public __ctype_abstract_base<wchar_t>
    1187             :     {
    1188             :     public:
    1189             :       // Types:
    1190             :       /// Typedef for the template parameter wchar_t.
    1191             :       typedef wchar_t           char_type;
    1192             :       typedef wctype_t          __wmask_type;
    1193             : 
    1194             :     protected:
    1195             :       __c_locale                _M_c_locale_ctype;
    1196             : 
    1197             :       // Pre-computed narrowed and widened chars.
    1198             :       bool                      _M_narrow_ok;
    1199             :       char                      _M_narrow[128];
    1200             :       wint_t                    _M_widen[1 + static_cast<unsigned char>(-1)];
    1201             : 
    1202             :       // Pre-computed elements for do_is.
    1203             :       mask                      _M_bit[16];
    1204             :       __wmask_type              _M_wmask[16];
    1205             : 
    1206             :     public:
    1207             :       // Data Members:
    1208             :       /// The facet id for ctype<wchar_t>
    1209             :       static locale::id         id;
    1210             : 
    1211             :       /**
    1212             :        *  @brief  Constructor performs initialization.
    1213             :        *
    1214             :        *  This is the constructor provided by the standard.
    1215             :        *
    1216             :        *  @param __refs  Passed to the base facet class.
    1217             :       */
    1218             :       explicit
    1219             :       ctype(size_t __refs = 0);
    1220             : 
    1221             :       /**
    1222             :        *  @brief  Constructor performs static initialization.
    1223             :        *
    1224             :        *  This constructor is used to construct the initial C locale facet.
    1225             :        *
    1226             :        *  @param __cloc  Handle to C locale data.
    1227             :        *  @param __refs  Passed to the base facet class.
    1228             :       */
    1229             :       explicit
    1230             :       ctype(__c_locale __cloc, size_t __refs = 0);
    1231             : 
    1232             :     protected:
    1233             :       __wmask_type
    1234             :       _M_convert_to_wmask(const mask __m) const throw();
    1235             : 
    1236             :       /// Destructor
    1237             :       virtual
    1238             :       ~ctype();
    1239             : 
    1240             :       /**
    1241             :        *  @brief  Test wchar_t classification.
    1242             :        *
    1243             :        *  This function finds a mask M for @a c and compares it to mask @a m.
    1244             :        *
    1245             :        *  do_is() is a hook for a derived facet to change the behavior of
    1246             :        *  classifying.  do_is() must always return the same result for the
    1247             :        *  same input.
    1248             :        *
    1249             :        *  @param __c  The wchar_t to find the mask of.
    1250             :        *  @param __m  The mask to compare against.
    1251             :        *  @return  (M & __m) != 0.
    1252             :       */
    1253             :       virtual bool
    1254             :       do_is(mask __m, char_type __c) const;
    1255             : 
    1256             :       /**
    1257             :        *  @brief  Return a mask array.
    1258             :        *
    1259             :        *  This function finds the mask for each wchar_t in the range [lo,hi)
    1260             :        *  and successively writes it to vec.  vec must have as many elements
    1261             :        *  as the input.
    1262             :        *
    1263             :        *  do_is() is a hook for a derived facet to change the behavior of
    1264             :        *  classifying.  do_is() must always return the same result for the
    1265             :        *  same input.
    1266             :        *
    1267             :        *  @param __lo  Pointer to start of range.
    1268             :        *  @param __hi  Pointer to end of range.
    1269             :        *  @param __vec  Pointer to an array of mask storage.
    1270             :        *  @return  @a __hi.
    1271             :       */
    1272             :       virtual const char_type*
    1273             :       do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const;
    1274             : 
    1275             :       /**
    1276             :        *  @brief  Find wchar_t matching mask
    1277             :        *
    1278             :        *  This function searches for and returns the first wchar_t c in
    1279             :        *  [__lo,__hi) for which is(__m,c) is true.
    1280             :        *
    1281             :        *  do_scan_is() is a hook for a derived facet to change the behavior of
    1282             :        *  match searching.  do_is() must always return the same result for the
    1283             :        *  same input.
    1284             :        *
    1285             :        *  @param __m  The mask to compare against.
    1286             :        *  @param __lo  Pointer to start of range.
    1287             :        *  @param __hi  Pointer to end of range.
    1288             :        *  @return  Pointer to a matching wchar_t if found, else @a __hi.
    1289             :       */
    1290             :       virtual const char_type*
    1291             :       do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const;
    1292             : 
    1293             :       /**
    1294             :        *  @brief  Find wchar_t not matching mask
    1295             :        *
    1296             :        *  This function searches for and returns a pointer to the first
    1297             :        *  wchar_t c of [__lo,__hi) for which is(__m,c) is false.
    1298             :        *
    1299             :        *  do_scan_is() is a hook for a derived facet to change the behavior of
    1300             :        *  match searching.  do_is() must always return the same result for the
    1301             :        *  same input.
    1302             :        *
    1303             :        *  @param __m  The mask to compare against.
    1304             :        *  @param __lo  Pointer to start of range.
    1305             :        *  @param __hi  Pointer to end of range.
    1306             :        *  @return  Pointer to a non-matching wchar_t if found, else @a __hi.
    1307             :       */
    1308             :       virtual const char_type*
    1309             :       do_scan_not(mask __m, const char_type* __lo,
    1310             :                   const char_type* __hi) const;
    1311             : 
    1312             :       /**
    1313             :        *  @brief  Convert to uppercase.
    1314             :        *
    1315             :        *  This virtual function converts the wchar_t argument to uppercase if
    1316             :        *  possible.  If not possible (for example, '2'), returns the argument.
    1317             :        *
    1318             :        *  do_toupper() is a hook for a derived facet to change the behavior of
    1319             :        *  uppercasing.  do_toupper() must always return the same result for
    1320             :        *  the same input.
    1321             :        *
    1322             :        *  @param __c  The wchar_t to convert.
    1323             :        *  @return  The uppercase wchar_t if convertible, else @a __c.
    1324             :       */
    1325             :       virtual char_type
    1326             :       do_toupper(char_type __c) const;
    1327             : 
    1328             :       /**
    1329             :        *  @brief  Convert array to uppercase.
    1330             :        *
    1331             :        *  This virtual function converts each wchar_t in the range [lo,hi) to
    1332             :        *  uppercase if possible.  Other elements remain untouched.
    1333             :        *
    1334             :        *  do_toupper() is a hook for a derived facet to change the behavior of
    1335             :        *  uppercasing.  do_toupper() must always return the same result for
    1336             :        *  the same input.
    1337             :        *
    1338             :        *  @param __lo  Pointer to start of range.
    1339             :        *  @param __hi  Pointer to end of range.
    1340             :        *  @return  @a __hi.
    1341             :       */
    1342             :       virtual const char_type*
    1343             :       do_toupper(char_type* __lo, const char_type* __hi) const;
    1344             : 
    1345             :       /**
    1346             :        *  @brief  Convert to lowercase.
    1347             :        *
    1348             :        *  This virtual function converts the argument to lowercase if
    1349             :        *  possible.  If not possible (for example, '2'), returns the argument.
    1350             :        *
    1351             :        *  do_tolower() is a hook for a derived facet to change the behavior of
    1352             :        *  lowercasing.  do_tolower() must always return the same result for
    1353             :        *  the same input.
    1354             :        *
    1355             :        *  @param __c  The wchar_t to convert.
    1356             :        *  @return  The lowercase wchar_t if convertible, else @a __c.
    1357             :       */
    1358             :       virtual char_type
    1359             :       do_tolower(char_type __c) const;
    1360             : 
    1361             :       /**
    1362             :        *  @brief  Convert array to lowercase.
    1363             :        *
    1364             :        *  This virtual function converts each wchar_t in the range [lo,hi) to
    1365             :        *  lowercase if possible.  Other elements remain untouched.
    1366             :        *
    1367             :        *  do_tolower() is a hook for a derived facet to change the behavior of
    1368             :        *  lowercasing.  do_tolower() must always return the same result for
    1369             :        *  the same input.
    1370             :        *
    1371             :        *  @param __lo  Pointer to start of range.
    1372             :        *  @param __hi  Pointer to end of range.
    1373             :        *  @return  @a __hi.
    1374             :       */
    1375             :       virtual const char_type*
    1376             :       do_tolower(char_type* __lo, const char_type* __hi) const;
    1377             : 
    1378             :       /**
    1379             :        *  @brief  Widen char to wchar_t
    1380             :        *
    1381             :        *  This virtual function converts the char to wchar_t using the
    1382             :        *  simplest reasonable transformation.  For an underived ctype<wchar_t>
    1383             :        *  facet, the argument will be cast to wchar_t.
    1384             :        *
    1385             :        *  do_widen() is a hook for a derived facet to change the behavior of
    1386             :        *  widening.  do_widen() must always return the same result for the
    1387             :        *  same input.
    1388             :        *
    1389             :        *  Note: this is not what you want for codepage conversions.  See
    1390             :        *  codecvt for that.
    1391             :        *
    1392             :        *  @param __c  The char to convert.
    1393             :        *  @return  The converted wchar_t.
    1394             :       */
    1395             :       virtual char_type
    1396             :       do_widen(char __c) const;
    1397             : 
    1398             :       /**
    1399             :        *  @brief  Widen char array to wchar_t array
    1400             :        *
    1401             :        *  This function converts each char in the input to wchar_t using the
    1402             :        *  simplest reasonable transformation.  For an underived ctype<wchar_t>
    1403             :        *  facet, the argument will be copied, casting each element to wchar_t.
    1404             :        *
    1405             :        *  do_widen() is a hook for a derived facet to change the behavior of
    1406             :        *  widening.  do_widen() must always return the same result for the
    1407             :        *  same input.
    1408             :        *
    1409             :        *  Note: this is not what you want for codepage conversions.  See
    1410             :        *  codecvt for that.
    1411             :        *
    1412             :        *  @param __lo  Pointer to start range.
    1413             :        *  @param __hi  Pointer to end of range.
    1414             :        *  @param __to  Pointer to the destination array.
    1415             :        *  @return  @a __hi.
    1416             :       */
    1417             :       virtual const char*
    1418             :       do_widen(const char* __lo, const char* __hi, char_type* __to) const;
    1419             : 
    1420             :       /**
    1421             :        *  @brief  Narrow wchar_t to char
    1422             :        *
    1423             :        *  This virtual function converts the argument to char using
    1424             :        *  the simplest reasonable transformation.  If the conversion
    1425             :        *  fails, dfault is returned instead.  For an underived
    1426             :        *  ctype<wchar_t> facet, @a c will be cast to char and
    1427             :        *  returned.
    1428             :        *
    1429             :        *  do_narrow() is a hook for a derived facet to change the
    1430             :        *  behavior of narrowing.  do_narrow() must always return the
    1431             :        *  same result for the same input.
    1432             :        *
    1433             :        *  Note: this is not what you want for codepage conversions.  See
    1434             :        *  codecvt for that.
    1435             :        *
    1436             :        *  @param __c  The wchar_t to convert.
    1437             :        *  @param __dfault  Char to return if conversion fails.
    1438             :        *  @return  The converted char.
    1439             :       */
    1440             :       virtual char
    1441             :       do_narrow(char_type __c, char __dfault) const;
    1442             : 
    1443             :       /**
    1444             :        *  @brief  Narrow wchar_t array to char array
    1445             :        *
    1446             :        *  This virtual function converts each wchar_t in the range [lo,hi) to
    1447             :        *  char using the simplest reasonable transformation and writes the
    1448             :        *  results to the destination array.  For any wchar_t in the input that
    1449             :        *  cannot be converted, @a dfault is used instead.  For an underived
    1450             :        *  ctype<wchar_t> facet, the argument will be copied, casting each
    1451             :        *  element to char.
    1452             :        *
    1453             :        *  do_narrow() is a hook for a derived facet to change the behavior of
    1454             :        *  narrowing.  do_narrow() must always return the same result for the
    1455             :        *  same input.
    1456             :        *
    1457             :        *  Note: this is not what you want for codepage conversions.  See
    1458             :        *  codecvt for that.
    1459             :        *
    1460             :        *  @param __lo  Pointer to start of range.
    1461             :        *  @param __hi  Pointer to end of range.
    1462             :        *  @param __dfault  Char to use if conversion fails.
    1463             :        *  @param __to  Pointer to the destination array.
    1464             :        *  @return  @a __hi.
    1465             :       */
    1466             :       virtual const char_type*
    1467             :       do_narrow(const char_type* __lo, const char_type* __hi,
    1468             :                 char __dfault, char* __to) const;
    1469             : 
    1470             :       // For use at construction time only.
    1471             :       void
    1472             :       _M_initialize_ctype() throw();
    1473             :     };
    1474             : #endif //_GLIBCXX_USE_WCHAR_T
    1475             : 
    1476             :   /// class ctype_byname [22.2.1.2].
    1477             :   template<typename _CharT>
    1478             :     class ctype_byname : public ctype<_CharT>
    1479             :     {
    1480             :     public:
    1481             :       typedef typename ctype<_CharT>::mask  mask;
    1482             : 
    1483             :       explicit
    1484             :       ctype_byname(const char* __s, size_t __refs = 0);
    1485             : 
    1486             : #if __cplusplus >= 201103L
    1487             :       explicit
    1488             :       ctype_byname(const string& __s, size_t __refs = 0)
    1489             :       : ctype_byname(__s.c_str(), __refs) { }
    1490             : #endif
    1491             : 
    1492             :     protected:
    1493             :       virtual
    1494             :       ~ctype_byname() { }
    1495             :     };
    1496             : 
    1497             :   /// 22.2.1.4  Class ctype_byname specializations.
    1498             :   template<>
    1499             :     class ctype_byname<char> : public ctype<char>
    1500             :     {
    1501             :     public:
    1502             :       explicit
    1503             :       ctype_byname(const char* __s, size_t __refs = 0);
    1504             : 
    1505             : #if __cplusplus >= 201103L
    1506             :       explicit
    1507             :       ctype_byname(const string& __s, size_t __refs = 0);
    1508             : #endif
    1509             : 
    1510             :     protected:
    1511             :       virtual
    1512             :       ~ctype_byname();
    1513             :     };
    1514             : 
    1515             : #ifdef _GLIBCXX_USE_WCHAR_T
    1516             :   template<>
    1517             :     class ctype_byname<wchar_t> : public ctype<wchar_t>
    1518             :     {
    1519             :     public:
    1520             :       explicit
    1521             :       ctype_byname(const char* __s, size_t __refs = 0);
    1522             : 
    1523             : #if __cplusplus >= 201103L
    1524             :       explicit
    1525             :       ctype_byname(const string& __s, size_t __refs = 0);
    1526             : #endif
    1527             : 
    1528             :     protected:
    1529             :       virtual
    1530             :       ~ctype_byname();
    1531             :     };
    1532             : #endif
    1533             : 
    1534             : _GLIBCXX_END_NAMESPACE_VERSION
    1535             : } // namespace
    1536             : 
    1537             : // Include host and configuration specific ctype inlines.
    1538             : #include <bits/ctype_inline.h>
    1539             : 
    1540             : namespace std _GLIBCXX_VISIBILITY(default)
    1541             : {
    1542             : _GLIBCXX_BEGIN_NAMESPACE_VERSION
    1543             : 
    1544             :   // 22.2.2  The numeric category.
    1545             :   class __num_base
    1546             :   {
    1547             :   public:
    1548             :     // NB: Code depends on the order of _S_atoms_out elements.
    1549             :     // Below are the indices into _S_atoms_out.
    1550             :     enum
    1551             :       {
    1552             :         _S_ominus,
    1553             :         _S_oplus,
    1554             :         _S_ox,
    1555             :         _S_oX,
    1556             :         _S_odigits,
    1557             :         _S_odigits_end = _S_odigits + 16,
    1558             :         _S_oudigits = _S_odigits_end,
    1559             :         _S_oudigits_end = _S_oudigits + 16,
    1560             :         _S_oe = _S_odigits + 14,  // For scientific notation, 'e'
    1561             :         _S_oE = _S_oudigits + 14, // For scientific notation, 'E'
    1562             :         _S_oend = _S_oudigits_end
    1563             :       };
    1564             : 
    1565             :     // A list of valid numeric literals for output.  This array
    1566             :     // contains chars that will be passed through the current locale's
    1567             :     // ctype<_CharT>.widen() and then used to render numbers.
    1568             :     // For the standard "C" locale, this is
    1569             :     // "-+xX0123456789abcdef0123456789ABCDEF".
    1570             :     static const char* _S_atoms_out;
    1571             : 
    1572             :     // String literal of acceptable (narrow) input, for num_get.
    1573             :     // "-+xX0123456789abcdefABCDEF"
    1574             :     static const char* _S_atoms_in;
    1575             : 
    1576             :     enum
    1577             :     {
    1578             :       _S_iminus,
    1579             :       _S_iplus,
    1580             :       _S_ix,
    1581             :       _S_iX,
    1582             :       _S_izero,
    1583             :       _S_ie = _S_izero + 14,
    1584             :       _S_iE = _S_izero + 20,
    1585             :       _S_iend = 26
    1586             :     };
    1587             : 
    1588             :     // num_put
    1589             :     // Construct and return valid scanf format for floating point types.
    1590             :     static void
    1591             :     _S_format_float(const ios_base& __io, char* __fptr, char __mod) throw();
    1592             :   };
    1593             : 
    1594             :   template<typename _CharT>
    1595             :     struct __numpunct_cache : public locale::facet
    1596             :     {
    1597             :       const char*                       _M_grouping;
    1598             :       size_t                            _M_grouping_size;
    1599             :       bool                              _M_use_grouping;
    1600             :       const _CharT*                     _M_truename;
    1601             :       size_t                            _M_truename_size;
    1602             :       const _CharT*                     _M_falsename;
    1603             :       size_t                            _M_falsename_size;
    1604             :       _CharT                            _M_decimal_point;
    1605             :       _CharT                            _M_thousands_sep;
    1606             : 
    1607             :       // A list of valid numeric literals for output: in the standard
    1608             :       // "C" locale, this is "-+xX0123456789abcdef0123456789ABCDEF".
    1609             :       // This array contains the chars after having been passed
    1610             :       // through the current locale's ctype<_CharT>.widen().
    1611             :       _CharT                            _M_atoms_out[__num_base::_S_oend];
    1612             : 
    1613             :       // A list of valid numeric literals for input: in the standard
    1614             :       // "C" locale, this is "-+xX0123456789abcdefABCDEF"
    1615             :       // This array contains the chars after having been passed
    1616             :       // through the current locale's ctype<_CharT>.widen().
    1617             :       _CharT                            _M_atoms_in[__num_base::_S_iend];
    1618             : 
    1619             :       bool                              _M_allocated;
    1620             : 
    1621             :       __numpunct_cache(size_t __refs = 0)
    1622             :       : facet(__refs), _M_grouping(0), _M_grouping_size(0),
    1623             :         _M_use_grouping(false),
    1624             :         _M_truename(0), _M_truename_size(0), _M_falsename(0),
    1625             :         _M_falsename_size(0), _M_decimal_point(_CharT()),
    1626             :         _M_thousands_sep(_CharT()), _M_allocated(false)
    1627             :         { }
    1628             : 
    1629             :       ~__numpunct_cache();
    1630             : 
    1631             :       void
    1632             :       _M_cache(const locale& __loc);
    1633             : 
    1634             :     private:
    1635             :       __numpunct_cache&
    1636             :       operator=(const __numpunct_cache&);
    1637             : 
    1638             :       explicit
    1639             :       __numpunct_cache(const __numpunct_cache&);
    1640             :     };
    1641             : 
    1642             :   template<typename _CharT>
    1643             :     __numpunct_cache<_CharT>::~__numpunct_cache()
    1644             :     {
    1645             :       if (_M_allocated)
    1646             :         {
    1647             :           delete [] _M_grouping;
    1648             :           delete [] _M_truename;
    1649             :           delete [] _M_falsename;
    1650             :         }
    1651             :     }
    1652             : 
    1653             : _GLIBCXX_BEGIN_NAMESPACE_CXX11
    1654             : 
    1655             :   /**
    1656             :    *  @brief  Primary class template numpunct.
    1657             :    *  @ingroup locales
    1658             :    *
    1659             :    *  This facet stores several pieces of information related to printing and
    1660             :    *  scanning numbers, such as the decimal point character.  It takes a
    1661             :    *  template parameter specifying the char type.  The numpunct facet is
    1662             :    *  used by streams for many I/O operations involving numbers.
    1663             :    *
    1664             :    *  The numpunct template uses protected virtual functions to provide the
    1665             :    *  actual results.  The public accessors forward the call to the virtual
    1666             :    *  functions.  These virtual functions are hooks for developers to
    1667             :    *  implement the behavior they require from a numpunct facet.
    1668             :   */
    1669             :   template<typename _CharT>
    1670             :     class numpunct : public locale::facet
    1671             :     {
    1672             :     public:
    1673             :       // Types:
    1674             :       ///@{
    1675             :       /// Public typedefs
    1676             :       typedef _CharT                    char_type;
    1677             :       typedef basic_string<_CharT>        string_type;
    1678             :       ///@}
    1679             :       typedef __numpunct_cache<_CharT>  __cache_type;
    1680             : 
    1681             :     protected:
    1682             :       __cache_type*                     _M_data;
    1683             : 
    1684             :     public:
    1685             :       /// Numpunct facet id.
    1686             :       static locale::id                 id;
    1687             : 
    1688             :       /**
    1689             :        *  @brief  Numpunct constructor.
    1690             :        *
    1691             :        *  @param  __refs  Refcount to pass to the base class.
    1692             :        */
    1693             :       explicit
    1694             :       numpunct(size_t __refs = 0)
    1695             :       : facet(__refs), _M_data(0)
    1696             :       { _M_initialize_numpunct(); }
    1697             : 
    1698             :       /**
    1699             :        *  @brief  Internal constructor.  Not for general use.
    1700             :        *
    1701             :        *  This is a constructor for use by the library itself to set up the
    1702             :        *  predefined locale facets.
    1703             :        *
    1704             :        *  @param  __cache  __numpunct_cache object.
    1705             :        *  @param  __refs  Refcount to pass to the base class.
    1706             :        */
    1707             :       explicit
    1708             :       numpunct(__cache_type* __cache, size_t __refs = 0)
    1709             :       : facet(__refs), _M_data(__cache)
    1710             :       { _M_initialize_numpunct(); }
    1711             : 
    1712             :       /**
    1713             :        *  @brief  Internal constructor.  Not for general use.
    1714             :        *
    1715             :        *  This is a constructor for use by the library itself to set up new
    1716             :        *  locales.
    1717             :        *
    1718             :        *  @param  __cloc  The C locale.
    1719             :        *  @param  __refs  Refcount to pass to the base class.
    1720             :        */
    1721             :       explicit
    1722             :       numpunct(__c_locale __cloc, size_t __refs = 0)
    1723             :       : facet(__refs), _M_data(0)
    1724             :       { _M_initialize_numpunct(__cloc); }
    1725             : 
    1726             :       /**
    1727             :        *  @brief  Return decimal point character.
    1728             :        *
    1729             :        *  This function returns a char_type to use as a decimal point.  It
    1730             :        *  does so by returning returning
    1731             :        *  numpunct<char_type>::do_decimal_point().
    1732             :        *
    1733             :        *  @return  @a char_type representing a decimal point.
    1734             :       */
    1735             :       char_type
    1736           0 :       decimal_point() const
    1737           0 :       { return this->do_decimal_point(); }
    1738             : 
    1739             :       /**
    1740             :        *  @brief  Return thousands separator character.
    1741             :        *
    1742             :        *  This function returns a char_type to use as a thousands
    1743             :        *  separator.  It does so by returning returning
    1744             :        *  numpunct<char_type>::do_thousands_sep().
    1745             :        *
    1746             :        *  @return  char_type representing a thousands separator.
    1747             :       */
    1748             :       char_type
    1749           0 :       thousands_sep() const
    1750           0 :       { return this->do_thousands_sep(); }
    1751             : 
    1752             :       /**
    1753             :        *  @brief  Return grouping specification.
    1754             :        *
    1755             :        *  This function returns a string representing groupings for the
    1756             :        *  integer part of a number.  Groupings indicate where thousands
    1757             :        *  separators should be inserted in the integer part of a number.
    1758             :        *
    1759             :        *  Each char in the return string is interpret as an integer
    1760             :        *  rather than a character.  These numbers represent the number
    1761             :        *  of digits in a group.  The first char in the string
    1762             :        *  represents the number of digits in the least significant
    1763             :        *  group.  If a char is negative, it indicates an unlimited
    1764             :        *  number of digits for the group.  If more chars from the
    1765             :        *  string are required to group a number, the last char is used
    1766             :        *  repeatedly.
    1767             :        *
    1768             :        *  For example, if the grouping() returns "\003\002" and is
    1769             :        *  applied to the number 123456789, this corresponds to
    1770             :        *  12,34,56,789.  Note that if the string was "32", this would
    1771             :        *  put more than 50 digits into the least significant group if
    1772             :        *  the character set is ASCII.
    1773             :        *
    1774             :        *  The string is returned by calling
    1775             :        *  numpunct<char_type>::do_grouping().
    1776             :        *
    1777             :        *  @return  string representing grouping specification.
    1778             :       */
    1779             :       string
    1780           0 :       grouping() const
    1781           0 :       { return this->do_grouping(); }
    1782             : 
    1783             :       /**
    1784             :        *  @brief  Return string representation of bool true.
    1785             :        *
    1786             :        *  This function returns a string_type containing the text
    1787             :        *  representation for true bool variables.  It does so by calling
    1788             :        *  numpunct<char_type>::do_truename().
    1789             :        *
    1790             :        *  @return  string_type representing printed form of true.
    1791             :       */
    1792             :       string_type
    1793             :       truename() const
    1794             :       { return this->do_truename(); }
    1795             : 
    1796             :       /**
    1797             :        *  @brief  Return string representation of bool false.
    1798             :        *
    1799             :        *  This function returns a string_type containing the text
    1800             :        *  representation for false bool variables.  It does so by calling
    1801             :        *  numpunct<char_type>::do_falsename().
    1802             :        *
    1803             :        *  @return  string_type representing printed form of false.
    1804             :       */
    1805             :       string_type
    1806             :       falsename() const
    1807             :       { return this->do_falsename(); }
    1808             : 
    1809             :     protected:
    1810             :       /// Destructor.
    1811             :       virtual
    1812             :       ~numpunct();
    1813             : 
    1814             :       /**
    1815             :        *  @brief  Return decimal point character.
    1816             :        *
    1817             :        *  Returns a char_type to use as a decimal point.  This function is a
    1818             :        *  hook for derived classes to change the value returned.
    1819             :        *
    1820             :        *  @return  @a char_type representing a decimal point.
    1821             :       */
    1822             :       virtual char_type
    1823             :       do_decimal_point() const
    1824             :       { return _M_data->_M_decimal_point; }
    1825             : 
    1826             :       /**
    1827             :        *  @brief  Return thousands separator character.
    1828             :        *
    1829             :        *  Returns a char_type to use as a thousands separator.  This function
    1830             :        *  is a hook for derived classes to change the value returned.
    1831             :        *
    1832             :        *  @return  @a char_type representing a thousands separator.
    1833             :       */
    1834             :       virtual char_type
    1835             :       do_thousands_sep() const
    1836             :       { return _M_data->_M_thousands_sep; }
    1837             : 
    1838             :       /**
    1839             :        *  @brief  Return grouping specification.
    1840             :        *
    1841             :        *  Returns a string representing groupings for the integer part of a
    1842             :        *  number.  This function is a hook for derived classes to change the
    1843             :        *  value returned.  @see grouping() for details.
    1844             :        *
    1845             :        *  @return  String representing grouping specification.
    1846             :       */
    1847             :       virtual string
    1848             :       do_grouping() const
    1849             :       { return _M_data->_M_grouping; }
    1850             : 
    1851             :       /**
    1852             :        *  @brief  Return string representation of bool true.
    1853             :        *
    1854             :        *  Returns a string_type containing the text representation for true
    1855             :        *  bool variables.  This function is a hook for derived classes to
    1856             :        *  change the value returned.
    1857             :        *
    1858             :        *  @return  string_type representing printed form of true.
    1859             :       */
    1860             :       virtual string_type
    1861             :       do_truename() const
    1862             :       { return _M_data->_M_truename; }
    1863             : 
    1864             :       /**
    1865             :        *  @brief  Return string representation of bool false.
    1866             :        *
    1867             :        *  Returns a string_type containing the text representation for false
    1868             :        *  bool variables.  This function is a hook for derived classes to
    1869             :        *  change the value returned.
    1870             :        *
    1871             :        *  @return  string_type representing printed form of false.
    1872             :       */
    1873             :       virtual string_type
    1874             :       do_falsename() const
    1875             :       { return _M_data->_M_falsename; }
    1876             : 
    1877             :       // For use at construction time only.
    1878             :       void
    1879             :       _M_initialize_numpunct(__c_locale __cloc = 0);
    1880             :     };
    1881             : 
    1882             :   template<typename _CharT>
    1883             :     locale::id numpunct<_CharT>::id;
    1884             : 
    1885             :   template<>
    1886             :     numpunct<char>::~numpunct();
    1887             : 
    1888             :   template<>
    1889             :     void
    1890             :     numpunct<char>::_M_initialize_numpunct(__c_locale __cloc);
    1891             : 
    1892             : #ifdef _GLIBCXX_USE_WCHAR_T
    1893             :   template<>
    1894             :     numpunct<wchar_t>::~numpunct();
    1895             : 
    1896             :   template<>
    1897             :     void
    1898             :     numpunct<wchar_t>::_M_initialize_numpunct(__c_locale __cloc);
    1899             : #endif
    1900             : 
    1901             :   /// class numpunct_byname [22.2.3.2].
    1902             :   template<typename _CharT>
    1903             :     class numpunct_byname : public numpunct<_CharT>
    1904             :     {
    1905             :     public:
    1906             :       typedef _CharT                    char_type;
    1907             :       typedef basic_string<_CharT>        string_type;
    1908             : 
    1909             :       explicit
    1910             :       numpunct_byname(const char* __s, size_t __refs = 0)
    1911             :       : numpunct<_CharT>(__refs)
    1912             :       {
    1913             :         if (__builtin_strcmp(__s, "C") != 0
    1914             :             && __builtin_strcmp(__s, "POSIX") != 0)
    1915             :           {
    1916             :             __c_locale __tmp;
    1917             :             this->_S_create_c_locale(__tmp, __s);
    1918             :             this->_M_initialize_numpunct(__tmp);
    1919             :             this->_S_destroy_c_locale(__tmp);
    1920             :           }
    1921             :       }
    1922             : 
    1923             : #if __cplusplus >= 201103L
    1924             :       explicit
    1925             :       numpunct_byname(const string& __s, size_t __refs = 0)
    1926             :       : numpunct_byname(__s.c_str(), __refs) { }
    1927             : #endif
    1928             : 
    1929             :     protected:
    1930             :       virtual
    1931             :       ~numpunct_byname() { }
    1932             :     };
    1933             : 
    1934             : _GLIBCXX_END_NAMESPACE_CXX11
    1935             : 
    1936             : _GLIBCXX_BEGIN_NAMESPACE_LDBL
    1937             : 
    1938             :   /**
    1939             :    *  @brief  Primary class template num_get.
    1940             :    *  @ingroup locales
    1941             :    *
    1942             :    *  This facet encapsulates the code to parse and return a number
    1943             :    *  from a string.  It is used by the istream numeric extraction
    1944             :    *  operators.
    1945             :    *
    1946             :    *  The num_get template uses protected virtual functions to provide the
    1947             :    *  actual results.  The public accessors forward the call to the virtual
    1948             :    *  functions.  These virtual functions are hooks for developers to
    1949             :    *  implement the behavior they require from the num_get facet.
    1950             :   */
    1951             :   template<typename _CharT, typename _InIter>
    1952             :     class num_get : public locale::facet
    1953             :     {
    1954             :     public:
    1955             :       // Types:
    1956             :       ///@{
    1957             :       /// Public typedefs
    1958             :       typedef _CharT                    char_type;
    1959             :       typedef _InIter                   iter_type;
    1960             :       ///@}
    1961             : 
    1962             :       /// Numpunct facet id.
    1963             :       static locale::id                 id;
    1964             : 
    1965             :       /**
    1966             :        *  @brief  Constructor performs initialization.
    1967             :        *
    1968             :        *  This is the constructor provided by the standard.
    1969             :        *
    1970             :        *  @param __refs  Passed to the base facet class.
    1971             :       */
    1972             :       explicit
    1973             :       num_get(size_t __refs = 0) : facet(__refs) { }
    1974             : 
    1975             :       /**
    1976             :        *  @brief  Numeric parsing.
    1977             :        *
    1978             :        *  Parses the input stream into the bool @a v.  It does so by calling
    1979             :        *  num_get::do_get().
    1980             :        *
    1981             :        *  If ios_base::boolalpha is set, attempts to read
    1982             :        *  ctype<CharT>::truename() or ctype<CharT>::falsename().  Sets
    1983             :        *  @a v to true or false if successful.  Sets err to
    1984             :        *  ios_base::failbit if reading the string fails.  Sets err to
    1985             :        *  ios_base::eofbit if the stream is emptied.
    1986             :        *
    1987             :        *  If ios_base::boolalpha is not set, proceeds as with reading a long,
    1988             :        *  except if the value is 1, sets @a v to true, if the value is 0, sets
    1989             :        *  @a v to false, and otherwise set err to ios_base::failbit.
    1990             :        *
    1991             :        *  @param  __in  Start of input stream.
    1992             :        *  @param  __end  End of input stream.
    1993             :        *  @param  __io  Source of locale and flags.
    1994             :        *  @param  __err  Error flags to set.
    1995             :        *  @param  __v  Value to format and insert.
    1996             :        *  @return  Iterator after reading.
    1997             :       */
    1998             :       iter_type
    1999             :       get(iter_type __in, iter_type __end, ios_base& __io,
    2000             :           ios_base::iostate& __err, bool& __v) const
    2001             :       { return this->do_get(__in, __end, __io, __err, __v); }
    2002             : 
    2003             :       ///@{
    2004             :       /**
    2005             :        *  @brief  Numeric parsing.
    2006             :        *
    2007             :        *  Parses the input stream into the integral variable @a v.  It does so
    2008             :        *  by calling num_get::do_get().
    2009             :        *
    2010             :        *  Parsing is affected by the flag settings in @a io.
    2011             :        *
    2012             :        *  The basic parse is affected by the value of io.flags() &
    2013             :        *  ios_base::basefield.  If equal to ios_base::oct, parses like the
    2014             :        *  scanf %o specifier.  Else if equal to ios_base::hex, parses like %X
    2015             :        *  specifier.  Else if basefield equal to 0, parses like the %i
    2016             :        *  specifier.  Otherwise, parses like %d for signed and %u for unsigned
    2017             :        *  types.  The matching type length modifier is also used.
    2018             :        *
    2019             :        *  Digit grouping is interpreted according to
    2020             :        *  numpunct::grouping() and numpunct::thousands_sep().  If the
    2021             :        *  pattern of digit groups isn't consistent, sets err to
    2022             :        *  ios_base::failbit.
    2023             :        *
    2024             :        *  If parsing the string yields a valid value for @a v, @a v is set.
    2025             :        *  Otherwise, sets err to ios_base::failbit and leaves @a v unaltered.
    2026             :        *  Sets err to ios_base::eofbit if the stream is emptied.
    2027             :        *
    2028             :        *  @param  __in  Start of input stream.
    2029             :        *  @param  __end  End of input stream.
    2030             :        *  @param  __io  Source of locale and flags.
    2031             :        *  @param  __err  Error flags to set.
    2032             :        *  @param  __v  Value to format and insert.
    2033             :        *  @return  Iterator after reading.
    2034             :       */
    2035             :       iter_type
    2036             :       get(iter_type __in, iter_type __end, ios_base& __io,
    2037             :           ios_base::iostate& __err, long& __v) const
    2038             :       { return this->do_get(__in, __end, __io, __err, __v); }
    2039             : 
    2040             :       iter_type
    2041             :       get(iter_type __in, iter_type __end, ios_base& __io,
    2042             :           ios_base::iostate& __err, unsigned short& __v) const
    2043             :       { return this->do_get(__in, __end, __io, __err, __v); }
    2044             : 
    2045             :       iter_type
    2046             :       get(iter_type __in, iter_type __end, ios_base& __io,
    2047             :           ios_base::iostate& __err, unsigned int& __v)   const
    2048             :       { return this->do_get(__in, __end, __io, __err, __v); }
    2049             : 
    2050             :       iter_type
    2051             :       get(iter_type __in, iter_type __end, ios_base& __io,
    2052             :           ios_base::iostate& __err, unsigned long& __v)  const
    2053             :       { return this->do_get(__in, __end, __io, __err, __v); }
    2054             : 
    2055             : #ifdef _GLIBCXX_USE_LONG_LONG
    2056             :       iter_type
    2057             :       get(iter_type __in, iter_type __end, ios_base& __io,
    2058             :           ios_base::iostate& __err, long long& __v) const
    2059             :       { return this->do_get(__in, __end, __io, __err, __v); }
    2060             : 
    2061             :       iter_type
    2062             :       get(iter_type __in, iter_type __end, ios_base& __io,
    2063             :           ios_base::iostate& __err, unsigned long long& __v)  const
    2064             :       { return this->do_get(__in, __end, __io, __err, __v); }
    2065             : #endif
    2066             :       ///@}
    2067             : 
    2068             :       ///@{
    2069             :       /**
    2070             :        *  @brief  Numeric parsing.
    2071             :        *
    2072             :        *  Parses the input stream into the integral variable @a v.  It does so
    2073             :        *  by calling num_get::do_get().
    2074             :        *
    2075             :        *  The input characters are parsed like the scanf %g specifier.  The
    2076             :        *  matching type length modifier is also used.
    2077             :        *
    2078             :        *  The decimal point character used is numpunct::decimal_point().
    2079             :        *  Digit grouping is interpreted according to
    2080             :        *  numpunct::grouping() and numpunct::thousands_sep().  If the
    2081             :        *  pattern of digit groups isn't consistent, sets err to
    2082             :        *  ios_base::failbit.
    2083             :        *
    2084             :        *  If parsing the string yields a valid value for @a v, @a v is set.
    2085             :        *  Otherwise, sets err to ios_base::failbit and leaves @a v unaltered.
    2086             :        *  Sets err to ios_base::eofbit if the stream is emptied.
    2087             :        *
    2088             :        *  @param  __in  Start of input stream.
    2089             :        *  @param  __end  End of input stream.
    2090             :        *  @param  __io  Source of locale and flags.
    2091             :        *  @param  __err  Error flags to set.
    2092             :        *  @param  __v  Value to format and insert.
    2093             :        *  @return  Iterator after reading.
    2094             :       */
    2095             :       iter_type
    2096             :       get(iter_type __in, iter_type __end, ios_base& __io,
    2097             :           ios_base::iostate& __err, float& __v) const
    2098             :       { return this->do_get(__in, __end, __io, __err, __v); }
    2099             : 
    2100             :       iter_type
    2101             :       get(iter_type __in, iter_type __end, ios_base& __io,
    2102             :           ios_base::iostate& __err, double& __v) const
    2103             :       { return this->do_get(__in, __end, __io, __err, __v); }
    2104             : 
    2105             :       iter_type
    2106             :       get(iter_type __in, iter_type __end, ios_base& __io,
    2107             :           ios_base::iostate& __err, long double& __v) const
    2108             :       { return this->do_get(__in, __end, __io, __err, __v); }
    2109             :       ///@}
    2110             : 
    2111             :       /**
    2112             :        *  @brief  Numeric parsing.
    2113             :        *
    2114             :        *  Parses the input stream into the pointer variable @a v.  It does so
    2115             :        *  by calling num_get::do_get().
    2116             :        *
    2117             :        *  The input characters are parsed like the scanf %p specifier.
    2118             :        *
    2119             :        *  Digit grouping is interpreted according to
    2120             :        *  numpunct::grouping() and numpunct::thousands_sep().  If the
    2121             :        *  pattern of digit groups isn't consistent, sets err to
    2122             :        *  ios_base::failbit.
    2123             :        *
    2124             :        *  Note that the digit grouping effect for pointers is a bit ambiguous
    2125             :        *  in the standard and shouldn't be relied on.  See DR 344.
    2126             :        *
    2127             :        *  If parsing the string yields a valid value for @a v, @a v is set.
    2128             :        *  Otherwise, sets err to ios_base::failbit and leaves @a v unaltered.
    2129             :        *  Sets err to ios_base::eofbit if the stream is emptied.
    2130             :        *
    2131             :        *  @param  __in  Start of input stream.
    2132             :        *  @param  __end  End of input stream.
    2133             :        *  @param  __io  Source of locale and flags.
    2134             :        *  @param  __err  Error flags to set.
    2135             :        *  @param  __v  Value to format and insert.
    2136             :        *  @return  Iterator after reading.
    2137             :       */
    2138             :       iter_type
    2139             :       get(iter_type __in, iter_type __end, ios_base& __io,
    2140             :           ios_base::iostate& __err, void*& __v) const
    2141             :       { return this->do_get(__in, __end, __io, __err, __v); }
    2142             : 
    2143             :     protected:
    2144             :       /// Destructor.
    2145             :       virtual ~num_get() { }
    2146             : 
    2147             :       _GLIBCXX_DEFAULT_ABI_TAG
    2148             :       iter_type
    2149             :       _M_extract_float(iter_type, iter_type, ios_base&, ios_base::iostate&,
    2150             :                        string&) const;
    2151             : 
    2152             :       template<typename _ValueT>
    2153             :         _GLIBCXX_DEFAULT_ABI_TAG
    2154             :         iter_type
    2155             :         _M_extract_int(iter_type, iter_type, ios_base&, ios_base::iostate&,
    2156             :                        _ValueT&) const;
    2157             : 
    2158             :       template<typename _CharT2>
    2159             :       typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, int>::__type
    2160             :         _M_find(const _CharT2*, size_t __len, _CharT2 __c) const
    2161             :         {
    2162             :           int __ret = -1;
    2163             :           if (__len <= 10)
    2164             :             {
    2165             :               if (__c >= _CharT2('0') && __c < _CharT2(_CharT2('0') + __len))
    2166             :                 __ret = __c - _CharT2('0');
    2167             :             }
    2168             :           else
    2169             :             {
    2170             :               if (__c >= _CharT2('0') && __c <= _CharT2('9'))
    2171             :                 __ret = __c - _CharT2('0');
    2172             :               else if (__c >= _CharT2('a') && __c <= _CharT2('f'))
    2173             :                 __ret = 10 + (__c - _CharT2('a'));
    2174             :               else if (__c >= _CharT2('A') && __c <= _CharT2('F'))
    2175             :                 __ret = 10 + (__c - _CharT2('A'));
    2176             :             }
    2177             :           return __ret;
    2178             :         }
    2179             : 
    2180             :       template<typename _CharT2>
    2181             :       typename __gnu_cxx::__enable_if<!__is_char<_CharT2>::__value,
    2182             :                                       int>::__type
    2183             :         _M_find(const _CharT2* __zero, size_t __len, _CharT2 __c) const
    2184             :         {
    2185             :           int __ret = -1;
    2186             :           const char_type* __q = char_traits<_CharT2>::find(__zero, __len, __c);
    2187             :           if (__q)
    2188             :             {
    2189             :               __ret = __q - __zero;
    2190             :               if (__ret > 15)
    2191             :                 __ret -= 6;
    2192             :             }
    2193             :           return __ret;
    2194             :         }
    2195             : 
    2196             :       ///@{
    2197             :       /**
    2198             :        *  @brief  Numeric parsing.
    2199             :        *
    2200             :        *  Parses the input stream into the variable @a v.  This function is a
    2201             :        *  hook for derived classes to change the value returned.  @see get()
    2202             :        *  for more details.
    2203             :        *
    2204             :        *  @param  __beg  Start of input stream.
    2205             :        *  @param  __end  End of input stream.
    2206             :        *  @param  __io  Source of locale and flags.
    2207             :        *  @param  __err  Error flags to set.
    2208             :        *  @param  __v  Value to format and insert.
    2209             :        *  @return  Iterator after reading.
    2210             :       */
    2211             :       virtual iter_type
    2212             :       do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, bool&) const;
    2213             : 
    2214             :       virtual iter_type
    2215             :       do_get(iter_type __beg, iter_type __end, ios_base& __io,
    2216             :              ios_base::iostate& __err, long& __v) const
    2217             :       { return _M_extract_int(__beg, __end, __io, __err, __v); }
    2218             : 
    2219             :       virtual iter_type
    2220             :       do_get(iter_type __beg, iter_type __end, ios_base& __io,
    2221             :              ios_base::iostate& __err, unsigned short& __v) const
    2222             :       { return _M_extract_int(__beg, __end, __io, __err, __v); }
    2223             : 
    2224             :       virtual iter_type
    2225             :       do_get(iter_type __beg, iter_type __end, ios_base& __io,
    2226             :              ios_base::iostate& __err, unsigned int& __v) const
    2227             :       { return _M_extract_int(__beg, __end, __io, __err, __v); }
    2228             : 
    2229             :       virtual iter_type
    2230             :       do_get(iter_type __beg, iter_type __end, ios_base& __io,
    2231             :              ios_base::iostate& __err, unsigned long& __v) const
    2232             :       { return _M_extract_int(__beg, __end, __io, __err, __v); }
    2233             : 
    2234             : #ifdef _GLIBCXX_USE_LONG_LONG
    2235             :       virtual iter_type
    2236             :       do_get(iter_type __beg, iter_type __end, ios_base& __io,
    2237             :              ios_base::iostate& __err, long long& __v) const
    2238             :       { return _M_extract_int(__beg, __end, __io, __err, __v); }
    2239             : 
    2240             :       virtual iter_type
    2241             :       do_get(iter_type __beg, iter_type __end, ios_base& __io,
    2242             :              ios_base::iostate& __err, unsigned long long& __v) const
    2243             :       { return _M_extract_int(__beg, __end, __io, __err, __v); }
    2244             : #endif
    2245             : 
    2246             :       virtual iter_type
    2247             :       do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, float&) const;
    2248             : 
    2249             :       virtual iter_type
    2250             :       do_get(iter_type, iter_type, ios_base&, ios_base::iostate&,
    2251             :              double&) const;
    2252             : 
    2253             :       // XXX GLIBCXX_ABI Deprecated
    2254             : #if defined _GLIBCXX_LONG_DOUBLE_COMPAT && defined __LONG_DOUBLE_128__
    2255             :       virtual iter_type
    2256             :       __do_get(iter_type, iter_type, ios_base&, ios_base::iostate&,
    2257             :                double&) const;
    2258             : #else
    2259             :       virtual iter_type
    2260             :       do_get(iter_type, iter_type, ios_base&, ios_base::iostate&,
    2261             :              long double&) const;
    2262             : #endif
    2263             : 
    2264             :       virtual iter_type
    2265             :       do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, void*&) const;
    2266             : 
    2267             :       // XXX GLIBCXX_ABI Deprecated
    2268             : #if defined _GLIBCXX_LONG_DOUBLE_COMPAT && defined __LONG_DOUBLE_128__
    2269             :       virtual iter_type
    2270             :       do_get(iter_type, iter_type, ios_base&, ios_base::iostate&,
    2271             :              long double&) const;
    2272             : #endif
    2273             :       ///@}
    2274             :     };
    2275             : 
    2276             :   template<typename _CharT, typename _InIter>
    2277             :     locale::id num_get<_CharT, _InIter>::id;
    2278             : 
    2279             : 
    2280             :   /**
    2281             :    *  @brief  Primary class template num_put.
    2282             :    *  @ingroup locales
    2283             :    *
    2284             :    *  This facet encapsulates the code to convert a number to a string.  It is
    2285             :    *  used by the ostream numeric insertion operators.
    2286             :    *
    2287             :    *  The num_put template uses protected virtual functions to provide the
    2288             :    *  actual results.  The public accessors forward the call to the virtual
    2289             :    *  functions.  These virtual functions are hooks for developers to
    2290             :    *  implement the behavior they require from the num_put facet.
    2291             :   */
    2292             :   template<typename _CharT, typename _OutIter>
    2293             :     class num_put : public locale::facet
    2294             :     {
    2295             :     public:
    2296             :       // Types:
    2297             :       ///@{
    2298             :       /// Public typedefs
    2299             :       typedef _CharT            char_type;
    2300             :       typedef _OutIter          iter_type;
    2301             :       ///@}
    2302             : 
    2303             :       /// Numpunct facet id.
    2304             :       static locale::id         id;
    2305             : 
    2306             :       /**
    2307             :        *  @brief  Constructor performs initialization.
    2308             :        *
    2309             :        *  This is the constructor provided by the standard.
    2310             :        *
    2311             :        *  @param __refs  Passed to the base facet class.
    2312             :       */
    2313             :       explicit
    2314             :       num_put(size_t __refs = 0) : facet(__refs) { }
    2315             : 
    2316             :       /**
    2317             :        *  @brief  Numeric formatting.
    2318             :        *
    2319             :        *  Formats the boolean @a v and inserts it into a stream.  It does so
    2320             :        *  by calling num_put::do_put().
    2321             :        *
    2322             :        *  If ios_base::boolalpha is set, writes ctype<CharT>::truename() or
    2323             :        *  ctype<CharT>::falsename().  Otherwise formats @a v as an int.
    2324             :        *
    2325             :        *  @param  __s  Stream to write to.
    2326             :        *  @param  __io  Source of locale and flags.
    2327             :        *  @param  __fill  Char_type to use for filling.
    2328             :        *  @param  __v  Value to format and insert.
    2329             :        *  @return  Iterator after writing.
    2330             :       */
    2331             :       iter_type
    2332             :       put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const
    2333             :       { return this->do_put(__s, __io, __fill, __v); }
    2334             : 
    2335             :       ///@{
    2336             :       /**
    2337             :        *  @brief  Numeric formatting.
    2338             :        *
    2339             :        *  Formats the integral value @a v and inserts it into a
    2340             :        *  stream.  It does so by calling num_put::do_put().
    2341             :        *
    2342             :        *  Formatting is affected by the flag settings in @a io.
    2343             :        *
    2344             :        *  The basic format is affected by the value of io.flags() &
    2345             :        *  ios_base::basefield.  If equal to ios_base::oct, formats like the
    2346             :        *  printf %o specifier.  Else if equal to ios_base::hex, formats like
    2347             :        *  %x or %X with ios_base::uppercase unset or set respectively.
    2348             :        *  Otherwise, formats like %d, %ld, %lld for signed and %u, %lu, %llu
    2349             :        *  for unsigned values.  Note that if both oct and hex are set, neither
    2350             :        *  will take effect.
    2351             :        *
    2352             :        *  If ios_base::showpos is set, '+' is output before positive values.
    2353             :        *  If ios_base::showbase is set, '0' precedes octal values (except 0)
    2354             :        *  and '0[xX]' precedes hex values.
    2355             :        *
    2356             :        *  The decimal point character used is numpunct::decimal_point().
    2357             :        *  Thousands separators are inserted according to
    2358             :        *  numpunct::grouping() and numpunct::thousands_sep().
    2359             :        *
    2360             :        *  If io.width() is non-zero, enough @a fill characters are inserted to
    2361             :        *  make the result at least that wide.  If
    2362             :        *  (io.flags() & ios_base::adjustfield) == ios_base::left, result is
    2363             :        *  padded at the end.  If ios_base::internal, then padding occurs
    2364             :        *  immediately after either a '+' or '-' or after '0x' or '0X'.
    2365             :        *  Otherwise, padding occurs at the beginning.
    2366             :        *
    2367             :        *  @param  __s  Stream to write to.
    2368             :        *  @param  __io  Source of locale and flags.
    2369             :        *  @param  __fill  Char_type to use for filling.
    2370             :        *  @param  __v  Value to format and insert.
    2371             :        *  @return  Iterator after writing.
    2372             :       */
    2373             :       iter_type
    2374             :       put(iter_type __s, ios_base& __io, char_type __fill, long __v) const
    2375             :       { return this->do_put(__s, __io, __fill, __v); }
    2376             : 
    2377             :       iter_type
    2378             :       put(iter_type __s, ios_base& __io, char_type __fill,
    2379             :           unsigned long __v) const
    2380             :       { return this->do_put(__s, __io, __fill, __v); }
    2381             : 
    2382             : #ifdef _GLIBCXX_USE_LONG_LONG
    2383             :       iter_type
    2384             :       put(iter_type __s, ios_base& __io, char_type __fill, long long __v) const
    2385             :       { return this->do_put(__s, __io, __fill, __v); }
    2386             : 
    2387             :       iter_type
    2388             :       put(iter_type __s, ios_base& __io, char_type __fill,
    2389             :           unsigned long long __v) const
    2390             :       { return this->do_put(__s, __io, __fill, __v); }
    2391             : #endif
    2392             :       ///@}
    2393             : 
    2394             :       ///@{
    2395             :       /**
    2396             :        *  @brief  Numeric formatting.
    2397             :        *
    2398             :        *  Formats the floating point value @a v and inserts it into a stream.
    2399             :        *  It does so by calling num_put::do_put().
    2400             :        *
    2401             :        *  Formatting is affected by the flag settings in @a io.
    2402             :        *
    2403             :        *  The basic format is affected by the value of io.flags() &
    2404             :        *  ios_base::floatfield.  If equal to ios_base::fixed, formats like the
    2405             :        *  printf %f specifier.  Else if equal to ios_base::scientific, formats
    2406             :        *  like %e or %E with ios_base::uppercase unset or set respectively.
    2407             :        *  Otherwise, formats like %g or %G depending on uppercase.  Note that
    2408             :        *  if both fixed and scientific are set, the effect will also be like
    2409             :        *  %g or %G.
    2410             :        *
    2411             :        *  The output precision is given by io.precision().  This precision is
    2412             :        *  capped at numeric_limits::digits10 + 2 (different for double and
    2413             :        *  long double).  The default precision is 6.
    2414             :        *
    2415             :        *  If ios_base::showpos is set, '+' is output before positive values.
    2416             :        *  If ios_base::showpoint is set, a decimal point will always be
    2417             :        *  output.
    2418             :        *
    2419             :        *  The decimal point character used is numpunct::decimal_point().
    2420             :        *  Thousands separators are inserted according to
    2421             :        *  numpunct::grouping() and numpunct::thousands_sep().
    2422             :        *
    2423             :        *  If io.width() is non-zero, enough @a fill characters are inserted to
    2424             :        *  make the result at least that wide.  If
    2425             :        *  (io.flags() & ios_base::adjustfield) == ios_base::left, result is
    2426             :        *  padded at the end.  If ios_base::internal, then padding occurs
    2427             :        *  immediately after either a '+' or '-' or after '0x' or '0X'.
    2428             :        *  Otherwise, padding occurs at the beginning.
    2429             :        *
    2430             :        *  @param  __s  Stream to write to.
    2431             :        *  @param  __io  Source of locale and flags.
    2432             :        *  @param  __fill  Char_type to use for filling.
    2433             :        *  @param  __v  Value to format and insert.
    2434             :        *  @return  Iterator after writing.
    2435             :       */
    2436             :       iter_type
    2437             :       put(iter_type __s, ios_base& __io, char_type __fill, double __v) const
    2438             :       { return this->do_put(__s, __io, __fill, __v); }
    2439             : 
    2440             :       iter_type
    2441             :       put(iter_type __s, ios_base& __io, char_type __fill,
    2442             :           long double __v) const
    2443             :       { return this->do_put(__s, __io, __fill, __v); }
    2444             :       ///@}
    2445             : 
    2446             :       /**
    2447             :        *  @brief  Numeric formatting.
    2448             :        *
    2449             :        *  Formats the pointer value @a v and inserts it into a stream.  It
    2450             :        *  does so by calling num_put::do_put().
    2451             :        *
    2452             :        *  This function formats @a v as an unsigned long with ios_base::hex
    2453             :        *  and ios_base::showbase set.
    2454             :        *
    2455             :        *  @param  __s  Stream to write to.
    2456             :        *  @param  __io  Source of locale and flags.
    2457             :        *  @param  __fill  Char_type to use for filling.
    2458             :        *  @param  __v  Value to format and insert.
    2459             :        *  @return  Iterator after writing.
    2460             :       */
    2461             :       iter_type
    2462             :       put(iter_type __s, ios_base& __io, char_type __fill,
    2463             :           const void* __v) const
    2464             :       { return this->do_put(__s, __io, __fill, __v); }
    2465             : 
    2466             :     protected:
    2467             :       template<typename _ValueT>
    2468             :         iter_type
    2469             :         _M_insert_float(iter_type, ios_base& __io, char_type __fill,
    2470             :                         char __mod, _ValueT __v) const;
    2471             : 
    2472             :       void
    2473             :       _M_group_float(const char* __grouping, size_t __grouping_size,
    2474             :                      char_type __sep, const char_type* __p, char_type* __new,
    2475             :                      char_type* __cs, int& __len) const;
    2476             : 
    2477             :       template<typename _ValueT>
    2478             :         iter_type
    2479             :         _M_insert_int(iter_type, ios_base& __io, char_type __fill,
    2480             :                       _ValueT __v) const;
    2481             : 
    2482             :       void
    2483             :       _M_group_int(const char* __grouping, size_t __grouping_size,
    2484             :                    char_type __sep, ios_base& __io, char_type* __new,
    2485             :                    char_type* __cs, int& __len) const;
    2486             : 
    2487             :       void
    2488             :       _M_pad(char_type __fill, streamsize __w, ios_base& __io,
    2489             :              char_type* __new, const char_type* __cs, int& __len) const;
    2490             : 
    2491             :       /// Destructor.
    2492             :       virtual
    2493             :       ~num_put() { }
    2494             : 
    2495             :       ///@{
    2496             :       /**
    2497             :        *  @brief  Numeric formatting.
    2498             :        *
    2499             :        *  These functions do the work of formatting numeric values and
    2500             :        *  inserting them into a stream. This function is a hook for derived
    2501             :        *  classes to change the value returned.
    2502             :        *
    2503             :        *  @param  __s  Stream to write to.
    2504             :        *  @param  __io  Source of locale and flags.
    2505             :        *  @param  __fill  Char_type to use for filling.
    2506             :        *  @param  __v  Value to format and insert.
    2507             :        *  @return  Iterator after writing.
    2508             :       */
    2509             :       virtual iter_type
    2510             :       do_put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const;
    2511             : 
    2512             :       virtual iter_type
    2513             :       do_put(iter_type __s, ios_base& __io, char_type __fill, long __v) const
    2514             :       { return _M_insert_int(__s, __io, __fill, __v); }
    2515             : 
    2516             :       virtual iter_type
    2517             :       do_put(iter_type __s, ios_base& __io, char_type __fill,
    2518             :              unsigned long __v) const
    2519             :       { return _M_insert_int(__s, __io, __fill, __v); }
    2520             : 
    2521             : #ifdef _GLIBCXX_USE_LONG_LONG
    2522             :       virtual iter_type
    2523             :       do_put(iter_type __s, ios_base& __io, char_type __fill,
    2524             :              long long __v) const
    2525             :       { return _M_insert_int(__s, __io, __fill, __v); }
    2526             : 
    2527             :       virtual iter_type
    2528             :       do_put(iter_type __s, ios_base& __io, char_type __fill,
    2529             :              unsigned long long __v) const
    2530             :       { return _M_insert_int(__s, __io, __fill, __v); }
    2531             : #endif
    2532             : 
    2533             :       virtual iter_type
    2534             :       do_put(iter_type, ios_base&, char_type, double) const;
    2535             : 
    2536             :       // XXX GLIBCXX_ABI Deprecated
    2537             : #if defined _GLIBCXX_LONG_DOUBLE_COMPAT && defined __LONG_DOUBLE_128__
    2538             :       virtual iter_type
    2539             :       __do_put(iter_type, ios_base&, char_type, double) const;
    2540             : #else
    2541             :       virtual iter_type
    2542             :       do_put(iter_type, ios_base&, char_type, long double) const;
    2543             : #endif
    2544             : 
    2545             :       virtual iter_type
    2546             :       do_put(iter_type, ios_base&, char_type, const void*) const;
    2547             : 
    2548             :       // XXX GLIBCXX_ABI Deprecated
    2549             : #if defined _GLIBCXX_LONG_DOUBLE_COMPAT && defined __LONG_DOUBLE_128__
    2550             :       virtual iter_type
    2551             :       do_put(iter_type, ios_base&, char_type, long double) const;
    2552             : #endif
    2553             :       ///@}
    2554             :     };
    2555             : 
    2556             :   template <typename _CharT, typename _OutIter>
    2557             :     locale::id num_put<_CharT, _OutIter>::id;
    2558             : 
    2559             : _GLIBCXX_END_NAMESPACE_LDBL
    2560             : 
    2561             :   // Subclause convenience interfaces, inlines.
    2562             :   // NB: These are inline because, when used in a loop, some compilers
    2563             :   // can hoist the body out of the loop; then it's just as fast as the
    2564             :   // C is*() function.
    2565             : 
    2566             :   /// Convenience interface to ctype.is(ctype_base::space, __c).
    2567             :   template<typename _CharT>
    2568             :     inline bool
    2569             :     isspace(_CharT __c, const locale& __loc)
    2570             :     { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::space, __c); }
    2571             : 
    2572             :   /// Convenience interface to ctype.is(ctype_base::print, __c).
    2573             :   template<typename _CharT>
    2574             :     inline bool
    2575             :     isprint(_CharT __c, const locale& __loc)
    2576             :     { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::print, __c); }
    2577             : 
    2578             :   /// Convenience interface to ctype.is(ctype_base::cntrl, __c).
    2579             :   template<typename _CharT>
    2580             :     inline bool
    2581             :     iscntrl(_CharT __c, const locale& __loc)
    2582             :     { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::cntrl, __c); }
    2583             : 
    2584             :   /// Convenience interface to ctype.is(ctype_base::upper, __c).
    2585             :   template<typename _CharT>
    2586             :     inline bool
    2587             :     isupper(_CharT __c, const locale& __loc)
    2588             :     { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::upper, __c); }
    2589             : 
    2590             :   /// Convenience interface to ctype.is(ctype_base::lower, __c).
    2591             :   template<typename _CharT>
    2592             :     inline bool
    2593             :     islower(_CharT __c, const locale& __loc)
    2594             :     { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::lower, __c); }
    2595             : 
    2596             :   /// Convenience interface to ctype.is(ctype_base::alpha, __c).
    2597             :   template<typename _CharT>
    2598             :     inline bool
    2599             :     isalpha(_CharT __c, const locale& __loc)
    2600             :     { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::alpha, __c); }
    2601             : 
    2602             :   /// Convenience interface to ctype.is(ctype_base::digit, __c).
    2603             :   template<typename _CharT>
    2604             :     inline bool
    2605             :     isdigit(_CharT __c, const locale& __loc)
    2606             :     { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::digit, __c); }
    2607             : 
    2608             :   /// Convenience interface to ctype.is(ctype_base::punct, __c).
    2609             :   template<typename _CharT>
    2610             :     inline bool
    2611             :     ispunct(_CharT __c, const locale& __loc)
    2612             :     { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::punct, __c); }
    2613             : 
    2614             :   /// Convenience interface to ctype.is(ctype_base::xdigit, __c).
    2615             :   template<typename _CharT>
    2616             :     inline bool
    2617             :     isxdigit(_CharT __c, const locale& __loc)
    2618             :     { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::xdigit, __c); }
    2619             : 
    2620             :   /// Convenience interface to ctype.is(ctype_base::alnum, __c).
    2621             :   template<typename _CharT>
    2622             :     inline bool
    2623             :     isalnum(_CharT __c, const locale& __loc)
    2624             :     { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::alnum, __c); }
    2625             : 
    2626             :   /// Convenience interface to ctype.is(ctype_base::graph, __c).
    2627             :   template<typename _CharT>
    2628             :     inline bool
    2629             :     isgraph(_CharT __c, const locale& __loc)
    2630             :     { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::graph, __c); }
    2631             : 
    2632             : #if __cplusplus >= 201103L
    2633             :   /// Convenience interface to ctype.is(ctype_base::blank, __c).
    2634             :   template<typename _CharT>
    2635             :     inline bool
    2636             :     isblank(_CharT __c, const locale& __loc)
    2637             :     { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::blank, __c); }
    2638             : #endif
    2639             : 
    2640             :   /// Convenience interface to ctype.toupper(__c).
    2641             :   template<typename _CharT>
    2642             :     inline _CharT
    2643           0 :     toupper(_CharT __c, const locale& __loc)
    2644           0 :     { return use_facet<ctype<_CharT> >(__loc).toupper(__c); }
    2645             : 
    2646             :   /// Convenience interface to ctype.tolower(__c).
    2647             :   template<typename _CharT>
    2648             :     inline _CharT
    2649       14240 :     tolower(_CharT __c, const locale& __loc)
    2650       14240 :     { return use_facet<ctype<_CharT> >(__loc).tolower(__c); }
    2651             : 
    2652             : _GLIBCXX_END_NAMESPACE_VERSION
    2653             : } // namespace std
    2654             : 
    2655             : # include <bits/locale_facets.tcc>
    2656             : 
    2657             : #endif

Generated by: LCOV version 1.14