Libc-763.11.tar.gz

[apple/libc.git] / gdtoa / FreeBSD / gdtoa-strtod.c

diff --git a/gdtoa/FreeBSD/gdtoa-strtod.c b/gdtoa/FreeBSD/gdtoa-strtod.c
index cb11666bbddb9270828a5c43fa295b9c3a9612a7..fdc933a1ef98d73c304bf5b16c194d7720272d6c 100644 (file)
--- a/gdtoa/FreeBSD/gdtoa-strtod.c
+++ b/gdtoa/FreeBSD/gdtoa-strtod.c
@@ -71,29 +71,36 @@ strtod
        int bb2, bb5, bbe, bd2, bd5, bbbits, bs2, c, decpt, dsign,
                 e, e1, esign, i, j, k, nd, nd0, nf, nz, nz0, sign;
        CONST char *s, *s0, *s1;
        int bb2, bb5, bbe, bd2, bd5, bbbits, bs2, c, decpt, dsign,
                 e, e1, esign, i, j, k, nd, nd0, nf, nz, nz0, sign;
        CONST char *s, *s0, *s1;

-       double aadj, aadj1, adj, rv, rv0;
+       double aadj;

        Long L;
        Long L;

+       U adj, aadj1, rv, rv0;

        ULong y, z;
        Bigint *bb, *bb1, *bd, *bd0, *bs, *delta;
 #ifdef SET_INEXACT
        int inexact, oldinexact;
 #endif
        ULong y, z;
        Bigint *bb, *bb1, *bd, *bd0, *bs, *delta;
 #ifdef SET_INEXACT
        int inexact, oldinexact;
 #endif

-#ifdef USE_LOCALE
+#ifdef USE_LOCALE /*{{*/

 #ifdef NO_LOCALE_CACHE
        char *decimalpoint = localeconv()->decimal_point;
 #ifdef NO_LOCALE_CACHE
        char *decimalpoint = localeconv()->decimal_point;

+       int dplen = strlen(decimalpoint);

 #else
        char *decimalpoint;
        static char *decimalpoint_cache;
 #else
        char *decimalpoint;
        static char *decimalpoint_cache;

+       static int dplen;

        if (!(s0 = decimalpoint_cache)) {
                s0 = localeconv()->decimal_point;
        if (!(s0 = decimalpoint_cache)) {
                s0 = localeconv()->decimal_point;

-               if ((decimalpoint_cache = (char*)malloc(strlen(s0) + 1))) {
+               if ((decimalpoint_cache = (char*)MALLOC(strlen(s0) + 1))) {

                        strcpy(decimalpoint_cache, s0);
                        s0 = decimalpoint_cache;
                        }
                        strcpy(decimalpoint_cache, s0);
                        s0 = decimalpoint_cache;
                        }

+               dplen = strlen(s0);

                }
        decimalpoint = (char*)s0;
                }
        decimalpoint = (char*)s0;

-#endif
-#endif
+#endif /*NO_LOCALE_CACHE*/
+#else  /*USE_LOCALE}{*/
+#define dplen 1
+#endif /*USE_LOCALE}}*/
+

 #ifdef Honor_FLT_ROUNDS /*{*/
        int Rounding;
 #ifdef Trust_FLT_ROUNDS /*{{ only define this if FLT_ROUNDS really works! */
 #ifdef Honor_FLT_ROUNDS /*{*/
        int Rounding;
 #ifdef Trust_FLT_ROUNDS /*{{ only define this if FLT_ROUNDS really works! */


@@ -109,7 +116,7 @@ strtod
 #endif /*}*/
 
        sign = nz0 = nz = decpt = 0;
 #endif /*}*/
 
        sign = nz0 = nz = decpt = 0;

-       dval(rv) = 0.;
+       dval(&rv) = 0.;

        for(s = s00;;s++) switch(*s) {
                case '-':
                        sign = 1;
        for(s = s00;;s++) switch(*s) {
                case '-':
                        sign = 1;


@@ -141,20 +148,12 @@ strtod
                  case 'x':
                  case 'X':
                        {
                  case 'x':
                  case 'X':
                        {

-#if defined(FE_DOWNWARD) && defined(FE_TONEAREST) && defined(FE_TOWARDZERO) && defined(FE_UPWARD) /*{{*/
+#ifdef Honor_FLT_ROUNDS

                        FPI fpi1 = fpi;
                        FPI fpi1 = fpi;

-#ifdef Honor_FLT_ROUNDS /*{{*/

                        fpi1.rounding = Rounding;
                        fpi1.rounding = Rounding;

-#else /*}{*/
-                       switch(fegetround()) {
-                         case FE_TOWARDZERO:   fpi1.rounding = 0; break;
-                         case FE_UPWARD:       fpi1.rounding = 2; break;
-                         case FE_DOWNWARD:     fpi1.rounding = 3;
-                         }
-#endif /*}}*/
-#else /*}{*/
+#else

 #define fpi1 fpi
 #define fpi1 fpi

-#endif /*}}*/
+#endif

                        switch((i = gethex(&s, &fpi1, &exp, &bb, sign)) & STRTOG_Retmask) {
                          case STRTOG_NoNumber:
                                s = s00;
                        switch((i = gethex(&s, &fpi1, &exp, &bb, sign)) & STRTOG_Retmask) {
                          case STRTOG_NoNumber:
                                s = s00;


@@ -279,8 +278,8 @@ strtod
                                        --s;
                                        if (!match(&s,"inity"))
                                                ++s;
                                        --s;
                                        if (!match(&s,"inity"))
                                                ++s;

-                                       word0(rv) = 0x7ff00000;
-                                       word1(rv) = 0;
+                                       word0(&rv) = 0x7ff00000;
+                                       word1(&rv) = 0;

                                        goto ret;
                                        }
                                break;
                                        goto ret;
                                        }
                                break;


@@ -291,13 +290,13 @@ strtod
                                        if (*s == '(' /*)*/
                                         && hexnan(&s, &fpinan, bits)
                                                        == STRTOG_NaNbits) {
                                        if (*s == '(' /*)*/
                                         && hexnan(&s, &fpinan, bits)
                                                        == STRTOG_NaNbits) {

-                                               word0(rv) = 0x7ff00000 | bits[1];
-                                               word1(rv) = bits[0];
+                                               word0(&rv) = 0x7ff00000 | bits[1];
+                                               word1(&rv) = bits[0];

                                                }
                                        else {
 #endif
                                                }
                                        else {
 #endif

-                                               word0(rv) = NAN_WORD0;
-                                               word1(rv) = NAN_WORD1;
+                                               word0(&rv) = NAN_WORD0;
+                                               word1(&rv) = NAN_WORD1;

 #ifndef No_Hex_NaN
                                                }
 #endif
 #ifndef No_Hex_NaN
                                                }
 #endif


@@ -321,13 +320,13 @@ strtod
        if (!nd0)
                nd0 = nd;
        k = nd < DBL_DIG + 1 ? nd : DBL_DIG + 1;
        if (!nd0)
                nd0 = nd;
        k = nd < DBL_DIG + 1 ? nd : DBL_DIG + 1;

-       dval(rv) = y;
+       dval(&rv) = y;

        if (k > 9) {
 #ifdef SET_INEXACT
                if (k > DBL_DIG)
                        oldinexact = get_inexact();
 #endif
        if (k > 9) {
 #ifdef SET_INEXACT
                if (k > DBL_DIG)
                        oldinexact = get_inexact();
 #endif

-               dval(rv) = tens[k - 9] * dval(rv) + z;
+               dval(&rv) = tens[k - 9] * dval(&rv) + z;

                }
        bd0 = 0;
        if (nd <= DBL_DIG
                }
        bd0 = 0;
        if (nd <= DBL_DIG


@@ -351,7 +350,7 @@ strtod
                                        sign = 0;
                                        }
 #endif
                                        sign = 0;
                                        }
 #endif

-                               /* rv = */ rounded_product(dval(rv), tens[e]);
+                               /* rv = */ rounded_product(dval(&rv), tens[e]);

                                goto ret;
 #endif
                                }
                                goto ret;
 #endif
                                }


@@ -368,20 +367,20 @@ strtod
                                        }
 #endif
                                e -= i;
                                        }
 #endif
                                e -= i;

-                               dval(rv) *= tens[i];
+                               dval(&rv) *= tens[i];

 #ifdef VAX
                                /* VAX exponent range is so narrow we must
                                 * worry about overflow here...
                                 */
  vax_ovfl_check:
 #ifdef VAX
                                /* VAX exponent range is so narrow we must
                                 * worry about overflow here...
                                 */
  vax_ovfl_check:

-                               word0(rv) -= P*Exp_msk1;
-                               /* rv = */ rounded_product(dval(rv), tens[e]);
-                               if ((word0(rv) & Exp_mask)
+                               word0(&rv) -= P*Exp_msk1;
+                               /* rv = */ rounded_product(dval(&rv), tens[e]);
+                               if ((word0(&rv) & Exp_mask)

                                 > Exp_msk1*(DBL_MAX_EXP+Bias-1-P))
                                        goto ovfl;
                                 > Exp_msk1*(DBL_MAX_EXP+Bias-1-P))
                                        goto ovfl;

-                               word0(rv) += P*Exp_msk1;
+                               word0(&rv) += P*Exp_msk1;

 #else
 #else

-                               /* rv = */ rounded_product(dval(rv), tens[e]);
+                               /* rv = */ rounded_product(dval(&rv), tens[e]);

 #endif
                                goto ret;
                                }
 #endif
                                goto ret;
                                }


@@ -395,7 +394,7 @@ strtod
                                sign = 0;
                                }
 #endif
                                sign = 0;
                                }
 #endif

-                       /* rv = */ rounded_quotient(dval(rv), tens[-e]);
+                       /* rv = */ rounded_quotient(dval(&rv), tens[-e]);

                        goto ret;
                        }
 #endif
                        goto ret;
                        }
 #endif


@@ -426,7 +425,7 @@ strtod
 
        if (e1 > 0) {
                if ( (i = e1 & 15) !=0)
 
        if (e1 > 0) {
                if ( (i = e1 & 15) !=0)

-                       dval(rv) *= tens[i];
+                       dval(&rv) *= tens[i];

                if (e1 &= ~15) {
                        if (e1 > DBL_MAX_10_EXP) {
  ovfl:
                if (e1 &= ~15) {
                        if (e1 > DBL_MAX_10_EXP) {
  ovfl:


@@ -439,25 +438,25 @@ strtod
                                switch(Rounding) {
                                  case 0: /* toward 0 */
                                  case 3: /* toward -infinity */
                                switch(Rounding) {
                                  case 0: /* toward 0 */
                                  case 3: /* toward -infinity */

-                                       word0(rv) = Big0;
-                                       word1(rv) = Big1;
+                                       word0(&rv) = Big0;
+                                       word1(&rv) = Big1;

                                        break;
                                  default:
                                        break;
                                  default:

-                                       word0(rv) = Exp_mask;
-                                       word1(rv) = 0;
+                                       word0(&rv) = Exp_mask;
+                                       word1(&rv) = 0;

                                  }
 #else /*Honor_FLT_ROUNDS*/
                                  }
 #else /*Honor_FLT_ROUNDS*/

-                               word0(rv) = Exp_mask;
-                               word1(rv) = 0;
+                               word0(&rv) = Exp_mask;
+                               word1(&rv) = 0;

 #endif /*Honor_FLT_ROUNDS*/
 #ifdef SET_INEXACT
                                /* set overflow bit */
 #endif /*Honor_FLT_ROUNDS*/
 #ifdef SET_INEXACT
                                /* set overflow bit */

-                               dval(rv0) = 1e300;
-                               dval(rv0) *= dval(rv0);
+                               dval(&rv0) = 1e300;
+                               dval(&rv0) *= dval(&rv0);

 #endif
 #else /*IEEE_Arith*/
 #endif
 #else /*IEEE_Arith*/

-                               word0(rv) = Big0;
-                               word1(rv) = Big1;
+                               word0(&rv) = Big0;
+                               word1(&rv) = Big1;

 #endif /*IEEE_Arith*/
                                if (bd0)
                                        goto retfree;
 #endif /*IEEE_Arith*/
                                if (bd0)
                                        goto retfree;


@@ -466,27 +465,27 @@ strtod
                        e1 >>= 4;
                        for(j = 0; e1 > 1; j++, e1 >>= 1)
                                if (e1 & 1)
                        e1 >>= 4;
                        for(j = 0; e1 > 1; j++, e1 >>= 1)
                                if (e1 & 1)

-                                       dval(rv) *= bigtens[j];
+                                       dval(&rv) *= bigtens[j];

                /* The last multiplication could overflow. */
                /* The last multiplication could overflow. */

-                       word0(rv) -= P*Exp_msk1;
-                       dval(rv) *= bigtens[j];
-                       if ((z = word0(rv) & Exp_mask)
+                       word0(&rv) -= P*Exp_msk1;
+                       dval(&rv) *= bigtens[j];
+                       if ((z = word0(&rv) & Exp_mask)

                         > Exp_msk1*(DBL_MAX_EXP+Bias-P))
                                goto ovfl;
                        if (z > Exp_msk1*(DBL_MAX_EXP+Bias-1-P)) {
                                /* set to largest number */
                                /* (Can't trust DBL_MAX) */
                         > Exp_msk1*(DBL_MAX_EXP+Bias-P))
                                goto ovfl;
                        if (z > Exp_msk1*(DBL_MAX_EXP+Bias-1-P)) {
                                /* set to largest number */
                                /* (Can't trust DBL_MAX) */

-                               word0(rv) = Big0;
-                               word1(rv) = Big1;
+                               word0(&rv) = Big0;
+                               word1(&rv) = Big1;

                                }
                        else
                                }
                        else

-                               word0(rv) += P*Exp_msk1;
+                               word0(&rv) += P*Exp_msk1;

                        }
                }
        else if (e1 < 0) {
                e1 = -e1;
                if ( (i = e1 & 15) !=0)
                        }
                }
        else if (e1 < 0) {
                e1 = -e1;
                if ( (i = e1 & 15) !=0)

-                       dval(rv) /= tens[i];
+                       dval(&rv) /= tens[i];

                if (e1 >>= 4) {
                        if (e1 >= 1 << n_bigtens)
                                goto undfl;
                if (e1 >>= 4) {
                        if (e1 >= 1 << n_bigtens)
                                goto undfl;


@@ -495,34 +494,34 @@ strtod
                                scale = 2*P;
                        for(j = 0; e1 > 0; j++, e1 >>= 1)
                                if (e1 & 1)
                                scale = 2*P;
                        for(j = 0; e1 > 0; j++, e1 >>= 1)
                                if (e1 & 1)

-                                       dval(rv) *= tinytens[j];
-                       if (scale && (j = 2*P + 1 - ((word0(rv) & Exp_mask)
+                                       dval(&rv) *= tinytens[j];
+                       if (scale && (j = 2*P + 1 - ((word0(&rv) & Exp_mask)

                                                >> Exp_shift)) > 0) {
                                /* scaled rv is denormal; zap j low bits */
                                if (j >= 32) {
                                                >> Exp_shift)) > 0) {
                                /* scaled rv is denormal; zap j low bits */
                                if (j >= 32) {

-                                       word1(rv) = 0;
+                                       word1(&rv) = 0;

                                        if (j >= 53)
                                        if (j >= 53)

-                                        word0(rv) = (P+2)*Exp_msk1;
+                                        word0(&rv) = (P+2)*Exp_msk1;

                                        else
                                        else

-                                        word0(rv) &= 0xffffffff << j-32;
+                                        word0(&rv) &= 0xffffffff << (j-32);

                                        }
                                else
                                        }
                                else

-                                       word1(rv) &= 0xffffffff << j;
+                                       word1(&rv) &= 0xffffffff << j;

                                }
 #else
                        for(j = 0; e1 > 1; j++, e1 >>= 1)
                                if (e1 & 1)
                                }
 #else
                        for(j = 0; e1 > 1; j++, e1 >>= 1)
                                if (e1 & 1)

-                                       dval(rv) *= tinytens[j];
+                                       dval(&rv) *= tinytens[j];

                        /* The last multiplication could underflow. */
                        /* The last multiplication could underflow. */

-                       dval(rv0) = dval(rv);
-                       dval(rv) *= tinytens[j];
-                       if (!dval(rv)) {
-                               dval(rv) = 2.*dval(rv0);
-                               dval(rv) *= tinytens[j];
+                       dval(&rv0) = dval(&rv);
+                       dval(&rv) *= tinytens[j];
+                       if (!dval(&rv)) {
+                               dval(&rv) = 2.*dval(&rv0);
+                               dval(&rv) *= tinytens[j];

 #endif
 #endif

-                               if (!dval(rv)) {
+                               if (!dval(&rv)) {

  undfl:
  undfl:

-                                       dval(rv) = 0.;
+                                       dval(&rv) = 0.;

 #ifndef NO_ERRNO
                                        errno = ERANGE;
 #endif
 #ifndef NO_ERRNO
                                        errno = ERANGE;
 #endif


@@ -531,8 +530,8 @@ strtod
                                        goto ret;
                                        }
 #ifndef Avoid_Underflow
                                        goto ret;
                                        }
 #ifndef Avoid_Underflow

-                               word0(rv) = Tiny0;
-                               word1(rv) = Tiny1;
+                               word0(&rv) = Tiny0;
+                               word1(&rv) = Tiny1;

                                /* The refinement below will clean
                                 * this approximation up.
                                 */
                                /* The refinement below will clean
                                 * this approximation up.
                                 */


@@ -545,12 +544,12 @@ strtod
 
        /* Put digits into bd: true value = bd * 10^e */
 
 
        /* Put digits into bd: true value = bd * 10^e */
 

-       bd0 = s2b(s0, nd0, nd, y);
+       bd0 = s2b(s0, nd0, nd, y, dplen);

 
        for(;;) {
                bd = Balloc(bd0->k);
                Bcopy(bd, bd0);
 
        for(;;) {
                bd = Balloc(bd0->k);
                Bcopy(bd, bd0);

-               bb = d2b(dval(rv), &bbe, &bbbits);      /* rv = bb * 2^bbe */
+               bb = d2b(dval(&rv), &bbe, &bbbits);     /* rv = bb * 2^bbe */

                bs = i2b(1);
 
                if (e >= 0) {
                bs = i2b(1);
 
                if (e >= 0) {


@@ -572,7 +571,7 @@ strtod
 #endif
 #ifdef Avoid_Underflow
                j = bbe - scale;
 #endif
 #ifdef Avoid_Underflow
                j = bbe - scale;

-               i = j + bbbits - 1;     /* logb(rv) */
+               i = j + bbbits - 1;     /* logb(&rv) */

                if (i < Emin)   /* denormal */
                        j += P - Emin;
                else
                if (i < Emin)   /* denormal */
                        j += P - Emin;
                else


@@ -586,7 +585,7 @@ strtod
 #endif
 #else /*Sudden_Underflow*/
                j = bbe;
 #endif
 #else /*Sudden_Underflow*/
                j = bbe;

-               i = j + bbbits - 1;     /* logb(rv) */
+               i = j + bbbits - 1;     /* logb(&rv) */

                if (i < Emin)   /* denormal */
                        j += P - Emin;
                else
                if (i < Emin)   /* denormal */
                        j += P - Emin;
                else


@@ -637,15 +636,15 @@ strtod
                                        }
                                if (Rounding) {
                                        if (dsign) {
                                        }
                                if (Rounding) {
                                        if (dsign) {

-                                               adj = 1.;
+                                               dval(&adj) = 1.;

                                                goto apply_adj;
                                                }
                                        }
                                else if (!dsign) {
                                                goto apply_adj;
                                                }
                                        }
                                else if (!dsign) {

-                                       adj = -1.;
-                                       if (!word1(rv)
-                                        && !(word0(rv) & Frac_mask)) {
-                                               y = word0(rv) & Exp_mask;
+                                       dval(&adj) = -1.;
+                                       if (!word1(&rv)
+                                        && !(word0(&rv) & Frac_mask)) {
+                                               y = word0(&rv) & Exp_mask;

 #ifdef Avoid_Underflow
                                                if (!scale || y > 2*P*Exp_msk1)
 #else
 #ifdef Avoid_Underflow
                                                if (!scale || y > 2*P*Exp_msk1)
 #else


@@ -654,66 +653,66 @@ strtod
                                                  {
                                                  delta = lshift(delta,Log2P);
                                                  if (cmp(delta, bs) <= 0)
                                                  {
                                                  delta = lshift(delta,Log2P);
                                                  if (cmp(delta, bs) <= 0)

-                                                       adj = -0.5;
+                                                       dval(&adj) = -0.5;

                                                  }
                                                }
  apply_adj:
 #ifdef Avoid_Underflow
                                                  }
                                                }
  apply_adj:
 #ifdef Avoid_Underflow

-                                       if (scale && (y = word0(rv) & Exp_mask)
+                                       if (scale && (y = word0(&rv) & Exp_mask)

                                                <= 2*P*Exp_msk1)
                                                <= 2*P*Exp_msk1)

-                                         word0(adj) += (2*P+1)*Exp_msk1 - y;
+                                         word0(&adj) += (2*P+1)*Exp_msk1 - y;

 #else
 #ifdef Sudden_Underflow
 #else
 #ifdef Sudden_Underflow

-                                       if ((word0(rv) & Exp_mask) <=
+                                       if ((word0(&rv) & Exp_mask) <=

                                                        P*Exp_msk1) {
                                                        P*Exp_msk1) {

-                                               word0(rv) += P*Exp_msk1;
-                                               dval(rv) += adj*ulp(dval(rv));
-                                               word0(rv) -= P*Exp_msk1;
+                                               word0(&rv) += P*Exp_msk1;
+                                               dval(&rv) += adj*ulp(&rv);
+                                               word0(&rv) -= P*Exp_msk1;

                                                }
                                        else
 #endif /*Sudden_Underflow*/
 #endif /*Avoid_Underflow*/
                                                }
                                        else
 #endif /*Sudden_Underflow*/
 #endif /*Avoid_Underflow*/

-                                       dval(rv) += adj*ulp(dval(rv));
+                                       dval(&rv) += adj*ulp(&rv);

                                        }
                                break;
                                }
                                        }
                                break;
                                }

-                       adj = ratio(delta, bs);
+                       dval(&adj) = ratio(delta, bs);

                        if (adj < 1.)
                        if (adj < 1.)

-                               adj = 1.;
+                               dval(&adj) = 1.;

                        if (adj <= 0x7ffffffe) {
                        if (adj <= 0x7ffffffe) {

-                               /* adj = Rounding ? ceil(adj) : floor(adj); */
+                               /* dval(&adj) = Rounding ? ceil(&adj) : floor(&adj); */

                                y = adj;
                                if (y != adj) {
                                        if (!((Rounding>>1) ^ dsign))
                                                y++;
                                y = adj;
                                if (y != adj) {
                                        if (!((Rounding>>1) ^ dsign))
                                                y++;

-                                       adj = y;
+                                       dval(&adj) = y;

                                        }
                                }
 #ifdef Avoid_Underflow
                                        }
                                }
 #ifdef Avoid_Underflow

-                       if (scale && (y = word0(rv) & Exp_mask) <= 2*P*Exp_msk1)
-                               word0(adj) += (2*P+1)*Exp_msk1 - y;
+                       if (scale && (y = word0(&rv) & Exp_mask) <= 2*P*Exp_msk1)
+                               word0(&adj) += (2*P+1)*Exp_msk1 - y;

 #else
 #ifdef Sudden_Underflow
 #else
 #ifdef Sudden_Underflow

-                       if ((word0(rv) & Exp_mask) <= P*Exp_msk1) {
-                               word0(rv) += P*Exp_msk1;
-                               adj *= ulp(dval(rv));
+                       if ((word0(&rv) & Exp_mask) <= P*Exp_msk1) {
+                               word0(&rv) += P*Exp_msk1;
+                               dval(&adj) *= ulp(&rv);

                                if (dsign)
                                if (dsign)

-                                       dval(rv) += adj;
+                                       dval(&rv) += adj;

                                else
                                else

-                                       dval(rv) -= adj;
-                               word0(rv) -= P*Exp_msk1;
+                                       dval(&rv) -= adj;
+                               word0(&rv) -= P*Exp_msk1;

                                goto cont;
                                }
 #endif /*Sudden_Underflow*/
 #endif /*Avoid_Underflow*/
                                goto cont;
                                }
 #endif /*Sudden_Underflow*/
 #endif /*Avoid_Underflow*/

-                       adj *= ulp(dval(rv));
+                       dval(&adj) *= ulp(&rv);

                        if (dsign) {
                        if (dsign) {

-                               if (word0(rv) == Big0 && word1(rv) == Big1)
+                               if (word0(&rv) == Big0 && word1(&rv) == Big1)

                                        goto ovfl;
                                        goto ovfl;

-                               dval(rv) += adj;
+                               dval(&rv) += adj;

                                }
                        else
                                }
                        else

-                               dval(rv) -= adj;
+                               dval(&rv) -= adj;

                        goto cont;
                        }
 #endif /*Honor_FLT_ROUNDS*/
                        goto cont;
                        }
 #endif /*Honor_FLT_ROUNDS*/


@@ -722,12 +721,12 @@ strtod
                        /* Error is less than half an ulp -- check for
                         * special case of mantissa a power of two.
                         */
                        /* Error is less than half an ulp -- check for
                         * special case of mantissa a power of two.
                         */

-                       if (dsign || word1(rv) || word0(rv) & Bndry_mask
+                       if (dsign || word1(&rv) || word0(&rv) & Bndry_mask

 #ifdef IEEE_Arith
 #ifdef Avoid_Underflow
 #ifdef IEEE_Arith
 #ifdef Avoid_Underflow

-                        || (word0(rv) & Exp_mask) <= (2*P+1)*Exp_msk1
+                        || (word0(&rv) & Exp_mask) <= (2*P+1)*Exp_msk1

 #else
 #else

-                        || (word0(rv) & Exp_mask) <= Exp_msk1
+                        || (word0(&rv) & Exp_mask) <= Exp_msk1

 #endif
 #endif
                                ) {
 #endif
 #endif
                                ) {


@@ -752,32 +751,32 @@ strtod
                if (i == 0) {
                        /* exactly half-way between */
                        if (dsign) {
                if (i == 0) {
                        /* exactly half-way between */
                        if (dsign) {

-                               if ((word0(rv) & Bndry_mask1) == Bndry_mask1
-                                &&  word1(rv) == (
+                               if ((word0(&rv) & Bndry_mask1) == Bndry_mask1
+                                &&  word1(&rv) == (

 #ifdef Avoid_Underflow
 #ifdef Avoid_Underflow

-                       (scale && (y = word0(rv) & Exp_mask) <= 2*P*Exp_msk1)
+                       (scale && (y = word0(&rv) & Exp_mask) <= 2*P*Exp_msk1)

                ? (0xffffffff & (0xffffffff << (2*P+1-(y>>Exp_shift)))) :
 #endif
                                                   0xffffffff)) {
                                        /*boundary case -- increment exponent*/
                ? (0xffffffff & (0xffffffff << (2*P+1-(y>>Exp_shift)))) :
 #endif
                                                   0xffffffff)) {
                                        /*boundary case -- increment exponent*/

-                                       word0(rv) = (word0(rv) & Exp_mask)
+                                       word0(&rv) = (word0(&rv) & Exp_mask)

                                                + Exp_msk1
 #ifdef IBM
                                                | Exp_msk1 >> 4
 #endif
                                                ;
                                                + Exp_msk1
 #ifdef IBM
                                                | Exp_msk1 >> 4
 #endif
                                                ;

-                                       word1(rv) = 0;
+                                       word1(&rv) = 0;

 #ifdef Avoid_Underflow
                                        dsign = 0;
 #endif
                                        break;
                                        }
                                }
 #ifdef Avoid_Underflow
                                        dsign = 0;
 #endif
                                        break;
                                        }
                                }

-                       else if (!(word0(rv) & Bndry_mask) && !word1(rv)) {
+                       else if (!(word0(&rv) & Bndry_mask) && !word1(&rv)) {

  drop_down:
                                /* boundary case -- decrement exponent */
 #ifdef Sudden_Underflow /*{{*/
  drop_down:
                                /* boundary case -- decrement exponent */
 #ifdef Sudden_Underflow /*{{*/

-                               L = word0(rv) & Exp_mask;
+                               L = word0(&rv) & Exp_mask;

 #ifdef IBM
                                if (L <  Exp_msk1)
 #else
 #ifdef IBM
                                if (L <  Exp_msk1)
 #else


@@ -792,7 +791,7 @@ strtod
 #else /*Sudden_Underflow}{*/
 #ifdef Avoid_Underflow
                                if (scale) {
 #else /*Sudden_Underflow}{*/
 #ifdef Avoid_Underflow
                                if (scale) {

-                                       L = word0(rv) & Exp_mask;
+                                       L = word0(&rv) & Exp_mask;

                                        if (L <= (2*P+1)*Exp_msk1) {
                                                if (L > (P+2)*Exp_msk1)
                                                        /* round even ==> */
                                        if (L <= (2*P+1)*Exp_msk1) {
                                                if (L > (P+2)*Exp_msk1)
                                                        /* round even ==> */


@@ -803,10 +802,10 @@ strtod
                                                }
                                        }
 #endif /*Avoid_Underflow*/
                                                }
                                        }
 #endif /*Avoid_Underflow*/

-                               L = (word0(rv) & Exp_mask) - Exp_msk1;
+                               L = (word0(&rv) & Exp_mask) - Exp_msk1;

 #endif /*Sudden_Underflow}}*/
 #endif /*Sudden_Underflow}}*/

-                               word0(rv) = L | Bndry_mask1;
-                               word1(rv) = 0xffffffff;
+                               word0(&rv) = L | Bndry_mask1;
+                               word1(&rv) = 0xffffffff;

 #ifdef IBM
                                goto cont;
 #else
 #ifdef IBM
                                goto cont;
 #else


@@ -814,16 +813,16 @@ strtod
 #endif
                                }
 #ifndef ROUND_BIASED
 #endif
                                }
 #ifndef ROUND_BIASED

-                       if (!(word1(rv) & LSB))
+                       if (!(word1(&rv) & LSB))

                                break;
 #endif
                        if (dsign)
                                break;
 #endif
                        if (dsign)

-                               dval(rv) += ulp(dval(rv));
+                               dval(&rv) += ulp(&rv);

 #ifndef ROUND_BIASED
                        else {
 #ifndef ROUND_BIASED
                        else {

-                               dval(rv) -= ulp(dval(rv));
+                               dval(&rv) -= ulp(&rv);

 #ifndef Sudden_Underflow
 #ifndef Sudden_Underflow

-                               if (!dval(rv))
+                               if (!dval(&rv))

                                        goto undfl;
 #endif
                                }
                                        goto undfl;
 #endif
                                }


@@ -835,14 +834,14 @@ strtod
                        }
                if ((aadj = ratio(delta, bs)) <= 2.) {
                        if (dsign)
                        }
                if ((aadj = ratio(delta, bs)) <= 2.) {
                        if (dsign)

-                               aadj = aadj1 = 1.;
-                       else if (word1(rv) || word0(rv) & Bndry_mask) {
+                               aadj = dval(&aadj1) = 1.;
+                       else if (word1(&rv) || word0(&rv) & Bndry_mask) {

 #ifndef Sudden_Underflow
 #ifndef Sudden_Underflow

-                               if (word1(rv) == Tiny1 && !word0(rv))
+                               if (word1(&rv) == Tiny1 && !word0(&rv))

                                        goto undfl;
 #endif
                                aadj = 1.;
                                        goto undfl;
 #endif
                                aadj = 1.;

-                               aadj1 = -1.;
+                               dval(&aadj1) = -1.;

                                }
                        else {
                                /* special case -- power of FLT_RADIX to be */
                                }
                        else {
                                /* special case -- power of FLT_RADIX to be */


@@ -852,45 +851,45 @@ strtod
                                        aadj = 1./FLT_RADIX;
                                else
                                        aadj *= 0.5;
                                        aadj = 1./FLT_RADIX;
                                else
                                        aadj *= 0.5;

-                               aadj1 = -aadj;
+                               dval(&aadj1) = -aadj;

                                }
                        }
                else {
                        aadj *= 0.5;
                                }
                        }
                else {
                        aadj *= 0.5;

-                       aadj1 = dsign ? aadj : -aadj;
+                       dval(&aadj1) = dsign ? aadj : -aadj;

 #ifdef Check_FLT_ROUNDS
                        switch(Rounding) {
                                case 2: /* towards +infinity */
 #ifdef Check_FLT_ROUNDS
                        switch(Rounding) {
                                case 2: /* towards +infinity */

-                                       aadj1 -= 0.5;
+                                       dval(&aadj1) -= 0.5;

                                        break;
                                case 0: /* towards 0 */
                                case 3: /* towards -infinity */
                                        break;
                                case 0: /* towards 0 */
                                case 3: /* towards -infinity */

-                                       aadj1 += 0.5;
+                                       dval(&aadj1) += 0.5;

                                }
 #else
                        if (Flt_Rounds == 0)
                                }
 #else
                        if (Flt_Rounds == 0)

-                               aadj1 += 0.5;
+                               dval(&aadj1) += 0.5;

 #endif /*Check_FLT_ROUNDS*/
                        }
 #endif /*Check_FLT_ROUNDS*/
                        }

-               y = word0(rv) & Exp_mask;
+               y = word0(&rv) & Exp_mask;

 
                /* Check for overflow */
 
                if (y == Exp_msk1*(DBL_MAX_EXP+Bias-1)) {
 
                /* Check for overflow */
 
                if (y == Exp_msk1*(DBL_MAX_EXP+Bias-1)) {

-                       dval(rv0) = dval(rv);
-                       word0(rv) -= P*Exp_msk1;
-                       adj = aadj1 * ulp(dval(rv));
-                       dval(rv) += adj;
-                       if ((word0(rv) & Exp_mask) >=
+                       dval(&rv0) = dval(&rv);
+                       word0(&rv) -= P*Exp_msk1;
+                       dval(&adj) = dval(&aadj1) * ulp(&rv);
+                       dval(&rv) += dval(&adj);
+                       if ((word0(&rv) & Exp_mask) >=

                                        Exp_msk1*(DBL_MAX_EXP+Bias-P)) {
                                        Exp_msk1*(DBL_MAX_EXP+Bias-P)) {

-                               if (word0(rv0) == Big0 && word1(rv0) == Big1)
+                               if (word0(&rv0) == Big0 && word1(&rv0) == Big1)

                                        goto ovfl;
                                        goto ovfl;

-                               word0(rv) = Big0;
-                               word1(rv) = Big1;
+                               word0(&rv) = Big0;
+                               word1(&rv) = Big1;

                                goto cont;
                                }
                        else
                                goto cont;
                                }
                        else

-                               word0(rv) += P*Exp_msk1;
+                               word0(&rv) += P*Exp_msk1;

                        }
                else {
 #ifdef Avoid_Underflow
                        }
                else {
 #ifdef Avoid_Underflow


@@ -899,58 +898,58 @@ strtod
                                        if ((z = aadj) <= 0)
                                                z = 1;
                                        aadj = z;
                                        if ((z = aadj) <= 0)
                                                z = 1;
                                        aadj = z;

-                                       aadj1 = dsign ? aadj : -aadj;
+                                       dval(&aadj1) = dsign ? aadj : -aadj;

                                        }
                                        }

-                               word0(aadj1) += (2*P+1)*Exp_msk1 - y;
+                               word0(&aadj1) += (2*P+1)*Exp_msk1 - y;

                                }
                                }

-                       adj = aadj1 * ulp(dval(rv));
-                       dval(rv) += adj;
+                       dval(&adj) = dval(&aadj1) * ulp(&rv);
+                       dval(&rv) += dval(&adj);

 #else
 #ifdef Sudden_Underflow
 #else
 #ifdef Sudden_Underflow

-                       if ((word0(rv) & Exp_mask) <= P*Exp_msk1) {
-                               dval(rv0) = dval(rv);
-                               word0(rv) += P*Exp_msk1;
-                               adj = aadj1 * ulp(dval(rv));
-                               dval(rv) += adj;
+                       if ((word0(&rv) & Exp_mask) <= P*Exp_msk1) {
+                               dval(&rv0) = dval(&rv);
+                               word0(&rv) += P*Exp_msk1;
+                               dval(&adj) = dval(&aadj1) * ulp(&rv);
+                               dval(&rv) += adj;

 #ifdef IBM
 #ifdef IBM

-                               if ((word0(rv) & Exp_mask) <  P*Exp_msk1)
+                               if ((word0(&rv) & Exp_mask) <  P*Exp_msk1)

 #else
 #else

-                               if ((word0(rv) & Exp_mask) <= P*Exp_msk1)
+                               if ((word0(&rv) & Exp_mask) <= P*Exp_msk1)

 #endif
                                        {
 #endif
                                        {

-                                       if (word0(rv0) == Tiny0
-                                        && word1(rv0) == Tiny1)
+                                       if (word0(&rv0) == Tiny0
+                                        && word1(&rv0) == Tiny1)

                                                goto undfl;
                                                goto undfl;

-                                       word0(rv) = Tiny0;
-                                       word1(rv) = Tiny1;
+                                       word0(&rv) = Tiny0;
+                                       word1(&rv) = Tiny1;

                                        goto cont;
                                        }
                                else
                                        goto cont;
                                        }
                                else

-                                       word0(rv) -= P*Exp_msk1;
+                                       word0(&rv) -= P*Exp_msk1;

                                }
                        else {
                                }
                        else {

-                               adj = aadj1 * ulp(dval(rv));
-                               dval(rv) += adj;
+                               dval(&adj) = dval(&aadj1) * ulp(&rv);
+                               dval(&rv) += adj;

                                }
 #else /*Sudden_Underflow*/
                                }
 #else /*Sudden_Underflow*/

-                       /* Compute adj so that the IEEE rounding rules will
-                        * correctly round rv + adj in some half-way cases.
-                        * If rv * ulp(rv) is denormalized (i.e.,
+                       /* Compute dval(&adj) so that the IEEE rounding rules will
+                        * correctly round rv + dval(&adj) in some half-way cases.
+                        * If rv * ulp(&rv) is denormalized (i.e.,

                         * y <= (P-1)*Exp_msk1), we must adjust aadj to avoid
                         * trouble from bits lost to denormalization;
                         * example: 1.2e-307 .
                         */
                        if (y <= (P-1)*Exp_msk1 && aadj > 1.) {
                         * y <= (P-1)*Exp_msk1), we must adjust aadj to avoid
                         * trouble from bits lost to denormalization;
                         * example: 1.2e-307 .
                         */
                        if (y <= (P-1)*Exp_msk1 && aadj > 1.) {

-                               aadj1 = (double)(int)(aadj + 0.5);
+                               dval(&aadj1) = (double)(int)(aadj + 0.5);

                                if (!dsign)
                                if (!dsign)

-                                       aadj1 = -aadj1;
+                                       dval(&aadj1) = -dval(&aadj1);

                                }
                                }

-                       adj = aadj1 * ulp(dval(rv));
-                       dval(rv) += adj;
+                       dval(&adj) = dval(&aadj1) * ulp(&rv);
+                       dval(&rv) += adj;

 #endif /*Sudden_Underflow*/
 #endif /*Avoid_Underflow*/
                        }
 #endif /*Sudden_Underflow*/
 #endif /*Avoid_Underflow*/
                        }

-               z = word0(rv) & Exp_mask;
+               z = word0(&rv) & Exp_mask;

 #ifndef SET_INEXACT
 #ifdef Avoid_Underflow
                if (!scale)
 #ifndef SET_INEXACT
 #ifdef Avoid_Underflow
                if (!scale)


@@ -960,7 +959,7 @@ strtod
                        L = (Long)aadj;
                        aadj -= L;
                        /* The tolerances below are conservative. */
                        L = (Long)aadj;
                        aadj -= L;
                        /* The tolerances below are conservative. */

-                       if (dsign || word1(rv) || word0(rv) & Bndry_mask) {
+                       if (dsign || word1(&rv) || word0(&rv) & Bndry_mask) {

                                if (aadj < .4999999 || aadj > .5000001)
                                        break;
                                }
                                if (aadj < .4999999 || aadj > .5000001)
                                        break;
                                }


@@ -977,9 +976,9 @@ strtod
 #ifdef SET_INEXACT
        if (inexact) {
                if (!oldinexact) {
 #ifdef SET_INEXACT
        if (inexact) {
                if (!oldinexact) {

-                       word0(rv0) = Exp_1 + (70 << Exp_shift);
-                       word1(rv0) = 0;
-                       dval(rv0) += 1.;
+                       word0(&rv0) = Exp_1 + (70 << Exp_shift);
+                       word1(&rv0) = 0;
+                       dval(&rv0) += 1.;

                        }
                }
        else if (!oldinexact)
                        }
                }
        else if (!oldinexact)


@@ -987,25 +986,25 @@ strtod
 #endif
 #ifdef Avoid_Underflow
        if (scale) {
 #endif
 #ifdef Avoid_Underflow
        if (scale) {

-               word0(rv0) = Exp_1 - 2*P*Exp_msk1;
-               word1(rv0) = 0;
-               dval(rv) *= dval(rv0);
+               word0(&rv0) = Exp_1 - 2*P*Exp_msk1;
+               word1(&rv0) = 0;
+               dval(&rv) *= dval(&rv0);

 #ifndef NO_ERRNO
                /* try to avoid the bug of testing an 8087 register value */
 #ifdef IEEE_Arith
 #ifndef NO_ERRNO
                /* try to avoid the bug of testing an 8087 register value */
 #ifdef IEEE_Arith

-               if (!(word0(rv) & Exp_mask))
+               if (!(word0(&rv) & Exp_mask))

 #else
 #else

-               if (word0(rv) == 0 && word1(rv) == 0)
+               if (word0(&rv) == 0 && word1(&rv) == 0)

 #endif
                        errno = ERANGE;
 #endif
                }
 #endif /* Avoid_Underflow */
 #ifdef SET_INEXACT
 #endif
                        errno = ERANGE;
 #endif
                }
 #endif /* Avoid_Underflow */
 #ifdef SET_INEXACT

-       if (inexact && !(word0(rv) & Exp_mask)) {
+       if (inexact && !(word0(&rv) & Exp_mask)) {

                /* set underflow bit */
                /* set underflow bit */

-               dval(rv0) = 1e-300;
-               dval(rv0) *= dval(rv0);
+               dval(&rv0) = 1e-300;
+               dval(&rv0) *= dval(&rv0);

                }
 #endif
  retfree:
                }
 #endif
  retfree:


@@ -1017,6 +1016,6 @@ strtod
  ret:
        if (se)
                *se = (char *)s;
  ret:
        if (se)
                *se = (char *)s;

-       return sign ? -dval(rv) : dval(rv);
+       return sign ? -dval(&rv) : dval(&rv);

        }
 
        }