_M_insert_float() [1/2]

template<typename _CharT, typename _OutIter>

template<typename _ValueT>

_OutIter std::num_put< _CharT, _OutIter >::_M_insert_float	(	_OutIter	__s,
		ios_base &	__io,
		_CharT	__fill,
		char	__mod,
		_ValueT	__v ) const

Definition at line 999 of file locale_facets.tcc.

      {
      typedef __numpunct_cache<_CharT>                __cache_type;
      __use_cache<__cache_type> __uc;
      const locale& __loc = __io._M_getloc();
      const __cache_type* __lc = __uc(__loc);
 
      // Use default precision if out of range.
      const streamsize __prec = __io.precision() < 0 ? 6 : __io.precision();
 
      const int __max_digits =
        __gnu_cxx::__numeric_traits<_ValueT>::__digits10;
 
      // [22.2.2.2.2] Stage 1, numeric conversion to character.
      int __len;
      // Long enough for the max format spec.
      char __fbuf[16];
      __num_base::_S_format_float(__io, __fbuf, __mod);
 
#if _GLIBCXX_USE_C99_STDIO && !_GLIBCXX_HAVE_BROKEN_VSNPRINTF
      // Precision is always used except for hexfloat format.
      const bool __use_prec =
        (__io.flags() & ios_base::floatfield) != ios_base::floatfield;
 
      // First try a buffer perhaps big enough (most probably sufficient
      // for non-ios_base::fixed outputs)
      int __cs_size = __max_digits * 3;
      char* __cs = static_cast<char*>(__builtin_alloca(__cs_size));
      if (__use_prec)
        __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
                              __fbuf, __prec, __v);
      else
        __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
                              __fbuf, __v);
 
      // If the buffer was not large enough, try again with the correct size.
      if (__len >= __cs_size)
        {
          __cs_size = __len + 1;
          __cs = static_cast<char*>(__builtin_alloca(__cs_size));
          if (__use_prec)
            __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
                                  __fbuf, __prec, __v);
          else
            __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
                                  __fbuf, __v);
        }
#else
      // Consider the possibility of long ios_base::fixed outputs
      const bool __fixed = __io.flags() & ios_base::fixed;
      const int __max_exp =
        __gnu_cxx::__numeric_traits<_ValueT>::__max_exponent10;
 
      // The size of the output string is computed as follows.
      // ios_base::fixed outputs may need up to __max_exp + 1 chars
      // for the integer part + __prec chars for the fractional part
      // + 3 chars for sign, decimal point, '\0'. On the other hand,
      // for non-fixed outputs __max_digits * 2 + __prec chars are
      // largely sufficient.
      const int __cs_size = __fixed ? __max_exp + __prec + 4
                                    : __max_digits * 2 + __prec;
      char* __cs = static_cast<char*>(__builtin_alloca(__cs_size));
      __len = std::__convert_from_v(_S_get_c_locale(), __cs, 0, __fbuf, 
                              __prec, __v);
#endif
 
      // [22.2.2.2.2] Stage 2, convert to char_type, using correct
      // numpunct.decimal_point() values for '.' and adding grouping.
      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
      
      _CharT* __ws = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
                                               * __len));
      __ctype.widen(__cs, __cs + __len, __ws);
      
      // Replace decimal point.
      _CharT* __wp = 0;
      const char* __p = char_traits<char>::find(__cs, __len, '.');
      if (__p)
        {
          __wp = __ws + (__p - __cs);
          *__wp = __lc->_M_decimal_point;
        }
      
      // Add grouping, if necessary.
      // N.B. Make sure to not group things like 2e20, i.e., no decimal
      // point, scientific notation.
      if (__lc->_M_use_grouping
          && (__wp || __len < 3 || (__cs[1] <= '9' && __cs[2] <= '9'
                              && __cs[1] >= '0' && __cs[2] >= '0')))
        {
          // Grouping can add (almost) as many separators as the
          // number of digits, but no more.
          _CharT* __ws2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
                                                  * __len * 2));
          
          streamsize __off = 0;
          if (__cs[0] == '-' || __cs[0] == '+')
            {
            __off = 1;
            __ws2[0] = __ws[0];
            __len -= 1;
            }
          
          _M_group_float(__lc->_M_grouping, __lc->_M_grouping_size,
                     __lc->_M_thousands_sep, __wp, __ws2 + __off,
                     __ws + __off, __len);
          __len += __off;
          
          __ws = __ws2;
        }
 
      // Pad.
      const streamsize __w = __io.width();
      if (__w > static_cast<streamsize>(__len))
        {
          _CharT* __ws3 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
                                                  * __w));
          _M_pad(__fill, __w, __io, __ws3, __ws, __len);
          __ws = __ws3;
        }
      __io.width(0);
      
      // [22.2.2.2.2] Stage 4.
      // Write resulting, fully-formatted string to output iterator.
      return std::__write(__s, __ws, __len);
      }