Subversion Repositories openrisc

// Locale support -*- C++ -*-

// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,

// 2006, 2007, 2008, 2009

// Free Software Foundation, Inc.

//

// This file is part of the GNU ISO C++ Library.  This library is free

// software; you can redistribute it and/or modify it under the

// terms of the GNU General Public License as published by the

// Free Software Foundation; either version 3, or (at your option)

// any later version.

// This library is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

// GNU General Public License for more details.

// Under Section 7 of GPL version 3, you are granted additional

// permissions described in the GCC Runtime Library Exception, version

// 3.1, as published by the Free Software Foundation.

// You should have received a copy of the GNU General Public License and

// a copy of the GCC Runtime Library Exception along with this program;

// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see

// .

/** @file locale_facets.tcc

 *  This is an internal header file, included by other library headers.

 *  You should not attempt to use it directly.

 */

#ifndef _LOCALE_FACETS_TCC

#define _LOCALE_FACETS_TCC 1

#pragma GCC system_header

_GLIBCXX_BEGIN_NAMESPACE(std)

  // Routine to access a cache for the facet.  If the cache didn't

  // exist before, it gets constructed on the fly.

  template

    struct __use_cache

    {

      const _Facet*

      operator() (const locale& __loc) const;

    };

  // Specializations.

  template

    struct __use_cache<__numpunct_cache<_CharT> >

    {

      const __numpunct_cache<_CharT>*

      operator() (const locale& __loc) const

      {

        const size_t __i = numpunct<_CharT>::id._M_id();

        const locale::facet** __caches = __loc._M_impl->_M_caches;

        if (!__caches[__i])

          {

            __numpunct_cache<_CharT>* __tmp = NULL;

            __try

              {

                __tmp = new __numpunct_cache<_CharT>;

                __tmp->_M_cache(__loc);

              }

            __catch(...)

              {

                delete __tmp;

                __throw_exception_again;

              }

            __loc._M_impl->_M_install_cache(__tmp, __i);

          }

        return static_cast*>(__caches[__i]);

      }

    };

  template

    void

    __numpunct_cache<_CharT>::_M_cache(const locale& __loc)

    {

      _M_allocated = true;

      const numpunct<_CharT>& __np = use_facet >(__loc);

      char* __grouping = 0;

      _CharT* __truename = 0;

      _CharT* __falsename = 0;

      __try

        {

          _M_grouping_size = __np.grouping().size();

          __grouping = new char[_M_grouping_size];

          __np.grouping().copy(__grouping, _M_grouping_size);

          _M_grouping = __grouping;

          _M_use_grouping = (_M_grouping_size

                             && static_cast(_M_grouping[0]) > 0

                             && (_M_grouping[0]

                                 != __gnu_cxx::__numeric_traits::__max));

          _M_truename_size = __np.truename().size();

          __truename = new _CharT[_M_truename_size];

          __np.truename().copy(__truename, _M_truename_size);

          _M_truename = __truename;

          _M_falsename_size = __np.falsename().size();

          __falsename = new _CharT[_M_falsename_size];

          __np.falsename().copy(__falsename, _M_falsename_size);

          _M_falsename = __falsename;

          _M_decimal_point = __np.decimal_point();

          _M_thousands_sep = __np.thousands_sep();

          const ctype<_CharT>& __ct = use_facet >(__loc);

          __ct.widen(__num_base::_S_atoms_out,

                     __num_base::_S_atoms_out

                     + __num_base::_S_oend, _M_atoms_out);

          __ct.widen(__num_base::_S_atoms_in,

                     __num_base::_S_atoms_in

                     + __num_base::_S_iend, _M_atoms_in);

        }

      __catch(...)

        {

          delete [] __grouping;

          delete [] __truename;

          delete [] __falsename;

          __throw_exception_again;

        }

    }

  // Used by both numeric and monetary facets.

  // Check to make sure that the __grouping_tmp string constructed in

  // money_get or num_get matches the canonical grouping for a given

  // locale.

  // __grouping_tmp is parsed L to R

  // 1,222,444 == __grouping_tmp of "\1\3\3"

  // __grouping is parsed R to L

  // 1,222,444 == __grouping of "\3" == "\3\3\3"

  _GLIBCXX_PURE bool

  __verify_grouping(const char* __grouping, size_t __grouping_size,

                    const string& __grouping_tmp) throw ();

_GLIBCXX_BEGIN_LDBL_NAMESPACE

  template

    _InIter

    num_get<_CharT, _InIter>::

    _M_extract_float(_InIter __beg, _InIter __end, ios_base& __io,

                     ios_base::iostate& __err, string& __xtrc) const

    {

      typedef char_traits<_CharT>                       __traits_type;

      typedef __numpunct_cache<_CharT>                  __cache_type;

      __use_cache<__cache_type> __uc;

      const locale& __loc = __io._M_getloc();

      const __cache_type* __lc = __uc(__loc);

      const _CharT* __lit = __lc->_M_atoms_in;

      char_type __c = char_type();

      // True if __beg becomes equal to __end.

      bool __testeof = __beg == __end;

      // First check for sign.

      if (!__testeof)

        {

          __c = *__beg;

          const bool __plus = __c == __lit[__num_base::_S_iplus];

          if ((__plus || __c == __lit[__num_base::_S_iminus])

              && !(__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)

              && !(__c == __lc->_M_decimal_point))

            {

              __xtrc += __plus ? '+' : '-';

              if (++__beg != __end)

                __c = *__beg;

              else

                __testeof = true;

            }

        }

      // Next, look for leading zeros.

      bool __found_mantissa = false;

      int __sep_pos = 0;

      while (!__testeof)

        {

          if ((__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)

              || __c == __lc->_M_decimal_point)

            break;

          else if (__c == __lit[__num_base::_S_izero])

            {

              if (!__found_mantissa)

                {

                  __xtrc += '0';

                  __found_mantissa = true;

                }

              ++__sep_pos;

              if (++__beg != __end)

                __c = *__beg;

              else

                __testeof = true;

            }

          else

            break;

        }

      // Only need acceptable digits for floating point numbers.

      bool __found_dec = false;

      bool __found_sci = false;

      string __found_grouping;

      if (__lc->_M_use_grouping)

        __found_grouping.reserve(32);

      const char_type* __lit_zero = __lit + __num_base::_S_izero;

      if (!__lc->_M_allocated)

        // "C" locale

        while (!__testeof)

          {

            const int __digit = _M_find(__lit_zero, 10, __c);

            if (__digit != -1)

              {

                __xtrc += '0' + __digit;

                __found_mantissa = true;

              }

            else if (__c == __lc->_M_decimal_point

                     && !__found_dec && !__found_sci)

              {

                __xtrc += '.';

                __found_dec = true;

              }

            else if ((__c == __lit[__num_base::_S_ie]

                      || __c == __lit[__num_base::_S_iE])

                     && !__found_sci && __found_mantissa)

              {

                // Scientific notation.

                __xtrc += 'e';

                __found_sci = true;

                // Remove optional plus or minus sign, if they exist.

                if (++__beg != __end)

                  {

                    __c = *__beg;

                    const bool __plus = __c == __lit[__num_base::_S_iplus];

                    if (__plus || __c == __lit[__num_base::_S_iminus])

                      __xtrc += __plus ? '+' : '-';

                    else

                      continue;

                  }

                else

                  {

                    __testeof = true;

                    break;

                  }

              }

            else

              break;

            if (++__beg != __end)

              __c = *__beg;

            else

              __testeof = true;

          }

      else

        while (!__testeof)

          {

            // According to 22.2.2.1.2, p8-9, first look for thousands_sep

            // and decimal_point.

            if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)

              {

                if (!__found_dec && !__found_sci)

                  {

                    // NB: Thousands separator at the beginning of a string

                    // is a no-no, as is two consecutive thousands separators.

                    if (__sep_pos)

                      {

                        __found_grouping += static_cast(__sep_pos);

                        __sep_pos = 0;

                      }

                    else

                      {

                        // NB: __convert_to_v will not assign __v and will

                        // set the failbit.

                        __xtrc.clear();

                        break;

                      }

                  }

                else

                  break;

              }

            else if (__c == __lc->_M_decimal_point)

              {

                if (!__found_dec && !__found_sci)

                  {

                    // If no grouping chars are seen, no grouping check

                    // is applied. Therefore __found_grouping is adjusted

                    // only if decimal_point comes after some thousands_sep.

                    if (__found_grouping.size())

                      __found_grouping += static_cast(__sep_pos);

                    __xtrc += '.';

                    __found_dec = true;

                  }

                else

                  break;

              }

            else

              {

                const char_type* __q =

                  __traits_type::find(__lit_zero, 10, __c);

                if (__q)

                  {

                    __xtrc += '0' + (__q - __lit_zero);

                    __found_mantissa = true;

                    ++__sep_pos;

                  }

                else if ((__c == __lit[__num_base::_S_ie]

                          || __c == __lit[__num_base::_S_iE])

                         && !__found_sci && __found_mantissa)

                  {

                    // Scientific notation.

                    if (__found_grouping.size() && !__found_dec)

                      __found_grouping += static_cast(__sep_pos);

                    __xtrc += 'e';

                    __found_sci = true;

                    // Remove optional plus or minus sign, if they exist.

                    if (++__beg != __end)

                      {

                        __c = *__beg;

                        const bool __plus = __c == __lit[__num_base::_S_iplus];

                        if ((__plus || __c == __lit[__num_base::_S_iminus])

                            && !(__lc->_M_use_grouping

                                 && __c == __lc->_M_thousands_sep)

                            && !(__c == __lc->_M_decimal_point))

                      __xtrc += __plus ? '+' : '-';

                        else

                          continue;

                      }

                    else

                      {

                        __testeof = true;

                        break;

                      }

                  }

                else

                  break;

              }

            if (++__beg != __end)

              __c = *__beg;

            else

              __testeof = true;

          }

      // Digit grouping is checked. If grouping and found_grouping don't

      // match, then get very very upset, and set failbit.

      if (__found_grouping.size())

        {

          // Add the ending grouping if a decimal or 'e'/'E' wasn't found.

          if (!__found_dec && !__found_sci)

            __found_grouping += static_cast(__sep_pos);

          if (!std::__verify_grouping(__lc->_M_grouping,

                                      __lc->_M_grouping_size,

                                      __found_grouping))

            __err = ios_base::failbit;

        }

      return __beg;

    }

  template

    template

      _InIter

      num_get<_CharT, _InIter>::

      _M_extract_int(_InIter __beg, _InIter __end, ios_base& __io,

                     ios_base::iostate& __err, _ValueT& __v) const

      {

        typedef char_traits<_CharT>                          __traits_type;

        using __gnu_cxx::__add_unsigned;

        typedef typename __add_unsigned<_ValueT>::__type __unsigned_type;

        typedef __numpunct_cache<_CharT>                     __cache_type;

        __use_cache<__cache_type> __uc;

        const locale& __loc = __io._M_getloc();

        const __cache_type* __lc = __uc(__loc);

        const _CharT* __lit = __lc->_M_atoms_in;

        char_type __c = char_type();

        // NB: Iff __basefield == 0, __base can change based on contents.

        const ios_base::fmtflags __basefield = __io.flags()

                                               & ios_base::basefield;

        const bool __oct = __basefield == ios_base::oct;

        int __base = __oct ? 8 : (__basefield == ios_base::hex ? 16 : 10);

        // True if __beg becomes equal to __end.

        bool __testeof = __beg == __end;

        // First check for sign.

        bool __negative = false;

        if (!__testeof)

          {

            __c = *__beg;

            __negative = __c == __lit[__num_base::_S_iminus];

            if ((__negative || __c == __lit[__num_base::_S_iplus])

                && !(__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)

                && !(__c == __lc->_M_decimal_point))

              {

                if (++__beg != __end)

                  __c = *__beg;

                else

                  __testeof = true;

              }

          }

        // Next, look for leading zeros and check required digits

        // for base formats.

        bool __found_zero = false;

        int __sep_pos = 0;

        while (!__testeof)

          {

            if ((__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)

                || __c == __lc->_M_decimal_point)

              break;

            else if (__c == __lit[__num_base::_S_izero]

                     && (!__found_zero || __base == 10))

              {

                __found_zero = true;

                ++__sep_pos;

                if (__basefield == 0)

                  __base = 8;

                if (__base == 8)

                  __sep_pos = 0;

              }

            else if (__found_zero

                     && (__c == __lit[__num_base::_S_ix]

                         || __c == __lit[__num_base::_S_iX]))

              {

                if (__basefield == 0)

                  __base = 16;

                if (__base == 16)

                  {

                    __found_zero = false;

                    __sep_pos = 0;

                  }

                else

                  break;

              }

            else

              break;

            if (++__beg != __end)

              {

                __c = *__beg;

                if (!__found_zero)

                  break;

              }

            else

              __testeof = true;

          }

        // At this point, base is determined. If not hex, only allow

        // base digits as valid input.

        const size_t __len = (__base == 16 ? __num_base::_S_iend

                              - __num_base::_S_izero : __base);

        // Extract.

        string __found_grouping;

        if (__lc->_M_use_grouping)

          __found_grouping.reserve(32);

        bool __testfail = false;

        bool __testoverflow = false;

        const __unsigned_type __max =

          (__negative && __gnu_cxx::__numeric_traits<_ValueT>::__is_signed)

          ? -__gnu_cxx::__numeric_traits<_ValueT>::__min

          : __gnu_cxx::__numeric_traits<_ValueT>::__max;

        const __unsigned_type __smax = __max / __base;

        __unsigned_type __result = 0;

        int __digit = 0;

        const char_type* __lit_zero = __lit + __num_base::_S_izero;

        if (!__lc->_M_allocated)

          // "C" locale

          while (!__testeof)

            {

              __digit = _M_find(__lit_zero, __len, __c);

              if (__digit == -1)

                break;

              if (__result > __smax)

                __testoverflow = true;

              else

                {

                  __result *= __base;

                  __testoverflow |= __result > __max - __digit;

                  __result += __digit;

                  ++__sep_pos;

                }

              if (++__beg != __end)

                __c = *__beg;

              else

                __testeof = true;

            }

        else

          while (!__testeof)

            {

              // According to 22.2.2.1.2, p8-9, first look for thousands_sep

              // and decimal_point.

              if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)

                {

                  // NB: Thousands separator at the beginning of a string

                  // is a no-no, as is two consecutive thousands separators.

                  if (__sep_pos)

                    {

                      __found_grouping += static_cast(__sep_pos);

                      __sep_pos = 0;

                    }

                  else

                    {

                      __testfail = true;

                      break;

                    }

                }

              else if (__c == __lc->_M_decimal_point)

                break;

              else

                {

                  const char_type* __q =

                    __traits_type::find(__lit_zero, __len, __c);

                  if (!__q)

                    break;

                  __digit = __q - __lit_zero;

                  if (__digit > 15)

                    __digit -= 6;

                  if (__result > __smax)

                    __testoverflow = true;

                  else

                    {

                      __result *= __base;

                      __testoverflow |= __result > __max - __digit;

                      __result += __digit;

                      ++__sep_pos;

                    }

                }

              if (++__beg != __end)

                __c = *__beg;

              else

                __testeof = true;

            }

        // Digit grouping is checked. If grouping and found_grouping don't

        // match, then get very very upset, and set failbit.

        if (__found_grouping.size())

          {

            // Add the ending grouping.

            __found_grouping += static_cast(__sep_pos);

            if (!std::__verify_grouping(__lc->_M_grouping,

                                        __lc->_M_grouping_size,

                                        __found_grouping))

              __err = ios_base::failbit;

          }

        // _GLIBCXX_RESOLVE_LIB_DEFECTS

        // 23. Num_get overflow result.

        if ((!__sep_pos && !__found_zero && !__found_grouping.size())

            || __testfail)

          {

            __v = 0;

            __err = ios_base::failbit;

          }

        else if (__testoverflow)

          {

            if (__negative

                && __gnu_cxx::__numeric_traits<_ValueT>::__is_signed)

              __v = __gnu_cxx::__numeric_traits<_ValueT>::__min;

            else

              __v = __gnu_cxx::__numeric_traits<_ValueT>::__max;

            __err = ios_base::failbit;

          }

        else

          __v = __negative ? -__result : __result;

        if (__testeof)

          __err |= ios_base::eofbit;

        return __beg;

      }

  // _GLIBCXX_RESOLVE_LIB_DEFECTS

  // 17.  Bad bool parsing

  template

    _InIter

    num_get<_CharT, _InIter>::

    do_get(iter_type __beg, iter_type __end, ios_base& __io,

           ios_base::iostate& __err, bool& __v) const

    {

      if (!(__io.flags() & ios_base::boolalpha))

        {

          // Parse bool values as long.

          // NB: We can't just call do_get(long) here, as it might

          // refer to a derived class.

          long __l = -1;

          __beg = _M_extract_int(__beg, __end, __io, __err, __l);

          if (__l == 0 || __l == 1)

            __v = bool(__l);

          else

            {

              // _GLIBCXX_RESOLVE_LIB_DEFECTS

              // 23. Num_get overflow result.

              __v = true;

              __err = ios_base::failbit;

              if (__beg == __end)

                __err |= ios_base::eofbit;

            }

        }

      else

        {

          // Parse bool values as alphanumeric.

          typedef __numpunct_cache<_CharT>  __cache_type;

          __use_cache<__cache_type> __uc;

          const locale& __loc = __io._M_getloc();

          const __cache_type* __lc = __uc(__loc);

          bool __testf = true;

          bool __testt = true;

          bool __donef = __lc->_M_falsename_size == 0;

          bool __donet = __lc->_M_truename_size == 0;

          bool __testeof = false;

          size_t __n = 0;

          while (!__donef || !__donet)

            {

              if (__beg == __end)

                {

                  __testeof = true;

                  break;

                }

              const char_type __c = *__beg;

              if (!__donef)

                __testf = __c == __lc->_M_falsename[__n];

              if (!__testf && __donet)

                break;

              if (!__donet)

                __testt = __c == __lc->_M_truename[__n];

              if (!__testt && __donef)

                break;

              if (!__testt && !__testf)

                break;

              ++__n;

              ++__beg;

              __donef = !__testf || __n >= __lc->_M_falsename_size;

              __donet = !__testt || __n >= __lc->_M_truename_size;

            }

          if (__testf && __n == __lc->_M_falsename_size && __n)

            {

              __v = false;

              if (__testt && __n == __lc->_M_truename_size)

                __err = ios_base::failbit;

              else

                __err = __testeof ? ios_base::eofbit : ios_base::goodbit;

            }

          else if (__testt && __n == __lc->_M_truename_size && __n)

            {

              __v = true;

              __err = __testeof ? ios_base::eofbit : ios_base::goodbit;

            }

          else

            {

              // _GLIBCXX_RESOLVE_LIB_DEFECTS

              // 23. Num_get overflow result.

              __v = false;

              __err = ios_base::failbit;

              if (__testeof)

                __err |= ios_base::eofbit;

            }

        }

      return __beg;

    }

  template

    _InIter

    num_get<_CharT, _InIter>::

    do_get(iter_type __beg, iter_type __end, ios_base& __io,

           ios_base::iostate& __err, float& __v) const

    {

      string __xtrc;

      __xtrc.reserve(32);

      __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);

      std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());

      if (__beg == __end)

        __err |= ios_base::eofbit;

      return __beg;

    }

  template

    _InIter

    num_get<_CharT, _InIter>::

    do_get(iter_type __beg, iter_type __end, ios_base& __io,

           ios_base::iostate& __err, double& __v) const

    {

      string __xtrc;

      __xtrc.reserve(32);

      __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);

      std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());

      if (__beg == __end)

        __err |= ios_base::eofbit;

      return __beg;

    }

#if defined _GLIBCXX_LONG_DOUBLE_COMPAT && defined __LONG_DOUBLE_128__

  template

    _InIter

    num_get<_CharT, _InIter>::

    __do_get(iter_type __beg, iter_type __end, ios_base& __io,

             ios_base::iostate& __err, double& __v) const

    {

      string __xtrc;

      __xtrc.reserve(32);

      __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);

      std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());

      if (__beg == __end)

        __err |= ios_base::eofbit;

      return __beg;

    }

#endif

  template

    _InIter

    num_get<_CharT, _InIter>::

    do_get(iter_type __beg, iter_type __end, ios_base& __io,

           ios_base::iostate& __err, long double& __v) const

    {

      string __xtrc;

      __xtrc.reserve(32);

      __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);

      std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());

      if (__beg == __end)

        __err |= ios_base::eofbit;

      return __beg;

    }

  template

    _InIter

    num_get<_CharT, _InIter>::

    do_get(iter_type __beg, iter_type __end, ios_base& __io,

           ios_base::iostate& __err, void*& __v) const

    {

      // Prepare for hex formatted input.

      typedef ios_base::fmtflags        fmtflags;

      const fmtflags __fmt = __io.flags();

      __io.flags((__fmt & ~ios_base::basefield) | ios_base::hex);

      typedef __gnu_cxx::__conditional_type<(sizeof(void*)

                                             <= sizeof(unsigned long)),

        unsigned long, unsigned long long>::__type _UIntPtrType;

      _UIntPtrType __ul;

      __beg = _M_extract_int(__beg, __end, __io, __err, __ul);

      // Reset from hex formatted input.

      __io.flags(__fmt);

      __v = reinterpret_cast(__ul);

      return __beg;

    }

  // For use by integer and floating-point types after they have been

  // converted into a char_type string.

  template

    void

    num_put<_CharT, _OutIter>::

    _M_pad(_CharT __fill, streamsize __w, ios_base& __io,

           _CharT* __new, const _CharT* __cs, int& __len) const

    {

      // [22.2.2.2.2] Stage 3.

      // If necessary, pad.

      __pad<_CharT, char_traits<_CharT> >::_S_pad(__io, __fill, __new,

                                                  __cs, __w, __len);

      __len = static_cast(__w);

    }

_GLIBCXX_END_LDBL_NAMESPACE

  template

    int

    __int_to_char(_CharT* __bufend, _ValueT __v, const _CharT* __lit,

                  ios_base::fmtflags __flags, bool __dec)

    {

      _CharT* __buf = __bufend;

      if (__builtin_expect(__dec, true))

        {

          // Decimal.

          do

            {

              *--__buf = __lit[(__v % 10) + __num_base::_S_odigits];

              __v /= 10;

            }

          while (__v != 0);

        }

      else if ((__flags & ios_base::basefield) == ios_base::oct)

        {

          // Octal.

          do

            {

              *--__buf = __lit[(__v & 0x7) + __num_base::_S_odigits];

              __v >>= 3;

            }

          while (__v != 0);

        }

      else

        {

          // Hex.

          const bool __uppercase = __flags & ios_base::uppercase;

          const int __case_offset = __uppercase ? __num_base::_S_oudigits

                                                : __num_base::_S_odigits;

          do

            {

              *--__buf = __lit[(__v & 0xf) + __case_offset];

              __v >>= 4;

            }

          while (__v != 0);

        }

      return __bufend - __buf;

    }

_GLIBCXX_BEGIN_LDBL_NAMESPACE

  template

    void

    num_put<_CharT, _OutIter>::

    _M_group_int(const char* __grouping, size_t __grouping_size, _CharT __sep,

                 ios_base&, _CharT* __new, _CharT* __cs, int& __len) const

    {

      _CharT* __p = std::__add_grouping(__new, __sep, __grouping,

                                        __grouping_size, __cs, __cs + __len);

      __len = __p - __new;

    }

  template

    template

      _OutIter

      num_put<_CharT, _OutIter>::

      _M_insert_int(_OutIter __s, ios_base& __io, _CharT __fill,

                    _ValueT __v) const

      {

        using __gnu_cxx::__add_unsigned;

        typedef typename __add_unsigned<_ValueT>::__type __unsigned_type;

        typedef __numpunct_cache<_CharT>                     __cache_type;

        __use_cache<__cache_type> __uc;

        const locale& __loc = __io._M_getloc();

        const __cache_type* __lc = __uc(__loc);

        const _CharT* __lit = __lc->_M_atoms_out;

        const ios_base::fmtflags __flags = __io.flags();

        // Long enough to hold hex, dec, and octal representations.

        const int __ilen = 5 * sizeof(_ValueT);

        _CharT* __cs = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)

                                                             * __ilen));

        // [22.2.2.2.2] Stage 1, numeric conversion to character.

        // Result is returned right-justified in the buffer.

        const ios_base::fmtflags __basefield = __flags & ios_base::basefield;

        const bool __dec = (__basefield != ios_base::oct

                            && __basefield != ios_base::hex);

        const __unsigned_type __u = ((__v > 0 || !__dec)

                                     ? __unsigned_type(__v)

                                     : -__unsigned_type(__v));

        int __len = __int_to_char(__cs + __ilen, __u, __lit, __flags, __dec);

        __cs += __ilen - __len;

        // Add grouping, if necessary.

        if (__lc->_M_use_grouping)

          {

            // Grouping can add (almost) as many separators as the number

            // of digits + space is reserved for numeric base or sign.

            _CharT* __cs2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)

                                                                  * (__len + 1)

                                                                  * 2));

            _M_group_int(__lc->_M_grouping, __lc->_M_grouping_size,

                         __lc->_M_thousands_sep, __io, __cs2 + 2, __cs, __len);

            __cs = __cs2 + 2;

          }

        // Complete Stage 1, prepend numeric base or sign.

        if (__builtin_expect(__dec, true))

          {

            // Decimal.

            if (__v >= 0)

              {

                if (bool(__flags & ios_base::showpos)

                    && __gnu_cxx::__numeric_traits<_ValueT>::__is_signed)

                  *--__cs = __lit[__num_base::_S_oplus], ++__len;

              }

            else

              *--__cs = __lit[__num_base::_S_ominus], ++__len;

          }

        else if (bool(__flags & ios_base::showbase) && __v)

          {

            if (__basefield == ios_base::oct)

              *--__cs = __lit[__num_base::_S_odigits], ++__len;

            else

              {

                // 'x' or 'X'

                const bool __uppercase = __flags & ios_base::uppercase;

                *--__cs = __lit[__num_base::_S_ox + __uppercase];

                // '0'

                *--__cs = __lit[__num_base::_S_odigits];

                __len += 2;

              }

          }

        // Pad.

        const streamsize __w = __io.width();

        if (__w > static_cast(__len))

          {

            _CharT* __cs3 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)

                                                                  * __w));

            _M_pad(__fill, __w, __io, __cs3, __cs, __len);

            __cs = __cs3;

          }

        __io.width(0);

        // [22.2.2.2.2] Stage 4.

        // Write resulting, fully-formatted string to output iterator.

        return std::__write(__s, __cs, __len);

      }

  template

    void

    num_put<_CharT, _OutIter>::

    _M_group_float(const char* __grouping, size_t __grouping_size,