num_get_float.cpp File Reference

#include "stlport_prefix.h"
#include <limits>
#include <locale>
#include <istream>

Include dependency graph for num_get_float.cpp:

Go to the source code of this file.

Classes
union	_Double_rep

Macros
#define	bit11   ULL(0x7ff)
#define	exponent_mask   (bit11 << 52)
#define	TEN_1   0 /* offset to 10 ** 1 */
#define	TEN_27   26 /* offset to 10 ** 27 */
#define	TEN_M28   37 /* offset to 10 ** -28 */
#define	NUM_HI_P   11
#define	NUM_HI_N   13
#define	_Stl_HIBITULL   (ULL(1) << 63)

Functions
_STLP_BEGIN_NAMESPACE _STLP_MOVE_TO_PRIV_NAMESPACE void _STLP_CALL	_Initialize_get_float (const ctype< wchar_t > &ct, wchar_t &Plus, wchar_t &Minus, wchar_t &pow_e, wchar_t &pow_E, wchar_t *digits)
static void	_Stl_mult64 (const uint64 u, const uint64 v, uint64 &high, uint64 &low)
void	_Stl_set_exponent (uint64 &val, uint64 exp)
static void	_Stl_norm_and_round (uint64 &p, int &norm, uint64 prodhi, uint64 prodlo)
static void	_Stl_tenscale (uint64 &p, int exp, int &bexp)
static double	_Stl_atod (char *buffer, ptrdiff_t ndigit, int dexp)
static double	_Stl_string_to_double (const char *s)
void _STLP_CALL	__string_to_float (const __iostring &v, float &val)
void _STLP_CALL	__string_to_float (const __iostring &v, double &val)
void _STLP_CALL	__string_to_float (const __iostring &v, long double &val)

Variables
static const uint64	_Stl_tenpow [80]
static const short	_Stl_twoexp [80]

Macro Definition Documentation

_Stl_HIBITULL

#define _Stl_HIBITULL   (ULL(1) << 63)

Definition at line 229 of file num_get_float.cpp.

bit11

#define bit11   ULL(0x7ff)

Definition at line 140 of file num_get_float.cpp.

exponent_mask

#define exponent_mask   (bit11 << 52)

Definition at line 141 of file num_get_float.cpp.

NUM_HI_N

#define NUM_HI_N   13

Definition at line 227 of file num_get_float.cpp.

NUM_HI_P

#define NUM_HI_P   11

Definition at line 226 of file num_get_float.cpp.

TEN_1

#define TEN_1   0 /* offset to 10 ** 1 */

Definition at line 223 of file num_get_float.cpp.

TEN_27

#define TEN_27   26 /* offset to 10 ** 27 */

Definition at line 224 of file num_get_float.cpp.

TEN_M28

#define TEN_M28   37 /* offset to 10 ** -28 */

Definition at line 225 of file num_get_float.cpp.

Function Documentation

__string_to_float() [1/3]

void _STLP_CALL __string_to_float	(	const __iostring &	v,
		double &	val
	)

Definition at line 855 of file num_get_float.cpp.

{
#if !defined (__linux__)
  val = _Stl_string_to_double(v.c_str());
#else
  val = _Stl_string_to_doubleT<double,ieee754_double,12,IEEE754_DOUBLE_BIAS>(v.c_str());
#endif
}

__string_to_float() [2/3]

void _STLP_CALL __string_to_float	(	const __iostring &	v,
		float &	val
	)

Definition at line 845 of file num_get_float.cpp.

{
#if !defined (__linux__)
  val = (float)_Stl_string_to_double(v.c_str());
#else
  val = (float)_Stl_string_to_doubleT<double,ieee754_double,12,IEEE754_DOUBLE_BIAS>(v.c_str());
#endif
}

Referenced by __do_get_float().

__string_to_float() [3/3]

void _STLP_CALL __string_to_float	(	const __iostring &	v,
		long double &	val
	)

Definition at line 866 of file num_get_float.cpp.

                                                         {
#if !defined (__linux__) && !defined (__MINGW32__) && !defined (__CYGWIN__) && \
    !defined (__BORLANDC__) && !defined (__DMC__) && !defined (__HP_aCC)
  //The following function is valid only if long double is an alias for double.
  _STLP_STATIC_ASSERT( sizeof(long double) <= sizeof(double) )
  val = _Stl_string_to_double(v.c_str());
#else
  val = _Stl_string_to_doubleT<long double,ieee854_long_double,16,IEEE854_LONG_DOUBLE_BIAS>(v.c_str());
#endif
}

_Initialize_get_float()

_STLP_BEGIN_NAMESPACE _STLP_MOVE_TO_PRIV_NAMESPACE void _STLP_CALL _Initialize_get_float	(	const ctype< wchar_t > &	ct,
		wchar_t &	Plus,
		wchar_t &	Minus,
		wchar_t &	pow_e,
		wchar_t &	pow_E,
		wchar_t *	digits
	)

Definition at line 83 of file num_get_float.cpp.

                                        {
  char ndigits[11] = "0123456789";
  Plus  = ct.widen('+');
  Minus = ct.widen('-');
  pow_e = ct.widen('e');
  pow_E = ct.widen('E');
  ct.widen(ndigits + 0, ndigits + 10, digits);
}

Referenced by __read_float().

_Stl_atod()

static double _Stl_atod ( char *  buffer, ptrdiff_t  ndigit, int  dexp  )

static

Definition at line 333 of file num_get_float.cpp.

                                                                  {
  typedef numeric_limits<double> limits;
  _Double_rep drep;
  uint64 &value = drep.ival;  /* Value develops as follows:
                                 * 1) decimal digits as an integer
                                 * 2) left adjusted fraction
                                 * 3) right adjusted fraction
                                 * 4) exponent and fraction
                                 */
 
  uint32 guard;         /* First guard bit */
  uint64 rest;          /* Remaining guard bits */
 
  int bexp;             /* binary exponent */
  int nzero;            /* number of non-zero bits */
  int sexp;             /* scaling exponent */
 
  char *bufferend;              /* pointer to char after last digit */
 
  /* Convert the decimal digits to a binary integer. */
  bufferend = buffer + ndigit;
  value = 0;
 
  while (buffer < bufferend) {
    value *= 10;
    value += *buffer++;
  }
 
  /* Check for zero and treat it as a special case */
  if (value == 0) {
    return 0.0;
  }
 
  /* Normalize value */
  bexp = 64;                    /* convert from 64b int to fraction */
 
  /* Count number of non-zeroes in value */
  nzero = 0;
  if ((value >> 32) != 0) { nzero  = 32; }    //*TY 03/25/2000 - added explicit comparison to zero to avoid uint64 to bool conversion operator
  if ((value >> (16 + nzero)) != 0) { nzero += 16; }
  if ((value >> ( 8 + nzero)) != 0) { nzero +=  8; }
  if ((value >> ( 4 + nzero)) != 0) { nzero +=  4; }
  if ((value >> ( 2 + nzero)) != 0) { nzero +=  2; }
  if ((value >> ( 1 + nzero)) != 0) { nzero +=  1; }
  if ((value >> (     nzero)) != 0) { nzero +=  1; }
 
  /* Normalize */
  value <<= /*(uint64)*/ (64 - nzero);    //*TY 03/25/2000 - removed extraneous cast to uint64
  bexp -= 64 - nzero;
 
  /* At this point we have a 64b fraction and a binary exponent
   * but have yet to incorporate the decimal exponent.
   */
 
  /* multiply by 10^dexp */
  _Stl_tenscale(value, dexp, sexp);
  bexp += sexp;
 
  if (bexp <= -1022) {          /* HI denorm or underflow */
    bexp += 1022;
    if (bexp < -53) {          /* guaranteed underflow */
      value = 0;
    }
    else {                      /* denorm or possible underflow */
      int lead0 = 12 - bexp;          /* 12 sign and exponent bits */
 
      /* we must special case right shifts of more than 63 */
      if (lead0 > 64) {
        rest = value;
        guard = 0;
        value = 0;
      }
      else if (lead0 == 64) {
        rest = value & ((ULL(1)<< 63)-1);
        guard = (uint32) ((value>> 63) & 1 );
        value = 0;
      }
      else {
        rest = value & (((ULL(1) << lead0)-1)-1);
        guard = (uint32) (((value>> lead0)-1) & 1);
        value >>= /*(uint64)*/ lead0; /* exponent is zero */
      }
 
      /* Round */
      if (guard && ((value & 1) || rest) ) {
        ++value;
        if (value == (ULL(1) << (limits::digits - 1))) { /* carry created normal number */
          value = 0;
          _Stl_set_exponent(value, 1);
        }
      }
    }
  }
  else {                        /* not zero or denorm */
    /* Round to 53 bits */
    rest = value & ((1 << 10) - 1);
    value >>= 10;
    guard = (uint32) value & 1;
    value >>= 1;
 
    /*  value&1 guard   rest    Action
     *
     *  dc      0       dc      none
     *  1       1       dc      round
     *  0       1       0       none
     *  0       1       !=0     round
     */
    if (guard) {
      if (((value&1)!=0) || (rest!=0)) {
        ++value;                        /* round */
        if ((value >> 53) != 0) {       /* carry all the way across */
          value >>= 1;          /* renormalize */
          ++bexp;
        }
      }
    }
    /*
     * Check for overflow
     * IEEE Double Precision Format
     * (From Table 7-8 of Kane and Heinrich)
     *
     * Fraction bits               52
     * Emax                     +1023
     * Emin                     -1022
     * Exponent bias            +1023
     * Exponent bits               11
     * Integer bit             hidden
     * Total width in bits         64
     */
 
    if (bexp > limits::max_exponent) {          /* overflow */
      return limits::infinity();
    }
    else {                      /* value is normal */
      value &= ~(ULL(1) << (limits::digits - 1));   /* hide hidden bit */
      _Stl_set_exponent(value, bexp + 1022); /* add bias */
    }
  }
 
  _STLP_STATIC_ASSERT(sizeof(uint64) >= sizeof(double))
  return drep.val;
}

Referenced by _Stl_string_to_double().

_Stl_mult64()

static void _Stl_mult64 ( const uint64  u, const uint64  v, uint64 &  high, uint64 &  low  )

static

Definition at line 118 of file num_get_float.cpp.

                                                   {
  const uint64 low_mask = ULL(0xffffffff);
  const uint64 u0 = u & low_mask;
  const uint64 u1 = u >> 32;
  const uint64 v0 = v & low_mask;
  const uint64 v1 = v >> 32;
 
  uint64 t = u0 * v0;
  low = t & low_mask;
 
  t = u1 * v0 + (t >> 32);
  uint64 w1 = t & low_mask;
  uint64 w2 = t >> 32;
 
  uint64 x = u0 * v1 + w1;
  low += (x & low_mask) << 32;
  high = u1 * v1 + w2 + (x >> 32);
}

Referenced by _Stl_tenscale().

_Stl_norm_and_round()

static void _Stl_norm_and_round ( uint64 &  p, int &  norm, uint64  prodhi, uint64  prodlo  )

static

Definition at line 231 of file num_get_float.cpp.

                                                                                    {
  norm = 0;
  if ((prodhi & _Stl_HIBITULL) == 0) {
                                /* leading bit is a zero
                                 * may have to normalize
                                 */
    if ((prodhi == ~_Stl_HIBITULL) &&
        ((prodlo >> 62) == 0x3)) {  /* normalization followed by round
                                     * would cause carry to create
                                     * extra bit, so don't normalize
                                     */
      p = _Stl_HIBITULL;
      return;
    }
    p = (prodhi << 1) | (prodlo >> 63); /* normalize */
    norm = 1;
    prodlo <<= 1;
  }
  else {
    p = prodhi;
  }
 
  if ((prodlo & _Stl_HIBITULL) != 0) {     /* first guard bit a one */
    if (((p & 0x1) != 0) ||
        prodlo != _Stl_HIBITULL ) {    /* not borderline for round to even */
      /* round */
      ++p;
      if (p == 0)
        ++p;
    }
  }
}

Referenced by _Stl_tenscale().

_Stl_set_exponent()

void _Stl_set_exponent ( uint64 &  val, uint64  exp  )

inline

Definition at line 148 of file num_get_float.cpp.

{ val = (val & ~exponent_mask) | ((exp & bit11) << 52); }

Referenced by _Stl_atod().

_Stl_string_to_double()

static double _Stl_string_to_double ( const char *  s )

static

Definition at line 644 of file num_get_float.cpp.

                                                   {
  typedef numeric_limits<double> limits;
  const int max_digits = limits::digits10 + 2;
  unsigned c;
  unsigned Negate, decimal_point;
  char *d;
  int exp;
  int dpchar;
  char digits[max_digits];
 
  c = *s++;
 
  /* process sign */
  Negate = 0;
  if (c == '+') {
    c = *s++;
  } else if (c == '-') {
    Negate = 1;
    c = *s++;
  }
 
  d = digits;
  dpchar = '.' - '0';
  decimal_point = 0;
  exp = 0;
 
  for (;;) {
    c -= '0';
    if (c < 10) {
      if (d == digits + max_digits) {
        /* ignore more than max_digits digits, but adjust exponent */
        exp += (decimal_point ^ 1);
      } else {
        if (c == 0 && d == digits) {
          /* ignore leading zeros */
        } else {
          *d++ = (char) c;
        }
        exp -= decimal_point;
      }
    } else if (c == (unsigned int) dpchar && !decimal_point) { /* INTERNATIONAL */
      decimal_point = 1;
    } else {
      break;
    }
    c = *s++;
  }
 
  /* strtod cant return until it finds the end of the exponent */
  if (d == digits) {
    return 0.0;
  }
 
  if (c == 'e' - '0' || c == 'E' - '0') {
    register unsigned negate_exp = 0;
    register int e = 0;
    c = *s++;
    if (c == '+' || c == ' ') {
      c = *s++;
    } else if (c == '-') {
      negate_exp = 1;
      c = *s++;
    }
    if (c -= '0', c < 10) {
      do {
        e = e * 10 + (int)c;
        c = *s++;
      } while (c -= '0', c < 10);
 
      if (negate_exp) {
        e = -e;
      }
      exp += e;
    }
  }
 
  double x;
  ptrdiff_t n = d - digits;
  if ((exp + n - 1) < limits::min_exponent10) {
    x = 0;
  }
  else if ((exp + n - 1) > limits::max_exponent10) {
    x = limits::infinity();
  }
  else {
    /* Let _Stl_atod diagnose under- and over-flows.
     * If the input was == 0.0, we have already returned,
     * so retval of +-Inf signals OVERFLOW, 0.0 UNDERFLOW */
    x = _Stl_atod(digits, n, exp);
  }
 
  if (Negate) {
    x = -x;
  }
 
  return x;
}

Referenced by __string_to_float().

_Stl_tenscale()

static void _Stl_tenscale ( uint64 &  p, int  exp, int &  bexp  )

static

Definition at line 268 of file num_get_float.cpp.

                                                         {
  bexp = 0;
 
  if ( exp == 0 ) {              /* no scaling needed */
    return;
  }
 
  int exp_hi = 0, exp_lo = exp; /* exp = exp_hi*32 + exp_lo */
  int tlo = TEN_1, thi;         /* offsets in power of ten table */
  int num_hi;                   /* number of high exponent powers */
 
  if (exp > 0) {                /* split exponent */
    if (exp_lo > 27) {
      exp_lo++;
      while (exp_lo > 27) {
        exp_hi++;
        exp_lo -= 28;
      }
    }
    thi = TEN_27;
    num_hi = NUM_HI_P;
  } else { // exp < 0
    while (exp_lo < 0) {
      exp_hi++;
      exp_lo += 28;
    }
    thi = TEN_M28;
    num_hi = NUM_HI_N;
  }
 
  uint64 prodhi, prodlo;        /* 128b product */
  int norm;                     /* number of bits of normalization */
 
  int hi, lo;                   /* offsets in power of ten table */
  while (exp_hi) {              /* scale */
    hi = (min) (exp_hi, num_hi);    /* only a few large powers of 10 */
    exp_hi -= hi;               /* could iterate in extreme case */
    hi += thi-1;
    _Stl_mult64(p, _Stl_tenpow[hi], prodhi, prodlo);
    _Stl_norm_and_round(p, norm, prodhi, prodlo);
    bexp += _Stl_twoexp[hi] - norm;
  }
 
  if (exp_lo) {
    lo = tlo + exp_lo -1;
    _Stl_mult64(p, _Stl_tenpow[lo], prodhi, prodlo);
    _Stl_norm_and_round(p, norm, prodhi, prodlo);
    bexp += _Stl_twoexp[lo] - norm;
  }
 
  return;
}

Referenced by _Stl_atod().

Variable Documentation

_Stl_tenpow

const uint64 _Stl_tenpow[80]

static

Definition at line 159 of file num_get_float.cpp.

Referenced by _Stl_tenscale().

_Stl_twoexp

const short _Stl_twoexp[80]

static

Initial value:

= {
4,7,10,14,17,20,24,27,30,34,37,40,44,47,50,54,57,60,64,67,70,74,77,80,84,87,90,
183,276,369,462,555,648,741,834,927,1020,
-93,-186,-279,-372,-465,-558,-651,-744,-837,-930,-1023,-1116,-1209
}

Definition at line 217 of file num_get_float.cpp.

Referenced by _Stl_tenscale().