Fixes for re-enabling more MSVC level 4 warnings: base/third_party/dmg_fp/ edition

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 530 matching lines @@
 {
         int x;
         Bigint *rv;
 #ifndef Omit_Private_Memory
         unsigned int len;
 #endif
 
         ACQUIRE_DTOA_LOCK(0);
         /* The k > Kmax case does not need ACQUIRE_DTOA_LOCK(0), */
         /* but this case seems very unlikely. */
-        if (k <= Kmax && (rv = freelist[k]))
+        if (k <= Kmax && freelist[k]) {
+                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 (k <= Kmax && pmem_next - private_mem + len <= PRIVATE_mem) {
                         rv = (Bigint*)pmem_next;
                         pmem_next += len;
@@ skipping 264 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++)) {
+                y = *xb++;
+                if (y) {
                         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))
+        i = k & 3;
+        if (i)
                 b = multadd(b, p05[i-1], 0);
 
         if (!(k >>= 2))
                 return b;
-        if (!(p5 = p5s)) {
+        p5 = p5s;
+        if (!p5) {
                 /* first time */
 #ifdef MULTIPLE_THREADS
                 ACQUIRE_DTOA_LOCK(1);
-                if (!(p5 = p5s)) {
+                p5 = p5s;
+                if (!p5) {
                         p5 = p5s = i2b(625);
                         p5->next = 0;
                         }
                 FREE_DTOA_LOCK(1);
 #else
                 p5 = p5s = i2b(625);
                 p5->next = 0;
 #endif
                 }
         for(;;) {
                 if (k & 1) {
                         b1 = mult(b, p5);
                         Bfree(b);
                         b = b1;
                         }
                 if (!(k >>= 1))
                         break;
-                if (!(p51 = p5->next)) {
+                p51 = p5->next;
+                if (!p51) {
 #ifdef MULTIPLE_THREADS
                         ACQUIRE_DTOA_LOCK(1);
-                        if (!(p51 = p5->next)) {
+                        p51 = p5->next;
+                        if (!p51) {
                                 p51 = p5->next = mult(p5,p5);
                                 p51->next = 0;
                                 }
                         FREE_DTOA_LOCK(1);
 #else
                         p51 = p5->next = mult(p5,p5);
                         p51->next = 0;
 #endif
                         }
                 p5 = p51;
@@ skipping 30 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))
+                *x1 = z;
+                if (*x1)
                         ++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)))
+        de = (int)(d0 >> Exp_shift);
+        if (de)
                 z |= Exp_msk1;
 #endif
 #ifdef Pack_32
-        if ((y = d1)) {
-                if ((k = lo0bits(&y))) {
+        y = d1;
+        if (y) {
+                k = lo0bits(&y);
+                if (k) {
                         x[0] = y | z << (32 - k);
                         z >>= k;
                         }
                 else
                         x[0] = y;
+                x[1] = z;
+                b->wds = x[1] ? 2 : 1;
 #ifndef Sudden_Underflow
-                i =
+                i = b->wds;
 #endif
-                    b->wds = (x[1] = z) ? 2 : 1;
                 }
         else {
                 k = lo0bits(&z);
                 x[0] = z;
 #ifndef Sudden_Underflow
                 i =
 #endif
                     b->wds = 1;
                 k += 32;
                 }
@@ skipping 202 matching lines @@
 match
 #ifdef KR_headers
         (sp, t) char **sp, *t;
 #else
         (CONST char **sp, CONST char *t)
 #endif
 {
         int c, d;
         CONST char *s = *sp;
 
-        while((d = *t++)) {
+        for(d = *t++; d; 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
  static void
 hexnan
 #ifdef KR_headers
         (rvp, sp) U *rvp; CONST char **sp;
 #else
         (U *rvp, CONST char **sp)
 #endif
 {
         ULong c, x[2];
         CONST char *s;
         int c1, havedig, udx0, xshift;
 
         if (!hexdig['0'])
                 hexdig_init();
         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 <= ' ')
+        for(c = *(CONST unsigned char*)(s+1); c && c <= ' '; c = *(CONST unsigned char*)(s+1))
                 ++s;
         if (s[1] == '0' && (s[2] == 'x' || s[2] == 'X'))
                 s += 2;
-        while((c = *(CONST unsigned char*)++s)) {
-                if ((c1 = hexdig[c]))
+        for(c = *(CONST unsigned char*)++s; c; c = *(CONST unsigned char*)++s) {
+                c1 = hexdig[c];
+                if (c1)
                         c  = c1 & 0xf;
                 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));
+                                c = *++s;
+                                } while(c);
                         break;
                         }
 #endif
                 havedig = 1;
                 if (xshift) {
                         xshift = 0;
                         x[0] = x[1];
                         x[1] = 0;
                         }
                 if (udx0)
@@ skipping 713 matching lines @@
                 }
         i = dshift(d, d2);
         if ((b2 += i) > 0)
                 b = lshift(b, b2);
         if ((d2 += i) > 0)
                 d = lshift(d, d2);
 
         /* Now b/d = exactly half-way between the two floating-point values */
         /* on either side of the input string.  Compute first digit of b/d. */
 
-        if (!(dig = quorem(b,d))) {
+        dig = quorem(b,d);
+        if (!dig) {
                 b = multadd(b, 10, 0);  /* very unlikely */
                 dig = quorem(b,d);
                 }
 
         /* Compare b/d with s0 */
 
         for(i = 0; i < nd0; ) {
-                if ((dd = s0[i++] - '0' - dig))
+                dd = s0[i++] - '0' - dig;
+                if (dd)
                         goto ret;
                 if (!b->x[0] && b->wds == 1) {
                         if (i < nd)
                                 dd = 1;
                         goto ret;
                         }
                 b = multadd(b, 10, 0);
                 dig = quorem(b,d);
                 }
         for(j = bc->dp1; i++ < nd;) {
-                if ((dd = s0[j++] - '0' - dig))
+                dd = s0[j++] - '0' - dig;
+                if (dd)
                         goto ret;
                 if (!b->x[0] && b->wds == 1) {
                         if (i < nd)
                                 dd = 1;
                         goto ret;
                         }
                 b = multadd(b, 10, 0);
                 dig = quorem(b,d);
                 }
         if (b->x[0] || b->wds > 1)
@@ skipping 379 matching lines @@
                 else
                         if (bc.rounding != 2)
                                 bc.rounding = 0;
                 }
 #endif
 #endif /*IEEE_Arith*/
 
         /* Get starting approximation = rv * 10**e1 */
 
         if (e1 > 0) {
-                if ((i = e1 & 15))
+                i = e1 & 15;
+                if (i)
                         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 37 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))
+                i = e1 & 15;
+                if (i)
                         dval(&rv) /= tens[i];
                 if (e1 >>= 4) {
                         if (e1 >= 1 << n_bigtens)
                                 goto undfl;
 #ifdef Avoid_Underflow
                         if (e1 & Scale_Bit)
                                 bc.scale = 2*P;
                         for(j = 0; e1 > 0; j++, e1 >>= 1)
                                 if (e1 & 1)
                                         dval(&rv) *= tinytens[j];
@@ skipping 630 matching lines @@
  static char *
 #ifdef KR_headers
 nrv_alloc(s, rve, n) char *s, **rve; int n;
 #else
 nrv_alloc(CONST char *s, char **rve, int n)
 #endif
 {
         char *rv, *t;
 
         t = rv = rv_alloc(n);
-        while((*t = *s++)) t++;
+        for(*t = *s++; *t; *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 168 matching lines @@
         if (Rounding >= 2) {
                 if (*sign)
                         Rounding = Rounding == 2 ? 0 : 2;
                 else
                         if (Rounding != 2)
                                 Rounding = 0;
                 }
 #endif
 
         b = d2b(&u, &be, &bbits);
-#ifdef Sudden_Underflow
         i = (int)(word0(&u) >> Exp_shift1 & (Exp_mask>>Exp_shift1));
-#else
-        if ((i = (int)(word0(&u) >> Exp_shift1 & (Exp_mask>>Exp_shift1)))) {
+#ifndef Sudden_Underflow
+        if (i) {
 #endif
                 dval(&d2) = dval(&u);
                 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 134 matching lines @@
                                 dval(&u) /= bigtens[n_bigtens-1];
                                 ieps++;
                                 }
                         for(; j; j >>= 1, i++)
                                 if (j & 1) {
                                         ieps++;
                                         ds *= bigtens[i];
                                         }
                         dval(&u) /= ds;
                         }
-                else if ((j1 = -k)) {
-                        dval(&u) *= tens[j1 & 0xf];
-                        for(j = j1 >> 4; j; j >>= 1, i++)
-                                if (j & 1) {
-                                        ieps++;
-                                        dval(&u) *= bigtens[i];
-                                        }
+                else {
+                        j1 = -k;
+                        if (j1) {
+                                dval(&u) *= tens[j1 & 0xf];
+                                for(j = j1 >> 4; j; j >>= 1, i++)
+                                        if (j & 1) {
+                                                ieps++;
+                                                dval(&u) *= bigtens[i];
+                                                }
+                                }
                         }
                 if (k_check && dval(&u) < 1. && ilim > 0) {
                         if (ilim1 <= 0)
                                 goto fast_failed;
                         ilim = ilim1;
                         k--;
                         dval(&u) *= 10.;
                         ieps++;
                         }
                 dval(&eps) = ieps*dval(&u) + 7.;
@@ skipping 134 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))
+                        j = b5 - m5;
+                        if (j)
                                 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))
+        i = ((s5 ? 32 - hi0bits(S->x[S->wds-1]) : 1) + s2) & 0x1f;
+        if (i)
                 i = 32 - i;
 #define iInc 28
 #else
         if (i = ((s5 ? 32 - hi0bits(S->x[S->wds-1]) : 1) + s2) & 0xf)
                 i = 16 - i;
 #define iInc 12
 #endif
         i = dshift(S, s2);
         b2 += i;
         m2 += i;
@@ skipping 184 matching lines @@
 #endif
         Bfree(b);
         *s = 0;
         *decpt = k + 1;
         if (rve)
                 *rve = s;
         return s0;
         }
 
 }  // namespace dmg_fp