num_put_float.cpp File Reference

#include "stlport_prefix.h"
#include <cmath>
#include <ios>
#include <locale>
#include <cstdio>
#include <cstdlib>
#include <algorithm>

Include dependency graph for num_put_float.cpp:

Go to the source code of this file.

Classes
struct	_Dig< N >
struct	_Dig< 0 >
struct	GroupPos

Macros
#define	NDIG   82
#define	todigit(x)   ((x)+'0')
#define	MAXEDIGITS   int(_Dig<LDBL_MAX_10_EXP>::dig)
#define	MAXFSIG   LDBL_DIG
#define	MAXFCVT   (LDBL_DIG + 1)
#define	USE_SPRINTF_INSTEAD

Functions
static void	__fill_fmtbuf (char *fmtbuf, ios_base::fmtflags flags, char long_modifier)
template<class _FloatT >
static size_t	__write_floatT (__iostring &buf, ios_base::fmtflags flags, int precision, _FloatT x, char modifier)
size_t _STLP_CALL	__write_float (__iostring &buf, ios_base::fmtflags flags, int precision, double x)
size_t _STLP_CALL	__write_float (__iostring &buf, ios_base::fmtflags flags, int precision, long double x)
void _STLP_CALL	__get_floor_digits (__iostring &out, _STLP_LONGEST_FLOAT_TYPE __x)
void _STLP_CALL	__convert_float_buffer (__iostring const &str, __iowstring &out, const ctype< wchar_t > &ct, wchar_t dot, bool __check_dot)
void _STLP_CALL	__adjust_float_buffer (__iostring &str, char dot)

Macro Definition Documentation

MAXEDIGITS

#define MAXEDIGITS   int(_Dig<LDBL_MAX_10_EXP>::dig)

Definition at line 116 of file num_put_float.cpp.

MAXFCVT

#define MAXFCVT   (LDBL_DIG + 1)

Definition at line 118 of file num_put_float.cpp.

MAXFSIG

#define MAXFSIG   LDBL_DIG

Definition at line 117 of file num_put_float.cpp.

NDIG

#define NDIG   82

Definition at line 28 of file num_put_float.cpp.

todigit

#define todigit

(

x

)

((x)+'0')

Definition at line 31 of file num_put_float.cpp.

USE_SPRINTF_INSTEAD

#define USE_SPRINTF_INSTEAD

Definition at line 206 of file num_put_float.cpp.

Function Documentation

__adjust_float_buffer()

void _STLP_CALL __adjust_float_buffer	(	__iostring &	str,
		char	dot
	)

Definition at line 904 of file num_put_float.cpp.

                                                 {
  if ('.' != dot) {
    size_t __dot_pos = str.find('.');
    if (__dot_pos != string::npos) {
      str[__dot_pos] = dot;
    }
  }
}

__convert_float_buffer()

void _STLP_CALL __convert_float_buffer	(	__iostring const &	str,
		__iowstring &	out,
		const ctype< wchar_t > &	ct,
		wchar_t	dot,
		bool	__check_dot
	)

Definition at line 873 of file num_put_float.cpp.

                                                                                                 {
  string::const_iterator str_ite(str.begin()), str_end(str.end());
 
  //First loop, check the dot char
  if (__check_dot) {
    while (str_ite != str_end) {
      if (*str_ite != '.') {
        out += ct.widen(*str_ite++);
      } else {
        out += dot;
        break;
      }
    }
  } else {
    if (str_ite != str_end) {
      out += ct.widen(*str_ite);
    }
  }
 
  if (str_ite != str_end) {
    //Second loop, dot has been found, no check anymore
    while (++str_ite != str_end) {
      out += ct.widen(*str_ite);
    }
  }
}

Referenced by __get_money_digits_aux(), and __put_float().

__fill_fmtbuf()

static void __fill_fmtbuf ( char *  fmtbuf, ios_base::fmtflags  flags, char  long_modifier  )

static

Definition at line 709 of file num_put_float.cpp.

                                                                                    {
  fmtbuf[0] = '%';
  int i = 1;
 
  if (flags & ios_base::showpos)
    fmtbuf[i++] = '+';
 
  if (flags & ios_base::showpoint)
    fmtbuf[i++] = '#';
 
  fmtbuf[i++] = '.';
  fmtbuf[i++] = '*';
 
  if (long_modifier)
    fmtbuf[i++] = long_modifier;
 
  switch (flags & ios_base::floatfield)
    {
    case ios_base::scientific:
      fmtbuf[i++] = (flags & ios_base::uppercase) ?  'E' : 'e';
      break;
    case ios_base::fixed:
#  if defined (__FreeBSD__)
      fmtbuf[i++] = 'f';
#  else
      fmtbuf[i++] = (flags & ios_base::uppercase) ? 'F' : 'f';
#  endif
      break;
    default:
      fmtbuf[i++] = (flags & ios_base::uppercase) ?  'G' : 'g';
      break;
    }
 
  fmtbuf[i] = 0;
}

Referenced by __write_floatT().

__get_floor_digits()

void _STLP_CALL __get_floor_digits	(	__iostring &	out,
		_STLP_LONGEST_FLOAT_TYPE	__x
	)

Definition at line 843 of file num_put_float.cpp.

                                                                                  {
  typedef numeric_limits<_STLP_LONGEST_FLOAT_TYPE> limits;
#if defined (USE_SPRINTF_INSTEAD)
  char cvtbuf[limits::max_exponent10 + 6];
#  if !defined (_STLP_NO_LONG_DOUBLE)
  snprintf(_STLP_ARRAY_AND_SIZE(cvtbuf), "%Lf", __x); // check for 1234.56!
#  else
  snprintf(_STLP_ARRAY_AND_SIZE(cvtbuf), "%f", __x);  // check for 1234.56!
#  endif
  char *p = strchr( cvtbuf, '.' );
  if ( p == 0 ) {
    out.append( cvtbuf );
  } else {
    out.append( cvtbuf, p );
  }
#else
  char cvtbuf[limits::max_exponent10 + 1];
  char * bp;
  int decpt, sign;
  bp = _Stl_fcvtR(__x, 0, &decpt, &sign, _STLP_CVT_BUFFER(cvtbuf));
 
  if (sign) {
    out += '-';
  }
  out.append(bp, bp + decpt);
#endif
}

Referenced by __get_money_digits_aux().

__write_float() [1/2]

size_t _STLP_CALL __write_float	(	__iostring &	buf,
		ios_base::fmtflags	flags,
		int	precision,
		double	x
	)

Definition at line 822 of file num_put_float.cpp.

                        {
  return __write_floatT(buf, flags, precision, x
#if defined (USE_SPRINTF_INSTEAD)
                                               , 0
#endif
                                                  );
}

Referenced by __do_put_float().

__write_float() [2/2]

size_t _STLP_CALL __write_float	(	__iostring &	buf,
		ios_base::fmtflags	flags,
		int	precision,
		long double	x
	)

Definition at line 833 of file num_put_float.cpp.

                             {
  return __write_floatT(buf, flags, precision, x
#if defined (USE_SPRINTF_INSTEAD)
                                               , 'L'
#endif
                                                    );
}

__write_floatT()

template<class _FloatT >

static size_t __write_floatT ( __iostring &  buf, ios_base::fmtflags  flags, int  precision, _FloatT  x, char  modifier  )

static

Definition at line 748 of file num_put_float.cpp.

                                               {
  /* In theory, if we want 'arbitrary' precision, we should use 'arbitrary'
   * buffer size below, but really we limited by exponent part in double.
   *    - ptr
   */
  typedef numeric_limits<_FloatT> limits;
  char static_buf[limits::max_exponent10 + 6]; // 6: -xxx.yyyE-zzz (sign, dot, E, exp sign, \0)
  char fmtbuf[32];
  __fill_fmtbuf(fmtbuf, flags, modifier);
  snprintf(_STLP_ARRAY_AND_SIZE(static_buf), fmtbuf, precision, x);
  buf = static_buf;
  return find_if(buf.begin(), buf.end(), GroupPos()) - buf.begin();
#else
                              ) {
  typedef numeric_limits<_FloatT> limits;
  //If numeric_limits support is correct we use the exposed values to detect NaN and infinity:
  if (limits::has_infinity && limits::has_quiet_NaN) {
    if (!(x == x) || // NaN check
        (x == limits::infinity() || x == -limits::infinity())) {
      return __format_nan_or_inf(buf, x, flags);
    }
  }
  // numeric_limits support is not good enough, we rely on platform dependent function
  // _Stl_is_nan_or_inf that do not support long double.
  else if (_Stl_is_nan_or_inf(x)) {
    return __format_nan_or_inf(buf, x, flags);
  }
#  if defined (__MINGW32__)
  //For the moment MinGW is limited to display at most numeric_limits<double>::max()
  if (x > numeric_limits<double>::max() ||
      x < -numeric_limits<double>::max()) {
    return __format_nan_or_inf(buf, x, flags);
  }
#  endif
 
  /* Buffer size is max number of digits which is the addition of:
   * - max_exponent10: max number of digits in fixed mode
   * - digits10 + 2: max number of significant digits
   * - trailing '\0'
   */
  char cvtbuf[limits::max_exponent10 + limits::digits10 + 2 + 1];
  char *bp;
  int decpt, sign;
 
  switch (flags & ios_base::floatfield) {
  case ios_base::fixed:
    {
      /* Here, number of digits represents digits _after_ decimal point.
       * In order to limit static buffer size we have to give 2 different values depending on x value.
       * For small values (abs(x) < 1) we need as many digits as requested by precision limited by the maximum number of digits
       * which is min_exponent10 + digits10 + 2
       * For bigger values we won't have more than limits::digits10 + 2 digits after decimal point. */
      int digits10 = (x > -1.0 && x < 1.0 ? -limits::min_exponent10 + limits::digits10 + 2
                                          : limits::digits10 + 2);
      bp = _Stl_fcvtR(x, (min) (precision, digits10), &decpt, &sign, _STLP_CVT_BUFFER(cvtbuf) );
    }
    break;
  case ios_base::scientific:
  default:
    /* Here, number of digits is total number of digits which is limited to digits10 + 2. */
    {
      int digits10 = limits::digits10 + 2;
      bp = _Stl_ecvtR(x, (min) (precision, digits10), &decpt, &sign, _STLP_CVT_BUFFER(cvtbuf) );
    }
    break;
  }
  return __format_float(buf, bp, decpt, sign, x == 0.0, flags, precision);
#endif
}

Referenced by __write_float().