132 #ifdef WORDS_BIGENDIAN 140 #ifdef HAVE_LONG_LONG 141 #define ULLong uint64 144 #define MALLOC ckd_malloc 145 #define FREE ckd_free 148 #define DBL_MAX_10_EXP 308 149 #define DBL_MAX_EXP 1024 156 #define MAX_ABS_EXP 1100000000U 164 #define MAX_DIGITS 1000000000U 170 #define Bug(x) {fprintf(stderr, "%s\n", x); exit(1);} 178 typedef union {
double d; ULong L[2]; }
U;
181 #define word0(x) (x)->L[1] 182 #define word1(x) (x)->L[0] 184 #define word0(x) (x)->L[0] 185 #define word1(x) (x)->L[1] 187 #define dval(x) (x)->d 189 #ifndef STRTOD_DIGLIM 190 #define STRTOD_DIGLIM 40 197 #define MAX_ABS_EXP 1100000000U 205 #define MAX_DIGITS 1000000000U 210 #if MAX_ABS_EXP > 0x7fffffff 211 #error "MAX_ABS_EXP should fit in an int" 213 #if MAX_DIGITS > 0x7fffffff 214 #error "MAX_DIGITS should fit in an int" 221 #if defined(IEEE_8087) 222 #define Storeinc(a,b,c) (((unsigned short *)a)[1] = (unsigned short)b, \ 223 ((unsigned short *)a)[0] = (unsigned short)c, a++) 225 #define Storeinc(a,b,c) (((unsigned short *)a)[0] = (unsigned short)b, \ 226 ((unsigned short *)a)[1] = (unsigned short)c, a++) 236 #define Exp_shift1 20 237 #define Exp_msk1 0x100000 238 #define Exp_msk11 0x100000 239 #define Exp_mask 0x7ff00000 245 #define Etiny (-1074) 246 #define Exp_1 0x3ff00000 247 #define Exp_11 0x3ff00000 249 #define Frac_mask 0xfffff 250 #define Frac_mask1 0xfffff 253 #define Bndry_mask 0xfffff 254 #define Bndry_mask1 0xfffff 255 #define Sign_bit 0x80000000 264 #define Flt_Rounds FLT_ROUNDS 270 #define Rounding Flt_Rounds 272 #define Big0 (Frac_mask1 | Exp_msk1*(DBL_MAX_EXP+Bias-1)) 273 #define Big1 0xffffffff 277 #define NAN_WORD0 0x7ff80000 282 #define POSINF_WORD0 0x7ff00000 283 #define POSINF_WORD1 0 290 int e0, nd, nd0, scale;
293 #define FFFFFFFF 0xffffffffUL 322 int k, maxwds, sign, wds;
328 #define SPHINXBASE_USING_MEMORY_DEBUGGER 1 330 #ifndef SPHINXBASE_USING_MEMORY_DEBUGGER 333 #define PRIVATE_MEM 2304 335 #define PRIVATE_mem ((PRIVATE_MEM+sizeof(double)-1)/sizeof(double)) 336 static double private_mem[PRIVATE_mem], *pmem_next = private_mem;
357 static Bigint *freelist[Kmax+1];
368 if (k <= Kmax && (rv = freelist[k]))
369 freelist[k] = rv->next;
372 len = (
sizeof(
Bigint) + (x-1)*
sizeof(ULong) +
sizeof(
double) - 1)
374 if (k <= Kmax && pmem_next - private_mem + len <= PRIVATE_mem) {
379 rv = (
Bigint*)MALLOC(len*
sizeof(
double));
386 rv->sign = rv->wds = 0;
399 v->next = freelist[v->k];
422 len = (
sizeof(
Bigint) + (x-1)*
sizeof(ULong) +
sizeof(
double) - 1)
425 rv = (
Bigint*)MALLOC(len*
sizeof(
double));
431 rv->sign = rv->wds = 0;
447 #define Bcopy(x,y) memcpy((char *)&x->sign, (char *)&y->sign, \ 448 y->wds*sizeof(Long) + 2*sizeof(int)) 455 multadd(
Bigint *b,
int m,
int a)
473 y = *x * (ULLong)m + carry;
475 *x++ = (ULong)(y & FFFFFFFF);
478 y = (xi & 0xffff) * m + carry;
479 z = (xi >> 16) * m + (y >> 16);
481 *x++ = (z << 16) + (y & 0xffff);
486 if (wds >= b->maxwds) {
496 b->x[wds++] = (ULong)carry;
509 s2b(
const char *s,
int nd0,
int nd, ULong y9)
516 for(k = 0, y = 1; x > y; y <<= 1, k++) ;
527 for (i = 9; i < nd0; i++) {
528 b = multadd(b, 10, *s++ -
'0');
534 b = multadd(b, 10, *s++ -
'0');
548 if (!(x & 0xffff0000)) {
552 if (!(x & 0xff000000)) {
556 if (!(x & 0xf0000000)) {
560 if (!(x & 0xc0000000)) {
564 if (!(x & 0x80000000)) {
566 if (!(x & 0x40000000))
641 ULong *x, *xa, *xae, *xb, *xbe, *xc, *xc0;
650 if ((!a->x[0] && a->wds == 1) || (!b->x[0] && b->wds == 1)) {
659 if (a->wds < b->wds) {
673 for(x = c->x, xa = x + wc; x < xa; x++)
681 for(; xb < xbe; xc0++) {
687 z = *x++ * (ULLong)y + *xc + carry;
689 *xc++ = (ULong)(z & FFFFFFFF);
696 for(; xb < xbe; xb++, xc0++) {
697 if (y = *xb & 0xffff) {
702 z = (*x & 0xffff) * y + (*xc & 0xffff) + carry;
704 z2 = (*x++ >> 16) * y + (*xc >> 16) + carry;
717 z = (*x & 0xffff) * y + (*xc >> 16) + carry;
720 z2 = (*x++ >> 16) * y + (*xc & 0xffff) + carry;
728 for(xc0 = c->x, xc = xc0 + wc; wc > 0 && !*--xc; --wc) ;
733 #ifndef SPHINXBASE_USING_MEMORY_DEBUGGER 744 pow5mult(
Bigint *b,
int k)
748 static int p05[3] = { 5, 25, 125 };
751 b = multadd(b, p05[i-1], 0);
800 pow5mult(
Bigint *b,
int k)
804 static int p05[3] = { 5, 25, 125 };
807 b = multadd(b, p05[i-1], 0);
855 ULong *x, *x1, *xe, z;
857 if (!k || (!b->x[0] && b->wds == 1))
863 for(i = b->maxwds; n1 > i; i <<= 1)
871 for(i = 0; i < n; i++)
900 ULong *xa, *xa0, *xb, *xb0;
906 if (i > 1 && !a->x[i-1])
907 Bug(
"cmp called with a->x[a->wds-1] == 0");
908 if (j > 1 && !b->x[j-1])
909 Bug(
"cmp called with b->x[b->wds-1] == 0");
919 return *xa < *xb ? -1 : 1;
935 ULong *xa, *xae, *xb, *xbe, *xc;
974 y = (ULLong)*xa++ - *xb++ - borrow;
975 borrow = y >> 32 & (ULong)1;
976 *xc++ = (ULong)(y & FFFFFFFF);
981 borrow = y >> 32 & (ULong)1;
982 *xc++ = (ULong)(y & FFFFFFFF);
986 y = (*xa & 0xffff) - (*xb & 0xffff) - borrow;
987 borrow = (y & 0x10000) >> 16;
988 z = (*xa++ >> 16) - (*xb++ >> 16) - borrow;
989 borrow = (z & 0x10000) >> 16;
994 y = (*xa & 0xffff) - borrow;
995 borrow = (y & 0x10000) >> 16;
996 z = (*xa++ >> 16) - borrow;
997 borrow = (z & 0x10000) >> 16;
1016 L = (word0(x) & Exp_mask) - (P-1)*Exp_msk1;
1027 ULong *xa, *xa0, w, y, z;
1035 if (!y) Bug(
"zero y in b2d");
1040 word0(&d) = Exp_1 | y >> (Ebits - k);
1041 w = xa > xa0 ? *--xa : 0;
1042 word1(&d) = y << ((32-Ebits) + k) | w >> (Ebits - k);
1045 z = xa > xa0 ? *--xa : 0;
1047 word0(&d) = Exp_1 | y << k | z >> (32 - k);
1048 y = xa > xa0 ? *--xa : 0;
1049 word1(&d) = z << k | y >> (32 - k);
1052 word0(&d) = Exp_1 | y;
1081 sd2b(
U *d,
int scale,
int *e)
1092 b->x[1] = word0(d) & Frac_mask;
1093 *e = Etiny - 1 + (int)((word0(d) & Exp_mask) >> Exp_shift);
1097 b->x[1] |= Exp_msk1;
1100 if (scale && (b->x[0] || b->x[1])) {
1106 assert(0 < scale && scale <= P - 1);
1109 assert(b->x[0] == 0);
1116 assert(b->x[0] << (32 - scale) == 0);
1117 b->x[0] = (b->x[0] >> scale) | (b->x[1] << (32 - scale));
1139 d2b(
U *d,
int *e,
int *bits)
1151 z = word0(d) & Frac_mask;
1152 word0(d) &= 0x7fffffff;
1153 if ((de = (
int)(word0(d) >> Exp_shift)))
1155 if ((y = word1(d))) {
1156 if ((k = lo0bits(&y))) {
1157 x[0] = y | z << (32 - k);
1163 b->wds = (x[1] = z) ? 2 : 1;
1173 *e = de - Bias - (P-1) + k;
1177 *e = de - Bias - (P-1) + 1 + k;
1178 *bits = 32*i - hi0bits(x[i-1]);
1192 dval(&da) = b2d(a, &ka);
1193 dval(&db) = b2d(b, &kb);
1194 k = ka - kb + 32*(a->wds - b->wds);
1196 word0(&da) += k*Exp_msk1;
1199 word0(&db) += k*Exp_msk1;
1201 return dval(&da) / dval(&db);
1206 1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9,
1207 1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,
1212 bigtens[] = { 1e16, 1e32, 1e64, 1e128, 1e256 };
1213 static const double tinytens[] = { 1e-16, 1e-32, 1e-64, 1e-128,
1214 9007199254740992.*9007199254740992.e-256
1219 #define Scale_Bit 0x10 1228 dshift(
Bigint *b,
int p2)
1230 int rv = hi0bits(b->x[b->wds-1]) - 4;
1244 ULong *bx, *bxe, q, *sx, *sxe;
1246 ULLong borrow, carry, y, ys;
1248 ULong borrow, carry, y, ys;
1255 Bug(
"oversize b in quorem");
1263 q = *bxe / (*sxe + 1);
1266 Bug(
"oversized quotient in quorem");
1273 ys = *sx++ * (ULLong)q + carry;
1275 y = *bx - (ys & FFFFFFFF) - borrow;
1276 borrow = y >> 32 & (ULong)1;
1277 *bx++ = (ULong)(y & FFFFFFFF);
1280 ys = (si & 0xffff) * q + carry;
1281 zs = (si >> 16) * q + (ys >> 16);
1283 y = (*bx & 0xffff) - (ys & 0xffff) - borrow;
1284 borrow = (y & 0x10000) >> 16;
1285 z = (*bx >> 16) - (zs & 0xffff) - borrow;
1286 borrow = (z & 0x10000) >> 16;
1293 while(--bxe > bx && !*bxe)
1298 if (cmp(b, S) >= 0) {
1308 y = *bx - (ys & FFFFFFFF) - borrow;
1309 borrow = y >> 32 & (ULong)1;
1310 *bx++ = (ULong)(y & FFFFFFFF);
1313 ys = (si & 0xffff) + carry;
1314 zs = (si >> 16) + (ys >> 16);
1316 y = (*bx & 0xffff) - (ys & 0xffff) - borrow;
1317 borrow = (y & 0x10000) >> 16;
1318 z = (*bx >> 16) - (zs & 0xffff) - borrow;
1319 borrow = (z & 0x10000) >> 16;
1327 while(--bxe > bx && !*bxe)
1346 if (bc->scale && 2*P + 1 > (
int)((word0(x) & Exp_mask) >> Exp_shift)) {
1348 word0(&u) = (P+2)*Exp_msk1;
1353 assert(word0(x) || word1(x));
1405 bigcomp(
U *rv,
const char *s0,
BCinfo *bc)
1408 int b2, d2, dd, i, nd, nd0, odd, p2, p5;
1413 b = sd2b(rv, bc->scale, &p2);
1439 d = pow5mult(d, p5);
1446 b = pow5mult(b, -p5);
1461 if ((b2 += i) > 0) {
1468 if ((d2 += i) > 0) {
1485 b = multadd(b, 10, 0);
1490 dd = s0[i < nd0 ? i : i+1] -
'0' - quorem(b, d);
1495 if (!b->x[0] && b->wds == 1) {
1509 if (dd > 0 || (dd == 0 && odd))
1510 dval(rv) += sulp(rv, bc);
1525 word0(&rv) = NAN_WORD0;
1526 word1(&rv) = NAN_WORD1;
1528 word0(&rv) |= Sign_bit;
1536 sb_infinity(
int sign)
1539 word0(&rv) = POSINF_WORD0;
1540 word1(&rv) = POSINF_WORD1;
1541 return sign ? -dval(&rv) : dval(&rv);
1545 sb_strtod(
const char *s00,
char **se)
1547 int bb2, bb5, bbe, bd2, bd5, bs2, c, dsign, e, e1, error;
1548 int esign, i, j, k, lz, nd, nd0, odd, sign;
1549 const char *s, *s0, *s1;
1551 U aadj2, adj, rv, rv0;
1552 ULong y, z, abs_exp;
1555 Bigint *bb, *bb1, *bd, *bd0, *bs, *delta;
1556 size_t ndigits, fraclen;
1584 while (
'0' <= c && c <=
'9')
1597 fraclen += (s - s1);
1601 while (
'0' <= c && c <=
'9')
1610 if (!ndigits && !lz) {
1618 if (ndigits > MAX_DIGITS || fraclen > MAX_DIGITS) {
1624 nd0 = (int)ndigits - (
int)fraclen;
1628 if (c ==
'e' || c ==
'E') {
1651 while (
'0' <= c && c <=
'9') {
1652 abs_exp = 10*abs_exp + (c -
'0');
1659 if (s - s1 > 9 || abs_exp > MAX_ABS_EXP)
1660 e = (int)MAX_ABS_EXP;
1684 for (i = nd; i > 0; ) {
1686 if (s0[i < nd0 ? i : i+1] !=
'0') {
1734 for (i = 0; i < nd; i++) {
1736 y = 10*y + s0[i < nd0 ? i : i+1] -
'0';
1737 else if (i < DBL_DIG+1)
1738 z = 10*z + s0[i < nd0 ? i : i+1] -
'0';
1743 k = nd < DBL_DIG + 1 ? nd : DBL_DIG + 1;
1746 dval(&rv) = tens[k - 9] * dval(&rv) + z;
1755 if (e <= Ten_pmax) {
1756 dval(&rv) *= tens[e];
1760 if (e <= Ten_pmax + i) {
1765 dval(&rv) *= tens[i];
1766 dval(&rv) *= tens[e];
1770 else if (e >= -Ten_pmax) {
1771 dval(&rv) /= tens[-e];
1783 dval(&rv) *= tens[i];
1785 if (e1 > DBL_MAX_10_EXP)
1788 for(j = 0; e1 > 1; j++, e1 >>= 1)
1790 dval(&rv) *= bigtens[j];
1792 word0(&rv) -= P*Exp_msk1;
1793 dval(&rv) *= bigtens[j];
1794 if ((z = word0(&rv) & Exp_mask)
1795 > Exp_msk1*(DBL_MAX_EXP+Bias-P))
1797 if (z > Exp_msk1*(DBL_MAX_EXP+Bias-1-P)) {
1804 word0(&rv) += P*Exp_msk1;
1820 dval(&rv) /= tens[i];
1822 if (e1 >= 1 << n_bigtens)
1826 for(j = 0; e1 > 0; j++, e1 >>= 1)
1828 dval(&rv) *= tinytens[j];
1829 if (bc.scale && (j = 2*P + 1 - ((word0(&rv) & Exp_mask)
1830 >> Exp_shift)) > 0) {
1835 word0(&rv) = (P+2)*Exp_msk1;
1837 word0(&rv) &= 0xffffffff << (j-32);
1840 word1(&rv) &= 0xffffffff << j;
1855 if (nd > STRTOD_DIGLIM) {
1863 for (i = 18; i > 0; ) {
1867 if (s0[i < nd0 ? i : i+1] !=
'0') {
1878 for(i = 0; i < nd0; ++i)
1879 y = 10*y + s0[i] -
'0';
1881 y = 10*y + s0[i+1] -
'0';
1884 bd0 = s2b(s0, nd0, nd, y);
1916 bd = Balloc(bd0->k);
1922 bb = sd2b(&rv, bc.scale, &bbe);
1975 i = bb2 < bd2 ? bb2 : bd2;
1986 bs = pow5mult(bs, bb5);
2004 bb = lshift(bb, bb2);
2013 bd = pow5mult(bd, bd5);
2022 bd = lshift(bd, bd2);
2031 bs = lshift(bs, bs2);
2044 delta = diff(bb, bd);
2045 if (delta == NULL) {
2052 dsign = delta->sign;
2055 if (bc.nd > nd && i <= 0) {
2070 if (!word1(&rv) && !(word0(&rv) & Bndry_mask)) {
2073 j = (int)(word0(&rv) & Exp_mask) >> Exp_shift;
2076 if (j - bc.scale >= 2) {
2077 dval(&rv) -= 0.5 * sulp(&rv, &bc);
2092 if (dsign || word1(&rv) || word0(&rv) & Bndry_mask
2093 || (word0(&rv) & Exp_mask) <= (2*P+1)*Exp_msk1
2097 if (!delta->x[0] && delta->wds <= 1) {
2101 delta = lshift(delta,Log2P);
2102 if (delta == NULL) {
2109 if (cmp(delta, bs) > 0)
2116 if ((word0(&rv) & Bndry_mask1) == Bndry_mask1
2119 (y = word0(&rv) & Exp_mask) <= 2*P*Exp_msk1) ?
2120 (0xffffffff & (0xffffffff << (2*P+1-(y>>Exp_shift)))) :
2123 word0(&rv) = (word0(&rv) & Exp_mask)
2131 else if (!(word0(&rv) & Bndry_mask) && !word1(&rv)) {
2135 L = word0(&rv) & Exp_mask;
2136 if (L <= (2*P+1)*Exp_msk1) {
2137 if (L > (P+2)*Exp_msk1)
2147 L = (word0(&rv) & Exp_mask) - Exp_msk1;
2148 word0(&rv) = L | Bndry_mask1;
2149 word1(&rv) = 0xffffffff;
2155 dval(&rv) += sulp(&rv, &bc);
2157 dval(&rv) -= sulp(&rv, &bc);
2167 if ((aadj = ratio(delta, bs)) <= 2.) {
2170 else if (word1(&rv) || word0(&rv) & Bndry_mask) {
2171 if (word1(&rv) == Tiny1 && !word0(&rv)) {
2183 if (aadj < 2./FLT_RADIX)
2184 aadj = 1./FLT_RADIX;
2192 aadj1 = dsign ? aadj : -aadj;
2193 if (Flt_Rounds == 0)
2196 y = word0(&rv) & Exp_mask;
2200 if (y == Exp_msk1*(DBL_MAX_EXP+Bias-1)) {
2201 dval(&rv0) = dval(&rv);
2202 word0(&rv) -= P*Exp_msk1;
2203 adj.d = aadj1 * ulp(&rv);
2205 if ((word0(&rv) & Exp_mask) >=
2206 Exp_msk1*(DBL_MAX_EXP+Bias-P)) {
2207 if (word0(&rv0) == Big0 && word1(&rv0) == Big1) {
2220 word0(&rv) += P*Exp_msk1;
2223 if (bc.scale && y <= 2*P*Exp_msk1) {
2224 if (aadj <= 0x7fffffff) {
2225 if ((z = (ULong)aadj) <= 0)
2228 aadj1 = dsign ? aadj : -aadj;
2230 dval(&aadj2) = aadj1;
2231 word0(&aadj2) += (2*P+1)*Exp_msk1 - y;
2232 aadj1 = dval(&aadj2);
2234 adj.d = aadj1 * ulp(&rv);
2237 z = word0(&rv) & Exp_mask;
2245 if (dsign || word1(&rv) || word0(&rv) & Bndry_mask) {
2246 if (aadj < .4999999 || aadj > .5000001)
2249 else if (aadj < .4999999/FLT_RADIX)
2265 error = bigcomp(&rv, s0, &bc);
2271 word0(&rv0) = Exp_1 - 2*P*Exp_msk1;
2273 dval(&rv) *= dval(&rv0);
2277 return sign ? -dval(&rv) : dval(&rv);
2287 return sign ? -0.0 : 0.0;
2292 word0(&rv) = Exp_mask;
2294 return sign ? -dval(&rv) : dval(&rv);
2305 sizeof(
Bigint) -
sizeof(ULong) -
sizeof(int) + j <= (
unsigned)i;
2308 r = (
int*)Balloc(k);
2312 return (
char *)(r+1);
2316 nrv_alloc(
char *s,
char **rve,
int n)
2324 while((*t = *s++)) t++;
2337 sb_freedtoa(
char *s)
2340 b->maxwds = 1 << (b->k = *(
int*)b);
2383 sb_dtoa(
double dd,
int mode,
int ndigits,
2384 int *decpt,
int *sign,
char **rve)
2420 int bbits, b2, b5, be, dig, i, ieps, ilim, ilim0, ilim1,
2421 j, j1, k, k0, k_check, leftright, m2, m5, s2, s5,
2422 spec_case, try_quick;
2426 Bigint *b, *b1, *delta, *mlo, *mhi, *S;
2437 if (word0(&u) & Sign_bit) {
2440 word0(&u) &= ~Sign_bit;
2446 if ((word0(&u) & Exp_mask) == Exp_mask)
2450 if (!word1(&u) && !(word0(&u) & 0xfffff))
2451 return nrv_alloc(
"Infinity", rve, 8);
2452 return nrv_alloc(
"NaN", rve, 3);
2456 return nrv_alloc(
"0", rve, 1);
2461 b = d2b(&u, &be, &bbits);
2464 if ((i = (
int)(word0(&u) >> Exp_shift1 & (Exp_mask>>Exp_shift1)))) {
2465 dval(&d2) = dval(&u);
2466 word0(&d2) &= Frac_mask1;
2467 word0(&d2) |= Exp_11;
2497 i = bbits + be + (Bias + (P-1) - 1);
2498 x = i > 32 ? word0(&u) << (64 - i) | word1(&u) >> (i - 32)
2499 : word1(&u) << (32 - i);
2501 word0(&d2) -= 31*Exp_msk1;
2502 i -= (Bias + (P-1) - 1) + 1;
2505 ds = (dval(&d2)-1.5)*0.289529654602168 + 0.1760912590558 +
2506 i*0.301029995663981;
2508 if (ds < 0. && ds != k)
2511 if (k >= 0 && k <= Ten_pmax) {
2512 if (dval(&u) < tens[k])
2535 if (mode < 0 || mode > 9)
2559 ilim = ilim1 = i = ndigits;
2565 i = ndigits + k + 1;
2577 if (ilim >= 0 && ilim <= Quick_max && try_quick) {
2582 dval(&d2) = dval(&u);
2592 dval(&u) /= bigtens[n_bigtens-1];
2595 for(; j; j >>= 1, i++)
2602 else if ((j1 = -k)) {
2603 dval(&u) *= tens[j1 & 0xf];
2604 for(j = j1 >> 4; j; j >>= 1, i++)
2607 dval(&u) *= bigtens[i];
2610 if (k_check && dval(&u) < 1. && ilim > 0) {
2618 dval(&eps) = ieps*dval(&u) + 7.;
2619 word0(&eps) -= (P-1)*Exp_msk1;
2623 if (dval(&u) > dval(&eps))
2625 if (dval(&u) < -dval(&eps))
2633 dval(&eps) = 0.5/tens[ilim-1] - dval(&eps);
2637 *s++ =
'0' + (int)L;
2638 if (dval(&u) < dval(&eps))
2640 if (1. - dval(&u) < dval(&eps))
2650 dval(&eps) *= tens[ilim-1];
2651 for(i = 1;; i++, dval(&u) *= 10.) {
2652 L = (Long)(dval(&u));
2653 if (!(dval(&u) -= L))
2655 *s++ =
'0' + (int)L;
2657 if (dval(&u) > 0.5 + dval(&eps))
2659 else if (dval(&u) < 0.5 - dval(&eps)) {
2670 dval(&u) = dval(&d2);
2677 if (be >= 0 && k <= Int_max) {
2680 if (ndigits < 0 && ilim <= 0) {
2682 if (ilim < 0 || dval(&u) <= 5*ds)
2686 for(i = 1;; i++, dval(&u) *= 10.) {
2687 L = (Long)(dval(&u) / ds);
2689 *s++ =
'0' + (int)L;
2694 dval(&u) += dval(&u);
2695 if (dval(&u) > ds || (dval(&u) == ds && L & 1)) {
2715 denorm ? be + (Bias + (P-1) - 1 + 1) :
2723 if (m2 > 0 && s2 > 0) {
2724 i = m2 < s2 ? m2 : s2;
2732 mhi = pow5mult(mhi, m5);
2741 if ((j = b5 - m5)) {
2748 b = pow5mult(b, b5);
2757 S = pow5mult(S, s5);
2765 if ((mode < 2 || leftright)
2767 if (!word1(&u) && !(word0(&u) & Bndry_mask)
2768 && word0(&u) & (Exp_mask & ~Exp_msk1)
2802 b = multadd(b, 10, 0);
2806 mhi = multadd(mhi, 10, 0);
2813 if (ilim <= 0 && (mode == 3 || mode == 5)) {
2821 S = multadd(S, 5, 0);
2834 mhi = lshift(mhi, m2);
2845 mhi = Balloc(mhi->k);
2849 mhi = lshift(mhi, Log2P);
2855 dig = quorem(b,S) +
'0';
2860 delta = diff(S, mhi);
2863 j1 = delta->sign ? 1 : cmp(b, delta);
2865 if (j1 == 0 && mode != 1 && !(word1(&u) & 1)
2874 if (j < 0 || (j == 0 && mode != 1
2877 if (!b->x[0] && b->wds <= 1) {
2885 if ((j1 > 0 || (j1 == 0 && dig & 1))
2905 b = multadd(b, 10, 0);
2909 mlo = mhi = multadd(mhi, 10, 0);
2914 mlo = multadd(mlo, 10, 0);
2917 mhi = multadd(mhi, 10, 0);
2925 *s++ = dig = quorem(b,S) +
'0';
2926 if (!b->x[0] && b->wds <= 1) {
2931 b = multadd(b, 10, 0);
2942 if (j > 0 || (j == 0 && dig & 1)) {
2959 if (mlo && mlo != mhi)
2973 if (mlo && mlo != mhi)
Sphinx's memory allocation/deallocation routines.
Basic type definitions used in Sphinx.