Allow clean compilation of dmg_fp under g++ -Wall -Werror

base/third_party/dmg_fp/dtoa.cc

 /****************************************************************
  *
  * The author of this software is David M. Gay.
  *
  * Copyright (c) 1991, 2000, 2001 by Lucent Technologies.
  *
  * Permission to use, copy, modify, and distribute this software for any
  * purpose without fee is hereby granted, provided that this entire notice
  * is included in all copies of any software which is or includes a copy
  * or modification of this software and in all copies of the supporting
@@ skipping 497 matching lines @@
         (int k)
 #endif
 {
         int x;
         Bigint *rv;
 #ifndef Omit_Private_Memory
         unsigned int len;
 #endif
 
         ACQUIRE_DTOA_LOCK(0);
-        if (rv = freelist[k]) {
+        if ((rv = freelist[k])) {
                 freelist[k] = rv->next;
                 }
         else {
                 x = 1 << k;
 #ifdef Omit_Private_Memory
                 rv = (Bigint *)MALLOC(sizeof(Bigint) + (x-1)*sizeof(ULong));
 #else
                 len = (sizeof(Bigint) + (x-1)*sizeof(ULong) + sizeof(double) - 1)
                         /sizeof(double);
                 if (pmem_next - private_mem + len <= PRIVATE_mem) {
@@ skipping 258 matching lines @@
         c = Balloc(k);
         for(x = c->x, xa = x + wc; x < xa; x++)
                 *x = 0;
         xa = a->x;
         xae = xa + wa;
         xb = b->x;
         xbe = xb + wb;
         xc0 = c->x;
 #ifdef ULLong
         for(; xb < xbe; xc0++) {
-                if (y = *xb++) {
+                if ((y = *xb++)) {
                         x = xa;
                         xc = xc0;
                         carry = 0;
                         do {
                                 z = *x++ * (ULLong)y + *xc + carry;
                                 carry = z >> 32;
                                 *xc++ = z & FFFFFFFF;
                                 }
                                 while(x < xae);
                         *xc = carry;
@@ skipping 61 matching lines @@
 #ifdef KR_headers
         (b, k) Bigint *b; int k;
 #else
         (Bigint *b, int k)
 #endif
 {
         Bigint *b1, *p5, *p51;
         int i;
         static int p05[3] = { 5, 25, 125 };
 
-        if (i = k & 3)
+        if ((i = k & 3))
                 b = multadd(b, p05[i-1], 0);
 
         if (!(k >>= 2))
                 return b;
         if (!(p5 = p5s)) {
                 /* first time */
 #ifdef MULTIPLE_THREADS
                 ACQUIRE_DTOA_LOCK(1);
                 if (!(p5 = p5s)) {
                         p5 = p5s = i2b(625);
@@ skipping 60 matching lines @@
         xe = x + b->wds;
 #ifdef Pack_32
         if (k &= 0x1f) {
                 k1 = 32 - k;
                 z = 0;
                 do {
                         *x1++ = *x << k | z;
                         z = *x++ >> k1;
                         }
                         while(x < xe);
-                if (*x1 = z)
+                if ((*x1 = z))
                         ++n1;
                 }
 #else
         if (k &= 0xf) {
                 k1 = 16 - k;
                 z = 0;
                 do {
                         *x1++ = *x << k  & 0xffff | z;
                         z = *x++ >> k1;
                         }
@@ skipping 281 matching lines @@
         x = b->x;
 
         z = d0 & Frac_mask;
         d0 &= 0x7fffffff;       /* clear sign bit, which we ignore */
 #ifdef Sudden_Underflow
         de = (int)(d0 >> Exp_shift);
 #ifndef IBM
         z |= Exp_msk11;
 #endif
 #else
-        if (de = (int)(d0 >> Exp_shift))
+        if ((de = (int)(d0 >> Exp_shift)))
                 z |= Exp_msk1;
 #endif
 #ifdef Pack_32
-        if (y = d1) {
-                if (k = lo0bits(&y)) {
+        if ((y = d1)) {
+                if ((k = lo0bits(&y))) {
                         x[0] = y | z << 32 - k;
                         z >>= k;
                         }
                 else
                         x[0] = y;
 #ifndef Sudden_Underflow
                 i =
 #endif
                     b->wds = (x[1] = z) ? 2 : 1;
                 }
@@ skipping 167 matching lines @@
 
 #ifndef NAN_WORD1
 #define NAN_WORD1 0
 #endif
 
  static int
 match
 #ifdef KR_headers
         (sp, t) char **sp, *t;
 #else
-        (CONST char **sp, char *t)
+        (CONST char **sp, CONST char *t)
 #endif
 {
         int c, d;
         CONST char *s = *sp;
 
-        while(d = *t++) {
+        while((d = *t++)) {
                 if ((c = *++s) >= 'A' && c <= 'Z')
                         c += 'a' - 'A';
                 if (c != d)
                         return 0;
                 }
         *sp = s + 1;
         return 1;
         }
 
 #ifndef No_Hex_NaN
@@ skipping 11 matching lines @@
 
         x[0] = x[1] = 0;
         havedig = xshift = 0;
         udx0 = 1;
         s = *sp;
         /* allow optional initial 0x or 0X */
         while((c = *(CONST unsigned char*)(s+1)) && c <= ' ')
                 ++s;
         if (s[1] == '0' && (s[2] == 'x' || s[2] == 'X'))
                 s += 2;
-        while(c = *(CONST unsigned char*)++s) {
+        while((c = *(CONST unsigned char*)++s)) {
                 if (c >= '0' && c <= '9')
                         c -= '0';
                 else if (c >= 'a' && c <= 'f')
                         c += 10 - 'a';
                 else if (c >= 'A' && c <= 'F')
                         c += 10 - 'A';
                 else if (c <= ' ') {
                         if (udx0 && havedig) {
                                 udx0 = 0;
                                 xshift = 1;
                                 }
                         continue;
                         }
 #ifdef GDTOA_NON_PEDANTIC_NANCHECK
                 else if (/*(*/ c == ')' && havedig) {
                         *sp = s + 1;
                         break;
                         }
                 else
                         return; /* invalid form: don't change *sp */
 #else
                 else {
                         do {
                                 if (/*(*/ c == ')') {
                                         *sp = s + 1;
                                         break;
                                         }
-                                } while(c = *++s);
+                                } while((c = *++s));
                         break;
                         }
 #endif
                 havedig = 1;
                 if (xshift) {
                         xshift = 0;
                         x[0] = x[1];
                         x[1] = 0;
                         }
                 if (udx0)
@@ skipping 313 matching lines @@
                 else
                         if (Rounding != 2)
                                 Rounding = 0;
                 }
 #endif
 #endif /*IEEE_Arith*/
 
         /* Get starting approximation = rv * 10**e1 */
 
         if (e1 > 0) {
-                if (i = e1 & 15)
+                if ((i = e1 & 15))
                         dval(rv) *= tens[i];
                 if (e1 &= ~15) {
                         if (e1 > DBL_MAX_10_EXP) {
  ovfl:
 #ifndef NO_ERRNO
                                 errno = ERANGE;
 #endif
                                 /* Can't trust HUGE_VAL */
 #ifdef IEEE_Arith
 #ifdef Honor_FLT_ROUNDS
@@ skipping 39 matching lines @@
                                 /* (Can't trust DBL_MAX) */
                                 word0(rv) = Big0;
                                 word1(rv) = Big1;
                                 }
                         else
                                 word0(rv) += P*Exp_msk1;
                         }
                 }
         else if (e1 < 0) {
                 e1 = -e1;
-                if (i = e1 & 15)
+                if ((i = e1 & 15))
                         dval(rv) /= tens[i];
                 if (e1 >>= 4) {
                         if (e1 >= 1 << n_bigtens)
                                 goto undfl;
 #ifdef Avoid_Underflow
                         if (e1 & Scale_Bit)
                                 scale = 2*P;
                         for(j = 0; e1 > 0; j++, e1 >>= 1)
                                 if (e1 & 1)
                                         dval(rv) *= tinytens[j];
@@ skipping 647 matching lines @@
 #ifdef KR_headers
 rv_alloc(i) int i;
 #else
 rv_alloc(int i)
 #endif
 {
         int j, k, *r;
 
         j = sizeof(ULong);
         for(k = 0;
-                sizeof(Bigint) - sizeof(ULong) - sizeof(int) + j <= i;
+                sizeof(Bigint) - sizeof(ULong) - sizeof(int) + j <= (size_t)i;
                 j <<= 1)
                         k++;
         r = (int*)Balloc(k);
         *r = k;
         return
 #ifndef MULTIPLE_THREADS
         dtoa_result =
 #endif
                 (char *)(r+1);
         }
 
  static char *
 #ifdef KR_headers
 nrv_alloc(s, rve, n) char *s, **rve; int n;
 #else
-nrv_alloc(char *s, char **rve, int n)
+nrv_alloc(CONST char *s, char **rve, int n)
 #endif
 {
         char *rv, *t;
 
         t = rv = rv_alloc(n);
-        while(*t = *s++) t++;
+        while((*t = *s++)) t++;
         if (rve)
                 *rve = t;
         return rv;
         }
 
 /* freedtoa(s) must be used to free values s returned by dtoa
  * when MULTIPLE_THREADS is #defined.  It should be used in all cases,
  * but for consistency with earlier versions of dtoa, it is optional
  * when MULTIPLE_THREADS is not defined.
  */
@@ skipping 84 matching lines @@
                         as modes 2 and 3 when FLT_ROUNDS != 1.
                 6-9 ==> Debugging modes similar to mode - 4:  don't try
                         fast floating-point estimate (if applicable).
 
                 Values of mode other than 0-9 are treated as mode 0.
 
                 Sufficient space is allocated to the return value
                 to hold the suppressed trailing zeros.
         */
 
-        int bbits, b2, b5, be, dig, i, ieps, ilim, ilim0, ilim1,
+        int bbits, b2, b5, be, dig, i, ieps, ilim = 0, ilim0, ilim1 = 0,
                 j, j1, k, k0, k_check, leftright, m2, m5, s2, s5,
                 spec_case, try_quick;
         Long L;
 #ifndef Sudden_Underflow
         int denorm;
         ULong x;
 #endif
         Bigint *b, *b1, *delta, *mlo, *mhi, *S;
         double d2, ds, eps;
         char *s, *s0;
@@ skipping 64 matching lines @@
                 else
                         if (Rounding != 2)
                                 Rounding = 0;
                 }
 #endif
 
         b = d2b(dval(d), &be, &bbits);
 #ifdef Sudden_Underflow
         i = (int)(word0(d) >> Exp_shift1 & (Exp_mask>>Exp_shift1));
 #else
-        if (i = (int)(word0(d) >> Exp_shift1 & (Exp_mask>>Exp_shift1))) {
+        if ((i = (int)(word0(d) >> Exp_shift1 & (Exp_mask>>Exp_shift1)))) {
 #endif
                 dval(d2) = dval(d);
                 word0(d2) &= Frac_mask1;
                 word0(d2) |= Exp_11;
 #ifdef IBM
                 if (j = 11 - hi0bits(word0(d2) & Frac_mask))
                         dval(d2) /= 1 << j;
 #endif
 
                 /* log(x)       ~=~ log(1.5) + (x-1.5)/1.5
@@ skipping 133 matching lines @@
                                 dval(d) /= bigtens[n_bigtens-1];
                                 ieps++;
                                 }
                         for(; j; j >>= 1, i++)
                                 if (j & 1) {
                                         ieps++;
                                         ds *= bigtens[i];
                                         }
                         dval(d) /= ds;
                         }
-                else if (j1 = -k) {
+                else if ((j1 = -k)) {
                         dval(d) *= tens[j1 & 0xf];
                         for(j = j1 >> 4; j; j >>= 1, i++)
                                 if (j & 1) {
                                         ieps++;
                                         dval(d) *= bigtens[i];
                                         }
                         }
                 if (k_check && dval(d) < 1. && ilim > 0) {
                         if (ilim1 <= 0)
                                 goto fast_failed;
@@ skipping 140 matching lines @@
                 s2 -= i;
                 }
         if (b5 > 0) {
                 if (leftright) {
                         if (m5 > 0) {
                                 mhi = pow5mult(mhi, m5);
                                 b1 = mult(mhi, b);
                                 Bfree(b);
                                 b = b1;
                                 }
-                        if (j = b5 - m5)
+                        if ((j = b5 - m5))
                                 b = pow5mult(b, j);
                         }
                 else
                         b = pow5mult(b, b5);
                 }
         S = i2b(1);
         if (s5 > 0)
                 S = pow5mult(S, s5);
 
         /* Check for special case that d is a normalized power of 2. */
@@ skipping 17 matching lines @@
                 }
 
         /* Arrange for convenient computation of quotients:
          * shift left if necessary so divisor has 4 leading 0 bits.
          *
          * Perhaps we should just compute leading 28 bits of S once
          * and for all and pass them and a shift to quorem, so it
          * can do shifts and ors to compute the numerator for q.
          */
 #ifdef Pack_32
-        if (i = ((s5 ? 32 - hi0bits(S->x[S->wds-1]) : 1) + s2) & 0x1f)
+        if ((i = ((s5 ? 32 - hi0bits(S->x[S->wds-1]) : 1) + s2) & 0x1f))
                 i = 32 - i;
 #else
         if (i = ((s5 ? 32 - hi0bits(S->x[S->wds-1]) : 1) + s2) & 0xf)
                 i = 16 - i;
 #endif
         if (i > 4) {
                 i -= 4;
                 b2 += i;
                 m2 += i;
                 s2 += i;
@@ skipping 156 matching lines @@
  roundoff:
                 while(*--s == '9')
                         if (s == s0) {
                                 k++;
                                 *s++ = '1';
                                 goto ret;
                                 }
                 ++*s++;
                 }
         else {
+#ifdef Honor_FLT_ROUNDS
  trimzeros:
+#endif
                 while(*--s == '0');
                 s++;
                 }
  ret:
         Bfree(S);
         if (mhi) {
                 if (mlo && mlo != mhi)
                         Bfree(mlo);
                 Bfree(mhi);
                 }
@@ skipping 11 matching lines @@
 #endif
         Bfree(b);
         *s = 0;
         *decpt = k + 1;
         if (rve)
                 *rve = s;
         return s0;
         }
 
 }  // namespace dmg_fp