Fix more MSVC warnings, this time mostly about possible value truncation (fixed

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 634 matching lines @@
 #endif
                 }
                 while(++i < wds);
         if (carry) {
                 if (wds >= b->maxwds) {
                         b1 = Balloc(b->k+1);
                         Bcopy(b1, b);
                         Bfree(b);
                         b = b1;
                         }
-                b->x[wds++] = carry;
+                b->x[wds++] = (ULong)carry;
                 b->wds = wds;
                 }
         return b;
         }
 
  static Bigint *
 s2b
 #ifdef KR_headers
         (s, nd0, nd, y9, dplen) CONST char *s; int nd0, nd, dplen; ULong y9;
 #else
@@ skipping 174 matching lines @@
                 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;
+                        *xc = (ULong)carry;
                         }
                 }
 #else
 #ifdef Pack_32
         for(; xb < xbe; xb++, xc0++) {
                 if (y = *xb & 0xffff) {
                         x = xa;
                         xc = xc0;
                         carry = 0;
                         do {
@@ skipping 643 matching lines @@
 
  static void
 #ifdef KR_headers
 htinit(h, s, inc) unsigned char *h; unsigned char *s; int inc;
 #else
 htinit(unsigned char *h, unsigned char *s, int inc)
 #endif
 {
         int i, j;
         for(i = 0; (j = s[i]) !=0; i++)
-                h[j] = i + inc;
+                h[j] = (unsigned char)(i + inc);
         }
 
  static void
 #ifdef KR_headers
 hexdig_init()
 #else
 hexdig_init(void)
 #endif
 {
 #define USC (unsigned char *)
@@ skipping 1771 matching lines @@
                                 word1(&rv) = Big1;
                                 goto cont;
                                 }
                         else
                                 word0(&rv) += P*Exp_msk1;
                         }
                 else {
 #ifdef Avoid_Underflow
                         if (bc.scale && y <= 2*P*Exp_msk1) {
                                 if (aadj <= 0x7fffffff) {
-                                        if ((z = aadj) <= 0)
+                                        if ((z = (ULong)aadj) <= 0)
                                                 z = 1;
                                         aadj = z;
                                         aadj1 = bc.dsign ? aadj : -aadj;
                                         }
                                 dval(&aadj2) = aadj1;
                                 word0(&aadj2) += (2*P+1)*Exp_msk1 - y;
                                 aadj1 = dval(&aadj2);
                                 }
                         adj.d = aadj1 * ulp(&rv);
                         dval(&rv) += adj.d;
@@ skipping 535 matching lines @@
                                 goto no_digits;
                         goto fast_failed;
                         }
 #ifndef No_leftright
                 if (leftright) {
                         /* Use Steele & White method of only
                          * generating digits needed.
                          */
                         dval(&eps) = 0.5/tens[ilim-1] - dval(&eps);
                         for(i = 0;;) {
-                                L = dval(&u);
+                                L = (long)dval(&u);
                                 dval(&u) -= L;
-                                *s++ = '0' + (int)L;
+                                *s++ = '0' + (char)L;
                                 if (dval(&u) < dval(&eps))
                                         goto ret1;
                                 if (1. - dval(&u) < dval(&eps))
                                         goto bump_up;
                                 if (++i >= ilim)
                                         break;
                                 dval(&eps) *= 10.;
                                 dval(&u) *= 10.;
                                 }
                         }
                 else {
 #endif
                         /* Generate ilim digits, then fix them up. */
                         dval(&eps) *= tens[ilim-1];
                         for(i = 1;; i++, dval(&u) *= 10.) {
                                 L = (Long)(dval(&u));
                                 if (!(dval(&u) -= L))
                                         ilim = i;
-                                *s++ = '0' + (int)L;
+                                *s++ = '0' + (char)L;
                                 if (i == ilim) {
                                         if (dval(&u) > 0.5 + dval(&eps))
                                                 goto bump_up;
                                         else if (dval(&u) < 0.5 - dval(&eps)) {
                                                 while(*--s == '0') {}
                                                 s++;
                                                 goto ret1;
                                                 }
                                         break;
                                         }
@@ skipping 22 matching lines @@
                 for(i = 1; i <= k + 1; i++, dval(&u) *= 10.) {
                         L = (Long)(dval(&u) / ds);
                         dval(&u) -= L*ds;
 #ifdef Check_FLT_ROUNDS
                         /* If FLT_ROUNDS == 2, L will usually be high by 1 */
                         if (dval(&u) < 0) {
                                 L--;
                                 dval(&u) += ds;
                                 }
 #endif
-                        *s++ = '0' + (int)L;
+                        *s++ = '0' + (char)L;
                         if (!dval(&u)) {
 #ifdef SET_INEXACT
                                 inexact = 0;
 #endif
                                 break;
                                 }
                         if (i == ilim) {
 #ifdef Honor_FLT_ROUNDS
                                 if (mode > 1)
                                 switch(Rounding) {
@@ skipping 157 matching lines @@
 #endif
                                                                    ) {
                                 if (dig == '9')
                                         goto round_9_up;
                                 if (j > 0)
                                         dig++;
 #ifdef SET_INEXACT
                                 else if (!b->x[0] && b->wds <= 1)
                                         inexact = 0;
 #endif
-                                *s++ = dig;
+                                *s++ = (char)dig;
                                 goto ret;
                                 }
 #endif
                         if (j < 0 || (j == 0 && mode != 1
 #ifndef ROUND_BIASED
                                                         && !(word1(&u) & 1)
 #endif
                                         )) {
                                 if (!b->x[0] && b->wds <= 1) {
 #ifdef SET_INEXACT
                                         inexact = 0;
 #endif
                                         goto accept_dig;
                                         }
 #ifdef Honor_FLT_ROUNDS
                                 if (mode > 1)
                                  switch(Rounding) {
                                   case 0: goto accept_dig;
                                   case 2: goto keep_dig;
                                   }
 #endif /*Honor_FLT_ROUNDS*/
                                 if (j1 > 0) {
                                         b = lshift(b, 1);
                                         j1 = cmp(b, S);
                                         if ((j1 > 0 || (j1 == 0 && dig & 1))
                                         && dig++ == '9')
                                                 goto round_9_up;
                                         }
  accept_dig:
-                                *s++ = dig;
+                                *s++ = (char)dig;
                                 goto ret;
                                 }
                         if (j1 > 0) {
 #ifdef Honor_FLT_ROUNDS
                                 if (!Rounding)
                                         goto accept_dig;
 #endif
                                 if (dig == '9') { /* possible if i == 1 */
  round_9_up:
                                         *s++ = '9';
                                         goto roundoff;
                                         }
-                                *s++ = dig + 1;
+                                *s++ = (char)dig + 1;

[scottmg, 2014/09/25 06:44:16]

(man this code is frightening)

this seems like it could potentially be different, should it be (char)(dig + 1)?
or if it's always '0'-'9' just ignore me.

[Peter Kasting, 2014/09/25 08:31:22]

What's even worse is that we have multiple copies of it in our codebase.
I think it's always 0-9 (otherwise sticking it in the result string is pretty
strange), but let's assume I'm wrong.  What would be a case when the result
would be different?  I can't think of a case where adding one after versus
before casting to char will make a difference, except maybe insofar as signed
overflow is technically undefined, so one form might be undefined and the other
not (but realistically, that's not going to have a practical effect on any of
our compilers).

                                 goto ret;
                                 }
 #ifdef Honor_FLT_ROUNDS
  keep_dig:
 #endif
-                        *s++ = dig;
+                        *s++ = (char)dig;
                         if (i == ilim)
                                 break;
                         b = multadd(b, 10, 0);
                         if (mlo == mhi)
                                 mlo = mhi = multadd(mhi, 10, 0);
                         else {
                                 mlo = multadd(mlo, 10, 0);
                                 mhi = multadd(mhi, 10, 0);
                                 }
                         }
                 }
         else
                 for(i = 1;; i++) {
-                        *s++ = dig = quorem(b,S) + '0';
+                        dig = quorem(b,S) + '0';
+                        *s++ = (char)dig;
                         if (!b->x[0] && b->wds <= 1) {
 #ifdef SET_INEXACT
                                 inexact = 0;
 #endif
                                 goto ret;
                                 }
                         if (i >= ilim)
                                 break;
                         b = multadd(b, 10, 0);
                         }
@@ skipping 46 matching lines @@
 #endif
         Bfree(b);
         *s = 0;
         *decpt = k + 1;
         if (rve)
                 *rve = s;
         return s0;
         }
 
 }  // namespace dmg_fp