WebSVN – Kolibri OS – Diff – /contrib/sdk/sources/newlib/libc/stdlib/strtod.c

 INDEX
 	strtof
 ANSI_SYNOPSIS
         #include
-        double strtod(const char *<[str]>, char **<[tail]>);
+        double strtod(const char *restrict <[str]>, char **restrict <[tail]>);
-        float strtof(const char *<[str]>, char **<[tail]>);
+        float strtof(const char *restrict <[str]>, char **restrict <[tail]>);
         double _strtod_r(void *<[reent]>,
-                         const char *<[str]>, char **<[tail]>);
+                         const char *restrict <[str]>, char **restrict <[tail]>);
 TRAD_SYNOPSIS
 #ifdef IEEE_Arith
 #ifndef NO_IEEE_Scale
 #define Avoid_Underflow
 #undef tinytens
-/* The factor of 2^53 in tinytens[4] helps us avoid setting the underflow */
+/* The factor of 2^106 in tinytens[4] helps us avoid setting the underflow */
 /* flag unnecessarily.  It leads to a song and dance at the end of strtod. */
+static _CONST double tinytens[] = { 1e-16, 1e-32,
+#ifdef _DOUBLE_IS_32BITS
+.0, 0.0, 0.0
+#else
-static _CONST double tinytens[] = { 1e-16, 1e-32, 1e-64, 1e-128,
+e-64, 1e-128,
+				    9007199254740992. * 9007199254740992.e-256
-		9007199254740992.e-256
+#endif
+		};
 		};
 #endif
 #endif
 #define Check_FLT_ROUNDS
 #else
 #define Rounding Flt_Rounds
 #endif
+#ifdef Avoid_Underflow /*{*/
+ static double
+_DEFUN (sulp, (x, scale),
+       	U x _AND
+	int scale)
+{
+        U u;
+        double rv;
+        int i;
+        rv = ulp(dval(x));
+        if (!scale || (i = 2*P + 1 - ((dword0(x) & Exp_mask) >> Exp_shift)) <= 0)
+                return rv; /* Is there an example where i <= 0 ? */
+        dword0(u) = Exp_1 + (i << Exp_shift);
+#ifndef _DOUBLE_IS_32BITS
+        dword1(u) = 0;
+#endif
+        return rv * u.d;
+        }
+#endif /*}*/
 #ifndef NO_HEX_FP
 static void
 double
 _DEFUN (_strtod_r, (ptr, s00, se),
 	struct _reent *ptr _AND
-	_CONST char *s00 _AND
+	_CONST char *__restrict s00 _AND
-	char **se)
+	char **__restrict se)
+{
 #ifdef Avoid_Underflow
 	int scale;
 	_CONST char *s, *s0, *s1;
 	double aadj, adj;
 	U aadj1, rv, rv0;
 	Long L;
 	__ULong y, z;
-	_Bigint *bb, *bb1, *bd, *bd0, *bs, *delta;
+	_Bigint *bb = NULL, *bb1, *bd = NULL, *bd0, *bs = NULL, *delta = NULL;
+#ifdef Avoid_Underflow
+	__ULong Lsb, Lsb1;
+#endif
 #ifdef SET_INEXACT
 	int inexact, oldinexact;
 #endif
 #ifdef Honor_FLT_ROUNDS
 	int rounding;
+		}
  break2:
 	if (*s == '0') {
 #ifndef NO_HEX_FP
+		{
-		static FPI fpi = { 53, 1-1023-53+1, 2046-1023-53+1, 1, SI };
+		static _CONST FPI fpi = { 53, 1-1023-53+1, 2046-1023-53+1, 1, SI };
 		Long exp;
 		__ULong bits[2];
 		switch(s[1]) {
 		  case 'x':
 		  case 'X':
 #define fpi1 fpi
 #endif
 			switch((i = gethex(ptr, &s, &fpi1, &exp, &bb, sign)) & STRTOG_Retmask) {
 			  case STRTOG_NoNumber:
 				s = s00;
+				sign = 0;
+				/* FALLTHROUGH */
 			  case STRTOG_Zero:
 				break;
 			  default:
 				if (bb) {
 					copybits(bits, fpi.nbits, bb);
 		if (!*s)
 			goto ret;
+		}
 	s0 = s;
 	y = z = 0;
-	for(nd = nf = 0; (c = *s) >= '0' && c <= '9'; nd++, s++) {
+	for(nd = nf = 0; (c = *s) >= '0' && c <= '9'; nd++, s++)
-		if (nd < DBL_DIG + 1) {
 			if (nd < 9)
 				y = 10*y + c - '0';
 			else
 				z = 10*z + c - '0';
-		}
-        }
 	nd0 = nd;
 	if (strncmp (s, _localeconv_r (ptr)->decimal_point,
-		     strlen (_localeconv_r (ptr)->decimal_point)) == 0) {
+		     strlen (_localeconv_r (ptr)->decimal_point)) == 0)
+		{
 		decpt = 1;
 		c = *(s += strlen (_localeconv_r (ptr)->decimal_point));
 		if (!nd) {
 			for(; c == '0'; c = *++s)
 				nz++;
+			}
 		for(; c >= '0' && c <= '9'; c = *++s) {
  have_dig:
 			nz++;
 			if (c -= '0') {
-				for(i = 1; i < nz; i++) {
+				nf += nz;
-					if (nd <= DBL_DIG + 1) {
+				for(i = 1; i < nz; i++)
-						if (nd + i < 10)
+					if (nd++ < 9)
 							y *= 10;
-						else
+					else if (nd <= DBL_DIG + 1)
 							z *= 10;
-					}
-				}
-				if (nd <= DBL_DIG + 1) {
-					if (nd + i < 10)
+				if (nd++ < 9)
 						y = 10*y + c;
-					else
+				else if (nd <= DBL_DIG + 1)
 						z = 10*z + c;
-				}
-				if (nd <= DBL_DIG + 1) {
-					nf += nz;
-					nd += nz;
-				}
 				nz = 0;
+				}
+			}
+		}
  dig_done:
 	if (!nd) {
 		if (!nz && !nz0) {
 #ifdef INFNAN_CHECK
 			/* Check for Nan and Infinity */
 			__ULong bits[2];
-			static FPI fpinan =	/* only 52 explicit bits */
+			static _CONST FPI fpinan =	/* only 52 explicit bits */
 				{ 52, 1-1023-53+1, 2046-1023-53+1, 1, SI };
 			if (!decpt)
 			 switch(c) {
 			  case 'i':
 			  case 'I':
 	/* Now the hard part -- adjusting rv to the correct value.*/
 	/* Put digits into bd: true value = bd * 10^e */
+	bd0 = s2b(ptr, s0, nd0, nd, y);
 	if (bd0 == NULL)
-	bd0 = s2b(ptr, s0, nd0, nd, y);
+		goto ovfl;
+	for(;;) {
 		bd = Balloc(ptr,bd0->_k);
-	for(;;) {
+		if (bd == NULL)
+			goto ovfl;
+		Bcopy(bd, bd0);
-		bd = Balloc(ptr,bd0->_k);
+		bb = d2b(ptr,dval(rv), &bbe, &bbbits);	/* rv = bb * 2^bbe */
+		if (bb == NULL)
+			goto ovfl;
-		Bcopy(bd, bd0);
+		bs = i2b(ptr,1);
-		bb = d2b(ptr,dval(rv), &bbe, &bbbits);	/* rv = bb * 2^bbe */
+		if (bs == NULL)
-		bs = i2b(ptr,1);
+			goto ovfl;
 #ifdef Honor_FLT_ROUNDS
 		if (rounding != 1)
 			bs2++;
 #endif
 #ifdef Avoid_Underflow
+		Lsb = LSB;
+		Lsb1 = 0;
 		j = bbe - scale;
 		i = j + bbbits - 1;	/* logb(rv) */
-		if (i < Emin)	/* denormal */
-			j += P - Emin;
-		else
-			j = P + 1 - bbbits;
+		j = P + 1 - bbbits;
+		if (i < Emin) {	/* denormal */
+			i = Emin - i;
+			j -= i;
+			if (i < 32)
+				Lsb <<= i;
+		else
+				Lsb1 = Lsb << (i-32);
+			}
 #else /*Avoid_Underflow*/
 #ifdef Sudden_Underflow
 #ifdef IBM
 		j = 1 + 4*P - 3 - bbbits + ((bbe + bbbits - 1) & 3);
 #else
 			bd2 -= i;
 			bs2 -= i;
+			}
 		if (bb5 > 0) {
 			bs = pow5mult(ptr, bs, bb5);
+			if (bs == NULL)
+				goto ovfl;
 			bb1 = mult(ptr, bs, bb);
+			if (bb1 == NULL)
+				goto ovfl;
 			Bfree(ptr, bb);
 			bb = bb1;
+			}
-		if (bb2 > 0)
+		if (bb2 > 0) {
 			bb = lshift(ptr, bb, bb2);
+			if (bb == NULL)
+				goto ovfl;
+			}
-		if (bd5 > 0)
+		if (bd5 > 0) {
 			bd = pow5mult(ptr, bd, bd5);
+			if (bd == NULL)
+				goto ovfl;
+			}
-		if (bd2 > 0)
+		if (bd2 > 0) {
 			bd = lshift(ptr, bd, bd2);
+			if (bd == NULL)
+				goto ovfl;
+			}
-		if (bs2 > 0)
+		if (bs2 > 0) {
 			bs = lshift(ptr, bs, bs2);
+			if (bs == NULL)
+				goto ovfl;
+			}
 		delta = diff(ptr, bb, bd);
+		if (delta == NULL)
+			goto ovfl;
 		dsign = delta->_sign;
 		delta->_sign = 0;
 		i = cmp(delta, bs);
 #ifdef Honor_FLT_ROUNDS
 		if (rounding != 1) {
 				goto cont;
+				}
 #endif /*Sudden_Underflow*/
 #endif /*Avoid_Underflow*/
 			adj *= ulp(dval(rv));
-			if (dsign)
+			if (dsign) {
+				if (dword0(rv) == Big0 && dword1(rv) == Big1)
+					goto ovfl;
 				dval(rv) += adj;
 			else
 				dval(rv) -= adj;
 			goto cont;
+			}
 			(scale && (y = dword0(rv) & Exp_mask) <= 2*P*Exp_msk1)
 		? (0xffffffff & (0xffffffff << (2*P+1-(y>>Exp_shift)))) :
 #endif
 xffffffff)) {
 					/*boundary case -- increment exponent*/
+					if (dword0(rv) == Big0 && dword1(rv) == Big1)
+						goto ovfl;
 					dword0(rv) = (dword0(rv) & Exp_mask)
 						+ Exp_msk1
 #ifdef IBM
 						| Exp_msk1 >> 4
 #endif
 #else
 				break;
 #endif
+				}
 #ifndef ROUND_BIASED
+#ifdef Avoid_Underflow
+			if (Lsb1) {
+				if (!(dword0(rv) & Lsb1))
+					break;
+				}
+			else if (!(dword1(rv) & Lsb))
+				break;
+#else
 			if (!(dword1(rv) & LSB))
 				break;
 #endif
+#endif
 			if (dsign)
+#ifdef Avoid_Underflow
+				dval(rv) += sulp(rv, scale);
+#else
 				dval(rv) += ulp(dval(rv));
+#endif
 #ifndef ROUND_BIASED
 			else {
+#ifdef Avoid_Underflow
+				dval(rv) -= sulp(rv, scale);
+#else
 				dval(rv) -= ulp(dval(rv));
+#endif
 #ifndef Sudden_Underflow
 				if (!dval(rv))
 					goto undfl;
 #endif
+				}
+			}
 		else {
 #ifdef Avoid_Underflow
 			if (scale && y <= 2*P*Exp_msk1) {
 				if (aadj <= 0x7fffffff) {
-					if ((z = aadj) <= 0)
+					if ((z = aadj) == 0)
 						z = 1;
 					aadj = z;
 					dval(aadj1) = dsign ? aadj : -aadj;
+					}
 				dword0(aadj1) += (2*P+1)*Exp_msk1 - y;
 #ifndef _REENT_ONLY
 double
 _DEFUN (strtod, (s00, se),
-	_CONST char *s00 _AND char **se)
+	_CONST char *__restrict s00 _AND char **__restrict se)
+{
   return _strtod_r (_REENT, s00, se);
+}
 float
 _DEFUN (strtof, (s00, se),
-	_CONST char *s00 _AND
+	_CONST char *__restrict s00 _AND
-	char **se)
+	char **__restrict se)
+{
   double retval = _strtod_r (_REENT, s00, se);

Subversion Repositories Kolibri OS

(root)/contrib/sdk/sources/newlib/libc/stdlib/strtod.c – Rev 4874 → 4921