1 files changed, 241 insertions, 281 deletions

diff --git a/src/lib/libc/stdlib/strtod.c b/src/lib/libc/stdlib/strtod.c
index b13fa128f5..4dc3d65a26 100644
--- a/src/lib/libc/stdlib/strtod.c
+++ b/src/lib/libc/stdlib/strtod.c
@@ -1,3 +1,4 @@
+/*      $OpenBSD: strtod.c,v 1.30 2006/10/30 18:30:52 deraadt Exp $ */
 /****************************************************************
  *
  * The author of this software is David M. Gay.
@@ -79,7 +80,6 @@
  * #define Just_16 to store 16 bits per 32-bit Long when doing high-precision
  *      integer arithmetic.  Whether this speeds things up or slows things
  *      down depends on the machine and the number being converted.
- * #define KR_headers for old-style C function headers.
  * #define Bad_float_h if your system lacks a float.h or if it does not
  *      define some or all of DBL_DIG, DBL_MAX_10_EXP, DBL_MAX_EXP,
  *      FLT_RADIX, FLT_ROUNDS, and DBL_MAX.
@@ -89,13 +89,14 @@
  *      directly -- and assumed always to succeed.
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-static char *rcsid = "$Id: strtod.c,v 1.1.1.1 1995/10/18 08:42:19 deraadt Exp $";
-#endif /* LIBC_SCCS and not lint */
-
+#include <sys/types.h>
 #if defined(__m68k__) || defined(__sparc__) || defined(__i386__) || \
-    defined(__mips__) || defined(__ns32k__) || defined(__alpha__)
-#include <machine/endian.h>
+    defined(__mips__) || defined(__mips64__) || defined(__ns32k__) || \
+    defined(__alpha__) || defined(__powerpc__) || defined(__m88k__) || \
+    defined(__hppa__) || defined(__amd64__) || defined(__sh__) || \
+    defined(__sparc64__) || \
+    (defined(__arm__) && defined(__VFP_FP__))
+
 #if BYTE_ORDER == BIG_ENDIAN
 #define IEEE_BIG_ENDIAN
 #else
@@ -103,7 +104,16 @@ static char *rcsid = "$Id: strtod.c,v 1.1.1.1 1995/10/18 08:42:19 deraadt Exp $"
 #endif
 #endif
 
-#ifdef vax
+#if defined(__arm__) && !defined(__VFP_FP__)
+/*
+ * Although the CPU is little endian the FP has different
+ * byte and word endianness. The byte order is still little endian
+ * but the word order is big endian.
+ */
+#define IEEE_BIG_ENDIAN
+#endif
+
+#ifdef __vax__
 #define VAX
 #endif
 
@@ -115,26 +125,22 @@ static char *rcsid = "$Id: strtod.c,v 1.1.1.1 1995/10/18 08:42:19 deraadt Exp $"
 #define Bug(x) {fprintf(stderr, "%s\n", x); exit(1);}
 #endif
 
+#include "thread_private.h"
+
+_THREAD_PRIVATE_KEY(dtoa);
+_THREAD_PRIVATE_KEY(pow5mult);
+
 #ifdef __cplusplus
 #include "malloc.h"
 #include "memory.h"
 #else
-#ifndef KR_headers
 #include "stdlib.h"
 #include "string.h"
 #include "locale.h"
-#else
-#include "malloc.h"
-#include "memory.h"
-#endif
 #endif
 
 #ifdef MALLOC
-#ifdef KR_headers
-extern char *MALLOC();
-#else
 extern void *MALLOC(size_t);
-#endif
 #else
 #define MALLOC malloc
 #endif
@@ -143,7 +149,6 @@ extern void *MALLOC(size_t);
 #include "errno.h"
 
 #ifdef Bad_float_h
-#undef __STDC__
 #ifdef IEEE_BIG_ENDIAN
 #define IEEE_ARITHMETIC
 #endif
@@ -193,12 +198,8 @@ extern "C" {
 #endif
 
 #ifndef CONST
-#ifdef KR_headers
-#define CONST /* blank */
-#else
 #define CONST const
 #endif
-#endif
 
 #ifdef Unsigned_Shifts
 #define Sign_Extend(a,b) if (b < 0) a |= 0xffff0000;
@@ -208,23 +209,27 @@ extern "C" {
 
 #if defined(IEEE_LITTLE_ENDIAN) + defined(IEEE_BIG_ENDIAN) + defined(VAX) + \
     defined(IBM) != 1
-Exactly one of IEEE_LITTLE_ENDIAN IEEE_BIG_ENDIAN, VAX, or
-IBM should be defined.
+#error Exactly one of IEEE_LITTLE_ENDIAN IEEE_BIG_ENDIAN, VAX, or IBM should be defined.
 #endif
 
+typedef union {
+        double d;
+        ULong ul[2];
+} _double;
+#define value(x) ((x).d)
 #ifdef IEEE_LITTLE_ENDIAN
-#define word0(x) ((ULong *)&x)[1]
-#define word1(x) ((ULong *)&x)[0]
+#define word0(x) ((x).ul[1])
+#define word1(x) ((x).ul[0])
 #else
-#define word0(x) ((ULong *)&x)[0]
-#define word1(x) ((ULong *)&x)[1]
+#define word0(x) ((x).ul[0])
+#define word1(x) ((x).ul[1])
 #endif
 
 /* The following definition of Storeinc is appropriate for MIPS processors.
  * An alternative that might be better on some machines is
  * #define Storeinc(a,b,c) (*a++ = b << 16 | c & 0xffff)
  */
-#if defined(IEEE_LITTLE_ENDIAN) + defined(VAX)
+#if defined(IEEE_LITTLE_ENDIAN) + defined(VAX) + defined(__arm__)
 #define Storeinc(a,b,c) (((unsigned short *)a)[1] = (unsigned short)b, \
 ((unsigned short *)a)[0] = (unsigned short)c, a++)
 #else
@@ -326,11 +331,7 @@ IBM should be defined.
 #ifdef RND_PRODQUOT
 #define rounded_product(a,b) a = rnd_prod(a, b)
 #define rounded_quotient(a,b) a = rnd_quot(a, b)
-#ifdef KR_headers
-extern double rnd_prod(), rnd_quot();
-#else
 extern double rnd_prod(double, double), rnd_quot(double, double);
-#endif
 #else
 #define rounded_product(a,b) a *= b
 #define rounded_quotient(a,b) a /= b
@@ -369,54 +370,94 @@ Bigint {
 
  static Bigint *freelist[Kmax+1];
 
+#define PRIVATE_MEM 2304
+#define PRIVATE_mem ((PRIVATE_MEM+sizeof(double)-1)/sizeof(double))
+ static double private_mem[PRIVATE_mem], *pmem_next = private_mem;
+
  static Bigint *
-Balloc
-#ifdef KR_headers
-        (k) int k;
-#else
-        (int k)
-#endif
+Balloc(int k)
 {
         int x;
+        unsigned int len;
         Bigint *rv;
 
-        if (rv = freelist[k]) {
+        _THREAD_PRIVATE_MUTEX_LOCK(dtoa);
+        if ((rv = freelist[k])) {
                 freelist[k] = rv->next;
                 }
         else {
                 x = 1 << k;
-                rv = (Bigint *)MALLOC(sizeof(Bigint) + (x-1)*sizeof(Long));
+                len = (sizeof(Bigint) + (x-1)*sizeof(Long) + sizeof(double) - 1)
+                        /sizeof(double);
+                if (pmem_next - private_mem + len <= PRIVATE_mem) {
+                        rv = (Bigint *)pmem_next;
+                        pmem_next += len;
+                        }
+                else
+                        rv = (Bigint *)MALLOC(len *sizeof(double));
                 rv->k = k;
                 rv->maxwds = x;
                 }
+        _THREAD_PRIVATE_MUTEX_UNLOCK(dtoa);
         rv->sign = rv->wds = 0;
         return rv;
         }
 
  static void
-Bfree
-#ifdef KR_headers
-        (v) Bigint *v;
-#else
-        (Bigint *v)
-#endif
+Bfree(Bigint *v)
 {
         if (v) {
+                _THREAD_PRIVATE_MUTEX_LOCK(dtoa);
                 v->next = freelist[v->k];
                 freelist[v->k] = v;
+                _THREAD_PRIVATE_MUTEX_UNLOCK(dtoa);
                 }
         }
 
 #define Bcopy(x,y) memcpy((char *)&x->sign, (char *)&y->sign, \
 y->wds*sizeof(Long) + 2*sizeof(int))
 
+/* return value is only used as a simple string, so mis-aligned parts
+ * inside the Bigint are not at risk on strict align architectures
+ */
+ static char *
+rv_alloc(int i)
+{
+        int j, k, *r;
+
+        j = sizeof(ULong);
+        for(k = 0;
+                sizeof(Bigint) - sizeof(ULong) - sizeof(int) + j <= i;
+                j <<= 1)
+                        k++;
+        r = (int*)Balloc(k);
+        *r = k;
+        return (char *)(r+1);
+        }
+
+ static char *
+nrv_alloc(char *s, char **rve, int n)
+{
+        char *rv, *t;
+
+        t = rv = rv_alloc(n);
+        while((*t = *s++) !=0)
+                t++;
+        if (rve)
+                *rve = t;
+        return rv;
+        }
+
+ void
+__freedtoa(char *s)
+{
+        Bigint *b = (Bigint *)((int *)s - 1);
+        b->maxwds = 1 << (b->k = *(int*)b);
+        Bfree(b);
+        }
+
  static Bigint *
-multadd
-#ifdef KR_headers
-        (b, m, a) Bigint *b; int m, a;
-#else
-        (Bigint *b, int m, int a)       /* multiply by m and add a */
-#endif
+multadd(Bigint *b, int m, int a)        /* multiply by m and add a */
 {
         int i, wds;
         ULong *x, y;
@@ -456,12 +497,7 @@ multadd
         }
 
  static Bigint *
-s2b
-#ifdef KR_headers
-        (s, nd0, nd, y9) CONST char *s; int nd0, nd; ULong y9;
-#else
-        (CONST char *s, int nd0, int nd, ULong y9)
-#endif
+s2b(CONST char *s, int nd0, int nd, ULong y9)
 {
         Bigint *b;
         int i, k;
@@ -494,14 +530,9 @@ s2b
         }
 
  static int
-hi0bits
-#ifdef KR_headers
-        (x) register ULong x;
-#else
-        (register ULong x)
-#endif
+hi0bits(ULong x)
 {
-        register int k = 0;
+        int k = 0;
 
         if (!(x & 0xffff0000)) {
                 k = 16;
@@ -528,15 +559,10 @@ hi0bits
         }
 
  static int
-lo0bits
-#ifdef KR_headers
-        (y) ULong *y;
-#else
-        (ULong *y)
-#endif
+lo0bits(ULong *y)
 {
-        register int k;
-        register ULong x = *y;
+        int k;
+        ULong x = *y;
 
         if (x & 7) {
                 if (x & 1)
@@ -568,7 +594,7 @@ lo0bits
         if (!(x & 1)) {
                 k++;
                 x >>= 1;
-                if (!x & 1)
+                if (!(x & 1))
                         return 32;
                 }
         *y = x;
@@ -576,12 +602,7 @@ lo0bits
         }
 
  static Bigint *
-i2b
-#ifdef KR_headers
-        (i) int i;
-#else
-        (int i)
-#endif
+i2b(int i)
 {
         Bigint *b;
 
@@ -592,12 +613,7 @@ i2b
         }
 
  static Bigint *
-mult
-#ifdef KR_headers
-        (a, b) Bigint *a, *b;
-#else
-        (Bigint *a, Bigint *b)
-#endif
+mult(Bigint *a, Bigint *b)
 {
         Bigint *c;
         int k, wa, wb, wc;
@@ -628,7 +644,7 @@ mult
         xc0 = c->x;
 #ifdef Pack_32
         for(; xb < xbe; xb++, xc0++) {
-                if (y = *xb & 0xffff) {
+                if ((y = *xb & 0xffff)) {
                         x = xa;
                         xc = xc0;
                         carry = 0;
@@ -642,7 +658,7 @@ mult
                                 while(x < xae);
                         *xc = carry;
                         }
-                if (y = *xb >> 16) {
+                if ((y = *xb >> 16)) {
                         x = xa;
                         xc = xc0;
                         carry = 0;
@@ -682,26 +698,23 @@ mult
  static Bigint *p5s;
 
  static Bigint *
-pow5mult
-#ifdef KR_headers
-        (b, k) Bigint *b; int k;
-#else
-        (Bigint *b, int k)
-#endif
+pow5mult(Bigint *b, int k)
 {
         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 */
+                _THREAD_PRIVATE_MUTEX_LOCK(pow5mult);
                 p5 = p5s = i2b(625);
                 p5->next = 0;
+                _THREAD_PRIVATE_MUTEX_UNLOCK(pow5mult);
                 }
         for(;;) {
                 if (k & 1) {
@@ -712,8 +725,12 @@ pow5mult
                 if (!(k >>= 1))
                         break;
                 if (!(p51 = p5->next)) {
-                        p51 = p5->next = mult(p5,p5);
-                        p51->next = 0;
+                        _THREAD_PRIVATE_MUTEX_LOCK(pow5mult);
+                        if (!(p51 = p5->next)) {
+                                p51 = p5->next = mult(p5,p5);
+                                p51->next = 0;
+                                }
+                        _THREAD_PRIVATE_MUTEX_UNLOCK(pow5mult);
                         }
                 p5 = p51;
                 }
@@ -721,12 +738,7 @@ pow5mult
         }
 
  static Bigint *
-lshift
-#ifdef KR_headers
-        (b, k) Bigint *b; int k;
-#else
-        (Bigint *b, int k)
-#endif
+lshift(Bigint *b, int k)
 {
         int i, k1, n, n1;
         Bigint *b1;
@@ -756,7 +768,7 @@ lshift
                         z = *x++ >> k1;
                         }
                         while(x < xe);
-                if (*x1 = z)
+                if ((*x1 = z))
                         ++n1;
                 }
 #else
@@ -781,12 +793,7 @@ lshift
         }
 
  static int
-cmp
-#ifdef KR_headers
-        (a, b) Bigint *a, *b;
-#else
-        (Bigint *a, Bigint *b)
-#endif
+cmp(Bigint *a, Bigint *b)
 {
         ULong *xa, *xa0, *xb, *xb0;
         int i, j;
@@ -815,12 +822,7 @@ cmp
         }
 
  static Bigint *
-diff
-#ifdef KR_headers
-        (a, b) Bigint *a, *b;
-#else
-        (Bigint *a, Bigint *b)
-#endif
+diff(Bigint *a, Bigint *b)
 {
         Bigint *c;
         int i, wa, wb;
@@ -897,16 +899,13 @@ diff
         }
 
  static double
-ulp
-#ifdef KR_headers
-        (x) double x;
-#else
-        (double x)
-#endif
+ulp(double _x)
 {
-        register Long L;
-        double a;
+        _double x;
+        Long L;
+        _double a;
 
+        value(x) = _x;
         L = (word0(x) & Exp_mask) - (P-1)*Exp_msk1;
 #ifndef Sudden_Underflow
         if (L > 0) {
@@ -931,20 +930,15 @@ ulp
                         }
                 }
 #endif
-        return a;
+        return value(a);
         }
 
  static double
-b2d
-#ifdef KR_headers
-        (a, e) Bigint *a; int *e;
-#else
-        (Bigint *a, int *e)
-#endif
+b2d(Bigint *a, int *e)
 {
         ULong *xa, *xa0, w, y, z;
         int k;
-        double d;
+        _double d;
 #ifdef VAX
         ULong d0, d1;
 #else
@@ -1001,22 +995,22 @@ b2d
 #undef d0
 #undef d1
 #endif
-        return d;
+        return value(d);
         }
 
  static Bigint *
-d2b
-#ifdef KR_headers
-        (d, e, bits) double d; int *e, *bits;
-#else
-        (double d, int *e, int *bits)
-#endif
+d2b(double _d, int *e, int *bits)
 {
         Bigint *b;
         int de, i, k;
         ULong *x, y, z;
+        _double d;
 #ifdef VAX
         ULong d0, d1;
+#endif
+
+        value(d) = _d;
+#ifdef VAX
         d0 = word0(d) >> 16 | word0(d) << 16;
         d1 = word1(d) >> 16 | word1(d) << 16;
 #else
@@ -1134,18 +1128,13 @@ d2b
 #undef d1
 
  static double
-ratio
-#ifdef KR_headers
-        (a, b) Bigint *a, *b;
-#else
-        (Bigint *a, Bigint *b)
-#endif
+ratio(Bigint *a, Bigint *b)
 {
-        double da, db;
+        _double da, db;
         int k, ka, kb;
 
-        da = b2d(a, &ka);
-        db = b2d(b, &kb);
+        value(da) = b2d(a, &ka);
+        value(db) = b2d(b, &kb);
 #ifdef Pack_32
         k = ka - kb + 32*(a->wds - b->wds);
 #else
@@ -1171,7 +1160,7 @@ ratio
                 word0(db) += k*Exp_msk1;
                 }
 #endif
-        return da / db;
+        return value(da) / value(db);
         }
 
 static CONST double
@@ -1201,32 +1190,29 @@ static CONST double tinytens[] = { 1e-16, 1e-32 };
 #endif
 
  double
-strtod
-#ifdef KR_headers
-        (s00, se) CONST char *s00; char **se;
-#else
-        (CONST char *s00, char **se)
-#endif
+strtod(CONST char *s00, char **se)
 {
         int bb2, bb5, bbe, bd2, bd5, bbbits, bs2, c, 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, aadj1, adj;
+        /*
+         * volatile forces mem update for FPUs where reg size != sizeof double,
+         * which should trigger ERANGE in the case of underflow.
+         */
+        volatile _double rv;
+        _double rv0;
         Long L;
         ULong y, z;
         Bigint *bb, *bb1, *bd, *bd0, *bs, *delta;
 
-#ifndef KR_headers
         CONST char decimal_point = localeconv()->decimal_point[0];
-#else
-        CONST char decimal_point = '.';
-#endif
 
         sign = nz0 = nz = 0;
-        rv = 0.;
+        value(rv) = 0.;
 
 
-        for(s = s00; isspace(*s); s++)
+        for(s = s00; isspace((unsigned char) *s); s++)
                 ;
 
         if (*s == '-') {
@@ -1340,9 +1326,9 @@ strtod
         if (!nd0)
                 nd0 = nd;
         k = nd < DBL_DIG + 1 ? nd : DBL_DIG + 1;
-        rv = y;
+        value(rv) = y;
         if (k > 9)
-                rv = tens[k - 9] * rv + z;
+                value(rv) = tens[k - 9] * value(rv) + z;
         bd0 = 0;
         if (nd <= DBL_DIG
 #ifndef RND_PRODQUOT
@@ -1356,7 +1342,8 @@ strtod
 #ifdef VAX
                                 goto vax_ovfl_check;
 #else
-                                /* rv = */ rounded_product(rv, tens[e]);
+                                /* value(rv) = */ rounded_product(value(rv),
+                                    tens[e]);
                                 goto ret;
 #endif
                                 }
@@ -1366,27 +1353,30 @@ strtod
                                  * this for larger i values.
                                  */
                                 e -= i;
-                                rv *= tens[i];
+                                value(rv) *= tens[i];
 #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(rv, tens[e]);
+                                /* value(rv) = */ rounded_product(value(rv),
+                                    tens[e]);
                                 if ((word0(rv) & Exp_mask)
                                  > Exp_msk1*(DBL_MAX_EXP+Bias-1-P))
                                         goto ovfl;
                                 word0(rv) += P*Exp_msk1;
 #else
-                                /* rv = */ rounded_product(rv, tens[e]);
+                                /* value(rv) = */ rounded_product(value(rv),
+                                    tens[e]);
 #endif
                                 goto ret;
                                 }
                         }
 #ifndef Inaccurate_Divide
                 else if (e >= -Ten_pmax) {
-                        /* rv = */ rounded_quotient(rv, tens[-e]);
+                        /* value(rv) = */ rounded_quotient(value(rv),
+                            tens[-e]);
                         goto ret;
                         }
 #endif
@@ -1397,13 +1387,13 @@ strtod
 
         if (e1 > 0) {
                 if (i = e1 & 15)
-                        rv *= tens[i];
+                        value(rv) *= tens[i];
                 if (e1 &= ~15) {
                         if (e1 > DBL_MAX_10_EXP) {
  ovfl:
                                 errno = ERANGE;
-#ifdef __STDC__
-                                rv = HUGE_VAL;
+#ifndef Bad_float_h
+                                value(rv) = HUGE_VAL;
 #else
                                 /* Can't trust HUGE_VAL */
 #ifdef IEEE_Arith
@@ -1421,10 +1411,10 @@ strtod
                         if (e1 >>= 4) {
                                 for(j = 0; e1 > 1; j++, e1 >>= 1)
                                         if (e1 & 1)
-                                                rv *= bigtens[j];
+                                                value(rv) *= bigtens[j];
                         /* The last multiplication could overflow. */
                                 word0(rv) -= P*Exp_msk1;
-                                rv *= bigtens[j];
+                                value(rv) *= bigtens[j];
                                 if ((z = word0(rv) & Exp_mask)
                                  > Exp_msk1*(DBL_MAX_EXP+Bias-P))
                                         goto ovfl;
@@ -1443,23 +1433,23 @@ strtod
         else if (e1 < 0) {
                 e1 = -e1;
                 if (i = e1 & 15)
-                        rv /= tens[i];
+                        value(rv) /= tens[i];
                 if (e1 &= ~15) {
                         e1 >>= 4;
                         if (e1 >= 1 << n_bigtens)
                                 goto undfl;
                         for(j = 0; e1 > 1; j++, e1 >>= 1)
                                 if (e1 & 1)
-                                        rv *= tinytens[j];
+                                        value(rv) *= tinytens[j];
                         /* The last multiplication could underflow. */
-                        rv0 = rv;
-                        rv *= tinytens[j];
-                        if (!rv) {
-                                rv = 2.*rv0;
-                                rv *= tinytens[j];
-                                if (!rv) {
+                        value(rv0) = value(rv);
+                        value(rv) *= tinytens[j];
+                        if (!value(rv)) {
+                                value(rv) = 2.*value(rv0);
+                                value(rv) *= tinytens[j];
+                                if (!value(rv)) {
  undfl:
-                                        rv = 0.;
+                                        value(rv) = 0.;
                                         errno = ERANGE;
                                         if (bd0)
                                                 goto retfree;
@@ -1483,7 +1473,7 @@ strtod
         for(;;) {
                 bd = Balloc(bd0->k);
                 Bcopy(bd, bd0);
-                bb = d2b(rv, &bbe, &bbbits);    /* rv = bb * 2^bbe */
+                bb = d2b(value(rv), &bbe, &bbbits);     /* rv = bb * 2^bbe */
                 bs = i2b(1);
 
                 if (e >= 0) {
@@ -1595,12 +1585,12 @@ strtod
                                 break;
 #endif
                         if (dsign)
-                                rv += ulp(rv);
+                                value(rv) += ulp(value(rv));
 #ifndef ROUND_BIASED
                         else {
-                                rv -= ulp(rv);
+                                value(rv) -= ulp(value(rv));
 #ifndef Sudden_Underflow
-                                if (!rv)
+                                if (!value(rv))
                                         goto undfl;
 #endif
                                 }
@@ -1651,10 +1641,10 @@ strtod
                 /* Check for overflow */
 
                 if (y == Exp_msk1*(DBL_MAX_EXP+Bias-1)) {
-                        rv0 = rv;
+                        value(rv0) = value(rv);
                         word0(rv) -= P*Exp_msk1;
-                        adj = aadj1 * ulp(rv);
-                        rv += adj;
+                        adj = aadj1 * ulp(value(rv));
+                        value(rv) += adj;
                         if ((word0(rv) & Exp_mask) >=
                                         Exp_msk1*(DBL_MAX_EXP+Bias-P)) {
                                 if (word0(rv0) == Big0 && word1(rv0) == Big1)
@@ -1669,10 +1659,10 @@ strtod
                 else {
 #ifdef Sudden_Underflow
                         if ((word0(rv) & Exp_mask) <= P*Exp_msk1) {
-                                rv0 = rv;
+                                value(rv0) = value(rv);
                                 word0(rv) += P*Exp_msk1;
-                                adj = aadj1 * ulp(rv);
-                                rv += adj;
+                                adj = aadj1 * ulp(value(rv));
+                                value(rv) += adj;
 #ifdef IBM
                                 if ((word0(rv) & Exp_mask) <  P*Exp_msk1)
 #else
@@ -1690,8 +1680,8 @@ strtod
                                         word0(rv) -= P*Exp_msk1;
                                 }
                         else {
-                                adj = aadj1 * ulp(rv);
-                                rv += adj;
+                                adj = aadj1 * ulp(value(rv));
+                                value(rv) += adj;
                                 }
 #else
                         /* Compute adj so that the IEEE rounding rules will
@@ -1706,8 +1696,8 @@ strtod
                                 if (!dsign)
                                         aadj1 = -aadj1;
                                 }
-                        adj = aadj1 * ulp(rv);
-                        rv += adj;
+                        adj = aadj1 * ulp(value(rv));
+                        value(rv) += adj;
 #endif
                         }
                 z = word0(rv) & Exp_mask;
@@ -1738,16 +1728,11 @@ strtod
  ret:
         if (se)
                 *se = (char *)s;
-        return sign ? -rv : rv;
+        return sign ? -value(rv) : value(rv);
         }
 
  static int
-quorem
-#ifdef KR_headers
-        (b, S) Bigint *b, *S;
-#else
-        (Bigint *b, Bigint *S)
-#endif
+quorem(Bigint *b, Bigint *S)
 {
         int n;
         Long borrow, y;
@@ -1882,13 +1867,7 @@ quorem
  */
 
  char *
-__dtoa
-#ifdef KR_headers
-        (d, mode, ndigits, decpt, sign, rve)
-        double d; int mode, ndigits, *decpt, *sign; char **rve;
-#else
-        (double d, int mode, int ndigits, int *decpt, int *sign, char **rve)
-#endif
+__dtoa(double _d, int mode, int ndigits, int *decpt, int *sign, char **rve)
 {
  /*     Arguments ndigits, decpt, sign are similar to those
         of ecvt and fcvt; trailing zeros are suppressed from
@@ -1933,17 +1912,11 @@ __dtoa
         ULong x;
 #endif
         Bigint *b, *b1, *delta, *mlo, *mhi, *S;
-        double d2, ds, eps;
+        double ds;
         char *s, *s0;
-        static Bigint *result;
-        static int result_k;
+        _double d, d2, eps;
 
-        if (result) {
-                result->k = result_k;
-                result->maxwds = 1 << result_k;
-                Bfree(result);
-                result = 0;
-                }
+        value(d) = _d;
 
         if (word0(d) & Sign_bit) {
                 /* set sign for everything, including 0's and NaNs */
@@ -1962,43 +1935,33 @@ __dtoa
                 {
                 /* Infinity or NaN */
                 *decpt = 9999;
-                s =
 #ifdef IEEE_Arith
-                        !word1(d) && !(word0(d) & 0xfffff) ? "Infinity" :
+                if (!word1(d) && !(word0(d) & 0xfffff))
+                        return nrv_alloc("Infinity", rve, 8);
 #endif
-                                "NaN";
-                if (rve)
-                        *rve =
-#ifdef IEEE_Arith
-                                s[3] ? s + 8 :
-#endif
-                                                s + 3;
-                return s;
+                return nrv_alloc("NaN", rve, 3);
                 }
 #endif
 #ifdef IBM
-        d += 0; /* normalize */
+        value(d) += 0; /* normalize */
 #endif
-        if (!d) {
+        if (!value(d)) {
                 *decpt = 1;
-                s = "0";
-                if (rve)
-                        *rve = s + 1;
-                return s;
+                return nrv_alloc("0", rve, 1);
                 }
 
-        b = d2b(d, &be, &bbits);
+        b = d2b(value(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))) {
 #endif
-                d2 = d;
+                value(d2) = value(d);
                 word0(d2) &= Frac_mask1;
                 word0(d2) |= Exp_11;
 #ifdef IBM
                 if (j = 11 - hi0bits(word0(d2) & Frac_mask))
-                        d2 /= 1 << j;
+                        value(d2) /= 1 << j;
 #endif
 
                 /* log(x)       ~=~ log(1.5) + (x-1.5)/1.5
@@ -2037,19 +2000,20 @@ __dtoa
                 i = bbits + be + (Bias + (P-1) - 1);
                 x = i > 32  ? word0(d) << 64 - i | word1(d) >> i - 32
                             : word1(d) << 32 - i;
-                d2 = x;
+                value(d2) = x;
                 word0(d2) -= 31*Exp_msk1; /* adjust exponent */
                 i -= (Bias + (P-1) - 1) + 1;
                 denorm = 1;
                 }
 #endif
-        ds = (d2-1.5)*0.289529654602168 + 0.1760912590558 + i*0.301029995663981;
+        ds = (value(d2)-1.5)*0.289529654602168 + 0.1760912590558 +
+            i*0.301029995663981;
         k = (int)ds;
         if (ds < 0. && ds != k)
                 k--;    /* want k = floor(ds) */
         k_check = 1;
         if (k >= 0 && k <= Ten_pmax) {
-                if (d < tens[k])
+                if (value(d) < tens[k])
                         k--;
                 k_check = 0;
                 }
@@ -2105,18 +2069,14 @@ __dtoa
                         if (i <= 0)
                                 i = 1;
                 }
-        j = sizeof(ULong);
-        for(result_k = 0; sizeof(Bigint) - sizeof(ULong) + j <= i;
-                j <<= 1) result_k++;
-        result = Balloc(result_k);
-        s = s0 = (char *)result;
+        s = s0 = rv_alloc(i);
 
         if (ilim >= 0 && ilim <= Quick_max && try_quick) {
 
                 /* Try to get by with floating-point arithmetic. */
 
                 i = 0;
-                d2 = d;
+                value(d2) = value(d);
                 k0 = k;
                 ilim0 = ilim;
                 ieps = 2; /* conservative */
@@ -2126,7 +2086,7 @@ __dtoa
                         if (j & Bletch) {
                                 /* prevent overflows */
                                 j &= Bletch - 1;
-                                d /= bigtens[n_bigtens-1];
+                                value(d) /= bigtens[n_bigtens-1];
                                 ieps++;
                                 }
                         for(; j; j >>= 1, i++)
@@ -2134,32 +2094,32 @@ __dtoa
                                         ieps++;
                                         ds *= bigtens[i];
                                         }
-                        d /= ds;
+                        value(d) /= ds;
                         }
                 else if (j1 = -k) {
-                        d *= tens[j1 & 0xf];
+                        value(d) *= tens[j1 & 0xf];
                         for(j = j1 >> 4; j; j >>= 1, i++)
                                 if (j & 1) {
                                         ieps++;
-                                        d *= bigtens[i];
+                                        value(d) *= bigtens[i];
                                         }
                         }
-                if (k_check && d < 1. && ilim > 0) {
+                if (k_check && value(d) < 1. && ilim > 0) {
                         if (ilim1 <= 0)
                                 goto fast_failed;
                         ilim = ilim1;
                         k--;
-                        d *= 10.;
+                        value(d) *= 10.;
                         ieps++;
                         }
-                eps = ieps*d + 7.;
+                value(eps) = ieps*value(d) + 7.;
                 word0(eps) -= (P-1)*Exp_msk1;
                 if (ilim == 0) {
                         S = mhi = 0;
-                        d -= 5.;
-                        if (d > eps)
+                        value(d) -= 5.;
+                        if (value(d) > value(eps))
                                 goto one_digit;
-                        if (d < -eps)
+                        if (value(d) < -value(eps))
                                 goto no_digits;
                         goto fast_failed;
                         }
@@ -2168,33 +2128,33 @@ __dtoa
                         /* Use Steele & White method of only
                          * generating digits needed.
                          */
-                        eps = 0.5/tens[ilim-1] - eps;
+                        value(eps) = 0.5/tens[ilim-1] - value(eps);
                         for(i = 0;;) {
-                                L = d;
-                                d -= L;
+                                L = value(d);
+                                value(d) -= L;
                                 *s++ = '0' + (int)L;
-                                if (d < eps)
+                                if (value(d) < value(eps))
                                         goto ret1;
-                                if (1. - d < eps)
+                                if (1. - value(d) < value(eps))
                                         goto bump_up;
                                 if (++i >= ilim)
                                         break;
-                                eps *= 10.;
-                                d *= 10.;
+                                value(eps) *= 10.;
+                                value(d) *= 10.;
                                 }
                         }
                 else {
 #endif
                         /* Generate ilim digits, then fix them up. */
-                        eps *= tens[ilim-1];
-                        for(i = 1;; i++, d *= 10.) {
-                                L = d;
-                                d -= L;
+                        value(eps) *= tens[ilim-1];
+                        for(i = 1;; i++, value(d) *= 10.) {
+                                L = value(d);
+                                value(d) -= L;
                                 *s++ = '0' + (int)L;
                                 if (i == ilim) {
-                                        if (d > 0.5 + eps)
+                                        if (value(d) > 0.5 + value(eps))
                                                 goto bump_up;
-                                        else if (d < 0.5 - eps) {
+                                        else if (value(d) < 0.5 - value(eps)) {
                                                 while(*--s == '0');
                                                 s++;
                                                 goto ret1;
@@ -2207,7 +2167,7 @@ __dtoa
 #endif
  fast_failed:
                 s = s0;
-                d = d2;
+                value(d) = value(d2);
                 k = k0;
                 ilim = ilim0;
                 }
@@ -2219,24 +2179,24 @@ __dtoa
                 ds = tens[k];
                 if (ndigits < 0 && ilim <= 0) {
                         S = mhi = 0;
-                        if (ilim < 0 || d <= 5*ds)
+                        if (ilim < 0 || value(d) <= 5*ds)
                                 goto no_digits;
                         goto one_digit;
                         }
                 for(i = 1;; i++) {
-                        L = d / ds;
-                        d -= L*ds;
+                        L = value(d) / ds;
+                        value(d) -= L*ds;
 #ifdef Check_FLT_ROUNDS
                         /* If FLT_ROUNDS == 2, L will usually be high by 1 */
-                        if (d < 0) {
+                        if (value(d) < 0) {
                                 L--;
-                                d += ds;
+                                value(d) += ds;
                                 }
 #endif
                         *s++ = '0' + (int)L;
                         if (i == ilim) {
-                                d += d;
-                                if (d > ds || d == ds && L & 1) {
+                                value(d) += value(d);
+                                if (value(d) > ds || value(d) == ds && L & 1) {
  bump_up:
                                         while(*--s == '9')
                                                 if (s == s0) {
@@ -2248,7 +2208,7 @@ __dtoa
                                         }
                                 break;
                                 }
-                        if (!(d *= 10.))
+                        if (!(value(d) *= 10.))
                                 break;
                         }
                 goto ret1;