30 register const char *s = start;
31 register unsigned long retval = 0;
33 while (len-- && *s >=
'0' && *s <=
'7') {
37 *retlen = (int)(s - start);
44 static const char hexdigit[] =
"0123456789abcdef0123456789ABCDEF";
45 register const char *s = start;
46 register unsigned long retval = 0;
49 while (len-- && *s && (tmp =
strchr(hexdigit, *s))) {
51 retval |= (tmp - hexdigit) & 15;
54 *retlen = (int)(s - start);
59 scan_digits(
const char *str,
int base,
size_t *retlen,
int *overflow)
61 static signed char table[] = {
63 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
64 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
65 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
66 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,-1,-1,-1,-1,-1,-1,
67 -1,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,
68 25,26,27,28,29,30,31,32,33,34,35,-1,-1,-1,-1,-1,
69 -1,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,
70 25,26,27,28,29,30,31,32,33,34,35,-1,-1,-1,-1,-1,
71 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
72 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
73 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
74 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
75 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
76 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
77 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
78 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
81 const char *start = str;
82 unsigned long ret = 0, x;
83 unsigned long mul_overflow = (~(
unsigned long)0) / base;
87 while ((c = (
unsigned char)*str++) !=
'\0') {
89 if (d == -1 || base <= d) {
90 *retlen = (str-1) - start;
93 if (mul_overflow < ret)
101 *retlen = (str-1) - start;
112 const char *subject_found = str;
114 if (base == 1 || 36 < base) {
119 while ((c = *str) &&
ISSPACE(c))
132 subject_found = str+1;
133 if (base == 0 || base == 16) {
134 if (str[1] ==
'x' || str[1] ==
'X') {
139 b = base == 0 ? 8 : 16;
149 b = base == 0 ? 10 : base;
155 subject_found = str+
len;
158 *endptr = (
char*)subject_found;
166 ret = (
unsigned long)(-(
long)ret);
174 #include <sys/types.h>
175 #include <sys/stat.h>
179 #if defined(HAVE_FCNTL_H)
184 # define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)
195 #define mmprepare(base, size) do {\
196 if (((VALUE)(base) & (0x3)) == 0)\
197 if ((size) >= 16) mmkind = 1;\
200 high = ((size) & (~0xf));\
201 low = ((size) & 0x0c);\
204 #define mmarg mmkind, size, high, low
206 static void mmswap_(
register char *a,
register char *b,
int mmkind,
size_t size,
size_t high,
size_t low)
212 register char *t = a + high;
214 s =
A[0];
A[0] =
B[0];
B[0] = s;
215 s =
A[1];
A[1] =
B[1];
B[1] = s;
216 s =
A[2];
A[2] =
B[2];
B[2] = s;
217 s =
A[3];
A[3] =
B[3];
B[3] = s; a += 16; b += 16;
220 if (low != 0) { s =
A[0];
A[0] =
B[0];
B[0] = s;
221 if (low >= 8) { s =
A[1];
A[1] =
B[1];
B[1] = s;
222 if (low == 12) {s =
A[2];
A[2] =
B[2];
B[2] = s;}}}
225 register char *t = a +
size;
226 do {s = *a; *a++ = *b; *b++ = s;}
while (a < t);
229 #define mmswap(a,b) mmswap_((a),(b),mmarg)
231 static void mmrot3_(
register char *a,
register char *b,
register char *c,
int mmkind,
size_t size,
size_t high,
size_t low)
236 register char *t = a + high;
238 s =
A[0];
A[0] =
B[0];
B[0] =
C[0];
C[0] = s;
239 s =
A[1];
A[1] =
B[1];
B[1] =
C[1];
C[1] = s;
240 s =
A[2];
A[2] =
B[2];
B[2] =
C[2];
C[2] = s;
241 s =
A[3];
A[3] =
B[3];
B[3] =
C[3];
C[3] = s; a += 16; b += 16; c += 16;
244 if (low != 0) { s =
A[0];
A[0] =
B[0];
B[0] =
C[0];
C[0] = s;
245 if (low >= 8) { s =
A[1];
A[1] =
B[1];
B[1] =
C[1];
C[1] = s;
246 if (low == 12) {s =
A[2];
A[2] =
B[2];
B[2] =
C[2];
C[2] = s;}}}
249 register char *t = a +
size;
250 do {s = *a; *a++ = *b; *b++ = *c; *c++ = s;}
while (a < t);
253 #define mmrot3(a,b,c) mmrot3_((a),(b),(c),mmarg)
265 #define PUSH(ll,rr) do { top->LL = (ll); top->RR = (rr); ++top; } while (0)
266 #define POP(ll,rr) do { --top; (ll) = top->LL; (rr) = top->RR; } while (0)
268 #define med3(a,b,c) ((*cmp)((a),(b),d)<0 ? \
269 ((*cmp)((b),(c),d)<0 ? (b) : ((*cmp)((a),(c),d)<0 ? (c) : (a))) : \
270 ((*cmp)((b),(c),d)>0 ? (b) : ((*cmp)((a),(c),d)<0 ? (a) : (c))))
274 int (*
cmp)(
const void*,
const void*,
void*),
void *d)
276 register char *l, *r, *m;
277 register int t, eq_l, eq_r;
279 char *
R = (
char*)base + size*(nel-1);
285 if (nel <= 1)
return;
290 if (stack == top)
return;
296 if ((*
cmp)(L,R,d) > 0)
mmswap(L,R);
goto nxt;
300 n = (r - l +
size) / size;
301 m = l + size * (n >> 1);
309 register char *p1 = l + n;
310 register char *p2 = p1 + n;
311 register char *p3 = p2 + n;
312 m1 =
med3(p1, p2, p3);
316 m3 =
med3(p1, p2, p3);
327 if ((t = (*
cmp)(l,m,d)) < 0) {
328 if ((t = (*
cmp)(m,r,d)) < 0) {
329 if (chklim && nel >= chklim) {
332 for (p=l; p<r; p+=size) if ((*cmp)(p,p+size,d) > 0)
goto fail;
338 if ((*
cmp)(l,r,d) <= 0) {
mmswap(m,r);
goto loopA;}
339 mmrot3(r,m,l);
goto loopA;
345 if ((t = (*
cmp)(m,r,d)) > 0) {
346 if (chklim && nel >= chklim) {
349 for (p=l; p<r; p+=
size)
if ((*
cmp)(p,p+size,d) < 0)
goto fail2;
353 fail2:
mmswap(l,r);
goto loopA;
356 if ((*
cmp)(l,r,d) <= 0) {
mmswap(l,m);
goto loopB;}
357 mmrot3(l,m,r);
goto loopA;
362 if ((t = (*
cmp)(m,r,d)) < 0) {
goto loopA;}
363 if (t > 0) {
mmswap(l,r);
goto loopB;}
367 if ((l += size) == r)
goto nxt;
368 if (l == m)
continue;
369 if ((t = (*
cmp)(l,m,d)) > 0) {
mmswap(l,r); l = L;
goto loopA;}
370 if (t < 0) {
mmswap(L,l); l = L;
goto loopB;}
373 loopA: eq_l = 1; eq_r = 1;
376 if ((l += size) == r)
378 if (l == m)
continue;
379 if ((t = (*
cmp)(l,m,d)) > 0) {eq_r = 0;
break;}
383 if (l == (r -= size))
385 if (r == m) {m = l;
break;}
386 if ((t = (*
cmp)(r,m,d)) < 0) {eq_l = 0;
break;}
392 loopB: eq_l = 1; eq_r = 1;
395 if (l == (r -= size))
397 if (r == m)
continue;
398 if ((t = (*
cmp)(r,m,d)) < 0) {eq_l = 0;
break;}
402 if ((l += size) == r)
404 if (l == m) {m = r;
break;}
405 if ((t = (*
cmp)(l,m,d)) > 0) {eq_r = 0;
break;}
414 if (l-L < R-r) {
PUSH(r,R); R = l;}
415 else {
PUSH(L,l); L = r;}
417 else if (eq_r == 0) L = r;
429 memcpy(tmp, str, len);
441 while (!getcwd(buf, size)) {
442 if (
errno != ERANGE) {
451 # define PATH_MAX 8192
628 #ifdef WORDS_BIGENDIAN
629 #define IEEE_BIG_ENDIAN
631 #define IEEE_LITTLE_ENDIAN
636 #undef IEEE_BIG_ENDIAN
637 #undef IEEE_LITTLE_ENDIAN
640 #if defined(__arm__) && !defined(__VFP_FP__)
641 #define IEEE_BIG_ENDIAN
642 #undef IEEE_LITTLE_ENDIAN
650 #define ULong unsigned int
651 #elif SIZEOF_LONG == 4
652 #define Long long int
653 #define ULong unsigned long int
657 #define Llong LONG_LONG
662 #define Bug(x) {fprintf(stderr, "%s\n", (x)); exit(EXIT_FAILURE);}
673 extern void *
MALLOC(
size_t);
675 #define MALLOC malloc
678 extern void FREE(
void*);
683 #ifndef Omit_Private_Memory
685 #define PRIVATE_MEM 2304
687 #define PRIVATE_mem ((PRIVATE_MEM+sizeof(double)-1)/sizeof(double))
692 #undef Avoid_Underflow
693 #ifdef IEEE_BIG_ENDIAN
696 #ifdef IEEE_LITTLE_ENDIAN
704 #define DBL_MAX_10_EXP 308
705 #define DBL_MAX_EXP 1024
711 #define DBL_MAX_10_EXP 75
712 #define DBL_MAX_EXP 63
714 #define DBL_MAX 7.2370055773322621e+75
719 #define DBL_MAX_10_EXP 38
720 #define DBL_MAX_EXP 127
722 #define DBL_MAX 1.7014118346046923e+38
726 #define LONG_MAX 2147483647
744 #if defined(IEEE_LITTLE_ENDIAN) + defined(IEEE_BIG_ENDIAN) + defined(VAX) + defined(IBM) != 1
748 typedef union {
double d; ULong L[2]; }
U;
753 # ifdef IEEE_LITTLE_ENDIAN
754 # define word0(x) (((ULong *)&(x))[1])
755 # define word1(x) (((ULong *)&(x))[0])
757 # define word0(x) (((ULong *)&(x))[0])
758 # define word1(x) (((ULong *)&(x))[1])
762 # ifdef IEEE_LITTLE_ENDIAN
763 # define word0(x) ((x).L[1])
764 # define word1(x) ((x).L[0])
766 # define word0(x) ((x).L[0])
767 # define word1(x) ((x).L[1])
769 # define dval(x) ((x).d)
776 #if defined(IEEE_LITTLE_ENDIAN) + defined(VAX) + defined(__arm__)
777 #define Storeinc(a,b,c) (((unsigned short *)(a))[1] = (unsigned short)(b), \
778 ((unsigned short *)(a))[0] = (unsigned short)(c), (a)++)
780 #define Storeinc(a,b,c) (((unsigned short *)(a))[0] = (unsigned short)(b), \
781 ((unsigned short *)(a))[1] = (unsigned short)(c), (a)++)
792 #define Exp_shift1 20
793 #define Exp_msk1 0x100000
794 #define Exp_msk11 0x100000
795 #define Exp_mask 0x7ff00000
799 #define Exp_1 0x3ff00000
800 #define Exp_11 0x3ff00000
802 #define Frac_mask 0xfffff
803 #define Frac_mask1 0xfffff
806 #define Bndry_mask 0xfffff
807 #define Bndry_mask1 0xfffff
809 #define Sign_bit 0x80000000
815 #ifndef NO_IEEE_Scale
816 #define Avoid_Underflow
818 #undef Sudden_Underflow
824 #define Flt_Rounds FLT_ROUNDS
830 #ifdef Honor_FLT_ROUNDS
831 #define Rounding rounding
832 #undef Check_FLT_ROUNDS
833 #define Check_FLT_ROUNDS
835 #define Rounding Flt_Rounds
839 #undef Check_FLT_ROUNDS
840 #undef Honor_FLT_ROUNDS
842 #undef Sudden_Underflow
843 #define Sudden_Underflow
848 #define Exp_shift1 24
849 #define Exp_msk1 0x1000000
850 #define Exp_msk11 0x1000000
851 #define Exp_mask 0x7f000000
854 #define Exp_1 0x41000000
855 #define Exp_11 0x41000000
857 #define Frac_mask 0xffffff
858 #define Frac_mask1 0xffffff
861 #define Bndry_mask 0xefffff
862 #define Bndry_mask1 0xffffff
864 #define Sign_bit 0x80000000
866 #define Tiny0 0x100000
875 #define Exp_msk1 0x80
876 #define Exp_msk11 0x800000
877 #define Exp_mask 0x7f80
880 #define Exp_1 0x40800000
881 #define Exp_11 0x4080
883 #define Frac_mask 0x7fffff
884 #define Frac_mask1 0xffff007f
887 #define Bndry_mask 0xffff007f
888 #define Bndry_mask1 0xffff007f
890 #define Sign_bit 0x8000
904 #define rounded_product(a,b) ((a) = rnd_prod((a), (b)))
905 #define rounded_quotient(a,b) ((a) = rnd_quot((a), (b)))
906 extern double rnd_prod(
double,
double), rnd_quot(
double,
double);
908 #define rounded_product(a,b) ((a) *= (b))
909 #define rounded_quotient(a,b) ((a) /= (b))
912 #define Big0 (Frac_mask1 | Exp_msk1*(DBL_MAX_EXP+Bias-1))
913 #define Big1 0xffffffff
919 #define FFFFFFFF 0xffffffffUL
933 #define Llong long long
936 #define ULLong unsigned Llong
940 #define MULTIPLE_THREADS 1
942 #ifndef MULTIPLE_THREADS
943 #define ACQUIRE_DTOA_LOCK(n)
944 #define FREE_DTOA_LOCK(n)
946 #define ACQUIRE_DTOA_LOCK(n)
947 #define FREE_DTOA_LOCK(n)
967 #ifndef Omit_Private_Memory
972 if (k <=
Kmax && (rv = freelist[k]) != 0) {
973 freelist[
k] = rv->
next;
977 #ifdef Omit_Private_Memory
980 len = (
sizeof(
Bigint) + (x-1)*
sizeof(ULong) +
sizeof(
double) - 1)
1006 v->
next = freelist[v->
k];
1012 #define Bcopy(x,y) memcpy((char *)&(x)->sign, (char *)&(y)->sign, \
1013 (y)->wds*sizeof(Long) + 2*sizeof(int))
1036 y = *x * (
ULLong)m + carry;
1042 y = (xi & 0xffff) * m + carry;
1043 z = (xi >> 16) * m + (y >> 16);
1045 *x++ = (z << 16) + (y & 0xffff);
1052 }
while (++i < wds);
1060 b->
x[wds++] = (ULong)carry;
1067 s2b(
const char *s,
int nd0,
int nd, ULong y9)
1074 for (k = 0, y = 1; x > y; y <<= 1, k++) ;
1081 b->
x[0] = y9 & 0xffff;
1082 b->
wds = (b->
x[1] = y9 >> 16) ? 2 : 1;
1089 b =
multadd(b, 10, *s++ -
'0');
1090 }
while (++i < nd0);
1096 b =
multadd(b, 10, *s++ -
'0');
1105 if (!(x & 0xffff0000)) {
1109 if (!(x & 0xff000000)) {
1113 if (!(x & 0xf0000000)) {
1117 if (!(x & 0xc0000000)) {
1121 if (!(x & 0x80000000)) {
1123 if (!(x & 0x40000000))
1133 register ULong
x = *y;
1146 if (!(x & 0xffff)) {
1188 ULong *
x, *xa, *xae, *xb, *xbe, *xc, *xc0;
1211 for (x = c->
x, xa = x + wc; x < xa; x++)
1219 for (; xb < xbe; xc0++) {
1220 if ((y = *xb++) != 0) {
1225 z = *x++ * (
ULLong)y + *xc + carry;
1234 for (; xb < xbe; xb++, xc0++) {
1235 if (y = *xb & 0xffff) {
1240 z = (*x & 0xffff) * y + (*xc & 0xffff) + carry;
1242 z2 = (*x++ >> 16) * y + (*xc >> 16) + carry;
1248 if (y = *xb >> 16) {
1254 z = (*x & 0xffff) * y + (*xc >> 16) + carry;
1257 z2 = (*x++ >> 16) * y + (*xc & 0xffff) + carry;
1264 for (; xb < xbe; xc0++) {
1270 z = *x++ * y + *xc + carry;
1279 for (xc0 = c->
x, xc = xc0 + wc; wc > 0 && !*--xc; --wc) ;
1291 static int p05[3] = { 5, 25, 125 };
1293 if ((i = k & 3) != 0)
1300 #ifdef MULTIPLE_THREADS
1303 p5 = p5s =
i2b(625);
1308 p5 = p5s =
i2b(625);
1320 if (!(p51 = p5->
next)) {
1321 #ifdef MULTIPLE_THREADS
1323 if (!(p51 = p5->
next)) {
1343 ULong *
x, *x1, *xe, z;
1351 n1 = n + b->
wds + 1;
1352 for (i = b->
maxwds; n1 > i; i <<= 1)
1356 for (i = 0; i < n; i++)
1365 *x1++ = *x << k | z;
1376 *x1++ = *x << k & 0xffff | z;
1395 ULong *xa, *xa0, *xb, *xb0;
1401 if (i > 1 && !a->
x[i-1])
1402 Bug(
"cmp called with a->x[a->wds-1] == 0");
1403 if (j > 1 && !b->
x[j-1])
1404 Bug(
"cmp called with b->x[b->wds-1] == 0");
1414 return *xa < *xb ? -1 : 1;
1426 ULong *xa, *xae, *xb, *xbe, *xc;
1463 y = (
ULLong)*xa++ - *xb++ - borrow;
1464 borrow = y >> 32 & (ULong)1;
1469 borrow = y >> 32 & (ULong)1;
1475 y = (*xa & 0xffff) - (*xb & 0xffff) - borrow;
1476 borrow = (y & 0x10000) >> 16;
1477 z = (*xa++ >> 16) - (*xb++ >> 16) - borrow;
1478 borrow = (z & 0x10000) >> 16;
1482 y = (*xa & 0xffff) - borrow;
1483 borrow = (y & 0x10000) >> 16;
1484 z = (*xa++ >> 16) - borrow;
1485 borrow = (z & 0x10000) >> 16;
1490 y = *xa++ - *xb++ - borrow;
1491 borrow = (y & 0x10000) >> 16;
1496 borrow = (y & 0x10000) >> 16;
1515 #ifndef Avoid_Underflow
1516 #ifndef Sudden_Underflow
1525 #ifndef Avoid_Underflow
1526 #ifndef Sudden_Underflow
1530 if (L < Exp_shift) {
1531 word0(a) = 0x80000 >> L;
1537 word1(a) = L >= 31 ? 1 : 1 << 31 - L;
1548 ULong *xa, *xa0, w, y, z;
1562 if (!y) Bug(
"zero y in b2d");
1569 w = xa > xa0 ? *--xa : 0;
1573 z = xa > xa0 ? *--xa : 0;
1575 d0 =
Exp_1 | y << k | z >> (32 -
k);
1576 y = xa > xa0 ? *--xa : 0;
1577 d1 = z << k | y >> (32 -
k);
1584 if (k <
Ebits + 16) {
1585 z = xa > xa0 ? *--xa : 0;
1587 w = xa > xa0 ? *--xa : 0;
1588 y = xa > xa0 ? *--xa : 0;
1592 z = xa > xa0 ? *--xa : 0;
1593 w = xa > xa0 ? *--xa : 0;
1595 d0 =
Exp_1 | y << k + 16 | z << k | w >> 16 -
k;
1596 y = xa > xa0 ? *--xa : 0;
1597 d1 = w << k + 16 | y <<
k;
1601 word0(d) = d0 >> 16 | d0 << 16;
1602 word1(d) = d1 >> 16 | d1 << 16;
1611 d2b(
double d_,
int *e,
int *bits)
1617 #ifndef Sudden_Underflow
1641 #ifdef Sudden_Underflow
1651 if ((y = d1) != 0) {
1653 x[0] = y | z << (32 -
k);
1658 #ifndef Sudden_Underflow
1661 b->
wds = (x[1] = z) ? 2 : 1;
1666 Bug(
"Zero passed to d2b");
1670 #ifndef Sudden_Underflow
1680 x[0] = y | z << 32 - k & 0xffff;
1681 x[1] = z >> k - 16 & 0xffff;
1687 x[1] = y >> 16 | z << 16 - k & 0xffff;
1688 x[2] = z >> k & 0xffff;
1703 Bug(
"Zero passed to d2b");
1721 #ifndef Sudden_Underflow
1725 *e = (de -
Bias - (
P-1) << 2) +
k;
1728 *e = de -
Bias - (
P-1) + k;
1731 #ifndef Sudden_Underflow
1734 *e = de -
Bias - (
P-1) + 1 + k;
1736 *bits = 32*i -
hi0bits(x[i-1]);
1738 *bits = (i+2)*16 -
hi0bits(x[i]);
1756 k = ka - kb + 32*(a->
wds - b->
wds);
1758 k = ka - kb + 16*(a->
wds - b->
wds);
1785 1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9,
1786 1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,
1796 static const double tinytens[] = { 1e-16, 1e-32, 1e-64, 1e-128,
1797 #ifdef Avoid_Underflow
1798 9007199254740992.*9007199254740992.e-256
1806 #define Scale_Bit 0x10
1810 bigtens[] = { 1e16, 1e32, 1e64 };
1811 static const double tinytens[] = { 1e-16, 1e-32, 1e-64 };
1815 static const double tinytens[] = { 1e-16, 1e-32 };
1827 #define NAN_WORD0 0x7ff80000
1835 match(
const char **sp,
char *t)
1838 const char *s = *sp;
1841 if ((c = *++s) >=
'A' && c <=
'Z')
1852 hexnan(
double *rvp,
const char **sp)
1856 int havedig, udx0, xshift;
1859 havedig = xshift = 0;
1862 while (c = *(
const unsigned char*)++s) {
1863 if (c >=
'0' && c <=
'9')
1865 else if (c >=
'a' && c <=
'f')
1867 else if (c >=
'A' && c <=
'F')
1869 else if (c <=
' ') {
1870 if (udx0 && havedig) {
1876 else if ( c ==
')' && havedig) {
1889 x[0] = (x[0] << 4) | (x[1] >> 28);
1890 x[1] = (x[1] << 4) | c;
1892 if ((x[0] &= 0xfffff) || x[1]) {
1903 #ifdef Avoid_Underflow
1906 int bb2, bb5, bbe, bd2, bd5, bbbits, bs2, c, dsign,
1907 e, e1, esign,
i, j,
k, nd, nd0, nf, nz, nz0,
sign;
1908 const char *s, *s0, *s1;
1910 double_u aadj1, rv, rv0;
1913 Bigint *bb, *bb1, *bd, *bd0, *bs, *delta;
1915 int inexact, oldinexact;
1917 #ifdef Honor_FLT_ROUNDS
1925 sign = nz0 = nz = 0;
1950 if (s[1] ==
'x' || s[1] ==
'X') {
1951 static const char hexdigit[] =
"0123456789abcdef0123456789ABCDEF";
1957 if (!*++s || !(s1 =
strchr(hexdigit, *s)))
goto ret0;
1958 while (*s ==
'0') s++;
1961 adj += aadj * ((s1 - hexdigit) & 15);
1964 }
while (*++s && (s1 =
strchr(hexdigit, *s)));
1969 if (!*++s || !(s1 =
strchr(hexdigit, *s)))
goto ret0;
1976 for (; *s && (s1 =
strchr(hexdigit, *s)); ++s) {
1977 adj += aadj * ((s1 - hexdigit) & 15);
1978 if ((aadj /= 16) == 0.0) {
1979 while (
strchr(hexdigit, *++s));
1988 if (*s ==
'P' || *s ==
'p') {
1989 dsign = 0x2C - *++s;
1990 if (abs(dsign) == 1) s++;
1995 if (c <
'0' ||
'9' < c)
goto ret0;
2002 if (nd + dsign * nd0 > 2095) {
2003 while (
'0' <= c && c <=
'9') c = *++s;
2006 }
while (
'0' <= c && c <=
'9');
2010 if (dsign)
goto ret0;
2012 dval(rv) = ldexp(adj, nd0);
2016 while (*++s ==
'0') ;
2022 for (nd = nf = 0; (c = *s) >=
'0' && c <=
'9'; nd++, s++)
2029 s1 = localeconv()->decimal_point;
2052 for (; c ==
'0'; c = *++s)
2054 if (c >
'0' && c <=
'9') {
2062 for (; c >=
'0' && c <=
'9'; c = *++s) {
2065 if (nf >
DBL_DIG * 4)
continue;
2068 for (i = 1; i < nz; i++)
2083 if (c ==
'e' || c ==
'E') {
2084 if (!nd && !nz && !nz0) {
2095 if (c >=
'0' && c <=
'9') {
2098 if (c >
'0' && c <=
'9') {
2101 while ((c = *++s) >=
'0' && c <=
'9')
2103 if (s - s1 > 8 || L > 19999)
2126 if (
match(&s,
"nf")) {
2128 if (!
match(&s,
"inity"))
2130 word0(rv) = 0x7ff00000;
2137 if (
match(&s,
"an")) {
2138 word0(rv) = NAN_WORD0;
2139 word1(rv) = NAN_WORD1;
2168 oldinexact = get_inexact();
2172 bd0 = bb = bd = bs = delta = 0;
2174 #ifndef RND_PRODQUOT
2175 #ifndef Honor_FLT_ROUNDS
2185 goto vax_ovfl_check;
2187 #ifdef Honor_FLT_ROUNDS
2203 #ifdef Honor_FLT_ROUNDS
2229 #ifndef Inaccurate_Divide
2231 #ifdef Honor_FLT_ROUNDS
2249 oldinexact = get_inexact();
2251 #ifdef Avoid_Underflow
2254 #ifdef Honor_FLT_ROUNDS
2257 rounding = rounding == 2 ? 0 : 2;
2268 if ((i = e1 & 15) != 0)
2278 #ifdef Honor_FLT_ROUNDS
2307 for (j = 0; e1 > 1; j++, e1 >>= 1)
2328 if ((i = e1 & 15) != 0)
2333 #ifdef Avoid_Underflow
2336 for (j = 0; e1 > 0; j++, e1 >>= 1)
2338 dval(rv) *= tinytens[j];
2347 word0(rv) &= 0xffffffff << (j-32);
2350 word1(rv) &= 0xffffffff << j;
2353 for (j = 0; e1 > 1; j++, e1 >>= 1)
2355 dval(rv) *= tinytens[j];
2358 dval(rv) *= tinytens[j];
2361 dval(rv) *= tinytens[j];
2373 #ifndef Avoid_Underflow
2388 bd0 =
s2b(s0, nd0, nd, y);
2393 bb =
d2b(
dval(rv), &bbe, &bbbits);
2409 #ifdef Honor_FLT_ROUNDS
2413 #ifdef Avoid_Underflow
2421 #ifdef Sudden_Underflow
2423 j = 1 + 4*
P - 3 - bbbits + ((bbe + bbbits - 1) & 3);
2438 #ifdef Avoid_Underflow
2441 i = bb2 < bd2 ? bb2 : bd2;
2463 delta =
diff(bb, bd);
2464 dsign = delta->
sign;
2467 #ifdef Honor_FLT_ROUNDS
2468 if (rounding != 1) {
2471 if (!delta->
x[0] && delta->
wds <= 1) {
2489 #ifdef Avoid_Underflow
2496 if (
cmp(delta, bs) <= 0)
2501 #ifdef Avoid_Underflow
2504 word0(adj) += (2*
P+1)*Exp_msk1 - y;
2506 #ifdef Sudden_Underflow
2507 if ((
word0(rv) & Exp_mask) <=
2520 adj =
ratio(delta, bs);
2523 if (adj <= 0x7ffffffe) {
2527 if (!((rounding>>1) ^ dsign))
2532 #ifdef Avoid_Underflow
2534 word0(adj) += (2*
P+1)*Exp_msk1 - y;
2536 #ifdef Sudden_Underflow
2572 if (!delta->
x[0] && delta->
wds <= 1)
2577 if (!delta->
x[0] && delta->
wds <= 1) {
2585 if (
cmp(delta, bs) > 0)
2596 ? (0xffffffff & (0xffffffff << (2*
P+1-(y>>
Exp_shift)))) :
2607 #ifdef Avoid_Underflow
2616 #ifdef Sudden_Underflow
2621 #ifdef Avoid_Underflow
2630 #ifdef Avoid_Underflow
2633 if (L <= (2*
P+1)*Exp_msk1) {
2634 if (L > (
P+2)*Exp_msk1)
2646 word1(rv) = 0xffffffff;
2653 #ifndef ROUND_BIASED
2659 #ifndef ROUND_BIASED
2662 #ifndef Sudden_Underflow
2667 #ifdef Avoid_Underflow
2673 if ((aadj =
ratio(delta, bs)) <= 2.) {
2675 aadj =
dval(aadj1) = 1.;
2677 #ifndef Sudden_Underflow
2692 dval(aadj1) = -aadj;
2697 dval(aadj1) = dsign ? aadj : -aadj;
2698 #ifdef Check_FLT_ROUNDS
2733 #ifdef Avoid_Underflow
2735 if (aadj <= 0x7fffffff) {
2736 if ((z = (
int)aadj) <= 0)
2739 dval(aadj1) = dsign ? aadj : -aadj;
2741 word0(aadj1) += (2*
P+1)*Exp_msk1 - y;
2746 #ifdef Sudden_Underflow
2753 if ((
word0(rv) & Exp_mask) <
P*Exp_msk1)
2755 if ((
word0(rv) & Exp_mask) <=
P*Exp_msk1)
2779 if (y <= (
P-1)*Exp_msk1 && aadj > 1.) {
2780 dval(aadj1) = (double)(
int)(aadj + 0.5);
2791 #ifdef Avoid_Underflow
2800 if (aadj < .4999999 || aadj > .5000001)
2821 else if (!oldinexact)
2824 #ifdef Avoid_Underflow
2852 return sign ? -
dval(rv) :
dval(rv);
2859 ULong *bx, *bxe, q, *sx, *sxe;
2861 ULLong borrow, carry, y, ys;
2863 ULong borrow, carry, y, ys;
2872 Bug(
"oversize b in quorem");
2880 q = *bxe / (*sxe + 1);
2883 Bug(
"oversized quotient in quorem");
2890 ys = *sx++ * (
ULLong)q + carry;
2892 y = *bx - (ys &
FFFFFFFF) - borrow;
2893 borrow = y >> 32 & (ULong)1;
2898 ys = (si & 0xffff) * q + carry;
2899 zs = (si >> 16) * q + (ys >> 16);
2901 y = (*bx & 0xffff) - (ys & 0xffff) - borrow;
2902 borrow = (y & 0x10000) >> 16;
2903 z = (*bx >> 16) - (zs & 0xffff) - borrow;
2904 borrow = (z & 0x10000) >> 16;
2907 ys = *sx++ * q + carry;
2909 y = *bx - (ys & 0xffff) - borrow;
2910 borrow = (y & 0x10000) >> 16;
2914 }
while (sx <= sxe);
2917 while (--bxe > bx && !*bxe)
2922 if (
cmp(b, S) >= 0) {
2932 y = *bx - (ys &
FFFFFFFF) - borrow;
2933 borrow = y >> 32 & (ULong)1;
2938 ys = (si & 0xffff) + carry;
2939 zs = (si >> 16) + (ys >> 16);
2941 y = (*bx & 0xffff) - (ys & 0xffff) - borrow;
2942 borrow = (y & 0x10000) >> 16;
2943 z = (*bx >> 16) - (zs & 0xffff) - borrow;
2944 borrow = (z & 0x10000) >> 16;
2949 y = *bx - (ys & 0xffff) - borrow;
2950 borrow = (y & 0x10000) >> 16;
2954 }
while (sx <= sxe);
2958 while (--bxe > bx && !*bxe)
2966 #ifndef MULTIPLE_THREADS
2967 static char *dtoa_result;
2970 #ifndef MULTIPLE_THREADS
2974 return dtoa_result =
xmalloc(i);
2977 #define rv_alloc(i) xmalloc(i)
2986 while ((*t = *s++) != 0) t++;
2992 #define rv_strdup(s, rve) nrv_alloc((s), (rve), strlen(s)+1)
2994 #ifndef MULTIPLE_THREADS
3083 int bbits, b2, b5, be, dig,
i, ieps, ilim, ilim0, ilim1,
3084 j, j1,
k, k0, k_check, leftright, m2, m5, s2, s5,
3085 spec_case, try_quick;
3087 #ifndef Sudden_Underflow
3091 Bigint *b, *b1, *delta, *mlo = 0, *mhi = 0, *
S;
3093 double_u d, d2, eps;
3095 #ifdef Honor_FLT_ROUNDS
3099 int inexact, oldinexact;
3104 #ifndef MULTIPLE_THREADS
3106 freedtoa(dtoa_result);
3114 word0(d) &= ~Sign_bit;
3119 #if defined(IEEE_Arith) + defined(VAX)
3123 if (
word0(d) == 0x8000)
3144 try_quick = oldinexact = get_inexact();
3147 #ifdef Honor_FLT_ROUNDS
3150 rounding = rounding == 2 ? 0 : 2;
3157 b =
d2b(
dval(d), &be, &bbits);
3158 #ifdef Sudden_Underflow
3198 #ifndef Sudden_Underflow
3204 i = bbits + be + (
Bias + (
P-1) - 1);
3205 x = i > 32 ?
word0(d) << (64 -
i) |
word1(d) >> (i - 32)
3209 i -= (
Bias + (
P-1) - 1) + 1;
3213 ds = (
dval(d2)-1.5)*0.289529654602168 + 0.1760912590558 + i*0.301029995663981;
3215 if (ds < 0. && ds != k)
3242 if (mode < 0 || mode > 9)
3246 #ifdef Check_FLT_ROUNDS
3271 ilim = ilim1 = i = ndigits;
3277 i = ndigits + k + 1;
3285 #ifdef Honor_FLT_ROUNDS
3286 if (mode > 1 && rounding != 1)
3290 if (ilim >= 0 && ilim <=
Quick_max && try_quick) {
3308 for (; j; j >>= 1, i++)
3315 else if ((j1 = -k) != 0) {
3317 for (j = j1 >> 4; j; j >>= 1, i++)
3323 if (k_check &&
dval(d) < 1. && ilim > 0) {
3342 #ifndef No_leftright
3351 *s++ =
'0' + (int)L;
3366 for (i = 1;; i++,
dval(d) *= 10.) {
3367 L = (Long)(
dval(d));
3368 if (!(
dval(d) -= L))
3370 *s++ =
'0' + (int)L;
3374 else if (
dval(d) < 0.5 -
dval(eps)) {
3375 while (*--s ==
'0') ;
3382 #ifndef No_leftright
3394 if (be >= 0 && k <=
Int_max) {
3397 if (ndigits < 0 && ilim <= 0) {
3399 if (ilim < 0 ||
dval(d) <= 5*ds)
3403 for (i = 1;; i++,
dval(d) *= 10.) {
3404 L = (Long)(
dval(d) / ds);
3406 #ifdef Check_FLT_ROUNDS
3413 *s++ =
'0' + (int)L;
3421 #ifdef Honor_FLT_ROUNDS
3425 case 2:
goto bump_up;
3429 if (
dval(d) > ds || (
dval(d) == ds && (L & 1))) {
3449 #ifndef Sudden_Underflow
3450 denorm ? be + (
Bias + (
P-1) - 1 + 1) :
3453 1 + 4*
P - 3 - bbits + ((bbits + be - 1) & 3);
3461 if (m2 > 0 && s2 > 0) {
3462 i = m2 < s2 ? m2 : s2;
3475 if ((j = b5 - m5) != 0)
3488 if ((mode < 2 || leftright)
3489 #ifdef Honor_FLT_ROUNDS
3494 #ifndef Sudden_Underflow
3513 if ((i = ((s5 ? 32 -
hi0bits(
S->x[
S->wds-1]) : 1) + s2) & 0x1f) != 0)
3516 if ((i = ((s5 ? 32 -
hi0bits(
S->x[
S->wds-1]) : 1) + s2) & 0xf) != 0)
3544 if (ilim <= 0 && (mode == 3 || mode == 5)) {
3577 delta =
diff(
S, mhi);
3578 j1 = delta->
sign ? 1 :
cmp(b, delta);
3580 #ifndef ROUND_BIASED
3581 if (j1 == 0 && mode != 1 && !(
word1(d) & 1)
3582 #ifdef Honor_FLT_ROUNDS
3591 else if (!b->
x[0] && b->
wds <= 1)
3598 if (j < 0 || (j == 0 && mode != 1
3599 #ifndef ROUND_BIASED
3603 if (!b->
x[0] && b->
wds <= 1) {
3609 #ifdef Honor_FLT_ROUNDS
3612 case 0:
goto accept_dig;
3613 case 2:
goto keep_dig;
3619 if ((j1 > 0 || (j1 == 0 && (dig & 1))) && dig++ ==
'9')
3627 #ifdef Honor_FLT_ROUNDS
3639 #ifdef Honor_FLT_ROUNDS
3647 mlo = mhi =
multadd(mhi, 10, 0);
3656 *s++ = dig =
quorem(b,
S) +
'0';
3657 if (!b->
x[0] && b->
wds <= 1) {
3670 #ifdef Honor_FLT_ROUNDS
3672 case 0:
goto trimzeros;
3673 case 2:
goto roundoff;
3678 if (j > 0 || (j == 0 && (dig & 1))) {
3689 while (*--s ==
'0') ;
3695 if (mlo && mlo != mhi)
3708 else if (!oldinexact)
3726 for (; *str; str = end) {
3727 while (
ISSPACE(*str) || *str ==
',') str++;
3730 while (*end && !
ISSPACE(*end) && *end !=
',') end++;
3731 len = (int)(end - str);
3762 #define DBL_MANH_SIZE 20
3763 #define DBL_MANL_SIZE 32
3764 #define DBL_ADJ (DBL_MAX_EXP - 2)
3765 #define SIGFIGS ((DBL_MANT_DIG + 3) / 4 + 1)
3766 #define dexp_get(u) ((int)(word0(u) >> Exp_shift) & ~Exp_msk1)
3767 #define dexp_set(u,v) (word0(u) = (((int)(word0(u)) & ~Exp_mask) | ((v) << Exp_shift)))
3768 #define dmanh_get(u) ((uint32_t)(word0(u) & Frac_mask))
3769 #define dmanl_get(u) ((uint32_t)word1(u))
3809 word0(u) &= ~Sign_bit;
3818 else if (
isnan(d)) {
3822 else if (d == 0.0) {
3830 u.
d *= 5.363123171977039e+154 ;
3841 bufsize = (ndigits > 0) ? ndigits :
SIGFIGS;
3845 if (
SIGFIGS > ndigits && ndigits > 0) {
3860 for (s = s0 + 1; s < s0 + bufsize; s++) {
3868 for (ndigits =
SIGFIGS; s0[ndigits - 1] ==
'0'; ndigits--)