| File: | src/lib/libc/gdtoa/misc.c |
| Warning: | line 81, column 18 Result of 'malloc' is converted to a pointer of type 'Bigint', which is incompatible with sizeof operand type 'double' |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
| 1 | /**************************************************************** |
| 2 | |
| 3 | The author of this software is David M. Gay. |
| 4 | |
| 5 | Copyright (C) 1998, 1999 by Lucent Technologies |
| 6 | All Rights Reserved |
| 7 | |
| 8 | Permission to use, copy, modify, and distribute this software and |
| 9 | its documentation for any purpose and without fee is hereby |
| 10 | granted, provided that the above copyright notice appear in all |
| 11 | copies and that both that the copyright notice and this |
| 12 | permission notice and warranty disclaimer appear in supporting |
| 13 | documentation, and that the name of Lucent or any of its entities |
| 14 | not be used in advertising or publicity pertaining to |
| 15 | distribution of the software without specific, written prior |
| 16 | permission. |
| 17 | |
| 18 | LUCENT DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, |
| 19 | INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. |
| 20 | IN NO EVENT SHALL LUCENT OR ANY OF ITS ENTITIES BE LIABLE FOR ANY |
| 21 | SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES |
| 22 | WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER |
| 23 | IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, |
| 24 | ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF |
| 25 | THIS SOFTWARE. |
| 26 | |
| 27 | ****************************************************************/ |
| 28 | |
| 29 | /* Please send bug reports to David M. Gay (dmg at acm dot org, |
| 30 | * with " at " changed at "@" and " dot " changed to "."). */ |
| 31 | |
| 32 | #include "gdtoaimp.h" |
| 33 | |
| 34 | static Bigint *freelist[Kmax9+1]; |
| 35 | #ifndef Omit_Private_Memory |
| 36 | #ifndef PRIVATE_MEM2304 |
| 37 | #define PRIVATE_MEM2304 2304 |
| 38 | #endif |
| 39 | #define PRIVATE_mem((2304 +sizeof(double)-1)/sizeof(double)) ((PRIVATE_MEM2304+sizeof(double)-1)/sizeof(double)) |
| 40 | static double private_mem[PRIVATE_mem((2304 +sizeof(double)-1)/sizeof(double))], *pmem_next = private_mem; |
| 41 | #endif |
| 42 | |
| 43 | #ifdef MULTIPLE_THREADS1 |
| 44 | static void *__dtoa_locks[] = { NULL((void*)0), NULL((void*)0) }; |
| 45 | #endif |
| 46 | |
| 47 | Bigint * |
| 48 | Balloc__Balloc_D2A |
| 49 | #ifdef KR_headers |
| 50 | (k) int k; |
| 51 | #else |
| 52 | (int k) |
| 53 | #endif |
| 54 | { |
| 55 | int x; |
| 56 | Bigint *rv; |
| 57 | #ifndef Omit_Private_Memory |
| 58 | unsigned int len; |
| 59 | #endif |
| 60 | |
| 61 | ACQUIRE_DTOA_LOCK(0)do { if (__isthreaded) _thread_cb.tc_mutex_lock(&__dtoa_locks [0]); } while (0); |
| 62 | /* The k > Kmax case does not need ACQUIRE_DTOA_LOCK(0), */ |
| 63 | /* but this case seems very unlikely. */ |
| 64 | if (k <= Kmax9 && (rv = freelist[k]) !=0) { |
| 65 | freelist[k] = rv->next; |
| 66 | } |
| 67 | else { |
| 68 | x = 1 << k; |
| 69 | #ifdef Omit_Private_Memory |
| 70 | rv = (Bigint *)MALLOCmalloc(sizeof(Bigint) + (x-1)*sizeof(ULong)); |
| 71 | if (rv == NULL((void*)0)) |
| 72 | return (NULL((void*)0)); |
| 73 | #else |
| 74 | len = (sizeof(Bigint) + (x-1)*sizeof(ULong) + sizeof(double) - 1) |
| 75 | /sizeof(double); |
| 76 | if (k <= Kmax9 && pmem_next - private_mem + len <= PRIVATE_mem((2304 +sizeof(double)-1)/sizeof(double))) { |
| 77 | rv = (Bigint*)pmem_next; |
| 78 | pmem_next += len; |
| 79 | } |
| 80 | else { |
| 81 | rv = (Bigint*)MALLOCmalloc(len*sizeof(double)); |
Result of 'malloc' is converted to a pointer of type 'Bigint', which is incompatible with sizeof operand type 'double' | |
| 82 | if (rv == NULL((void*)0)) |
| 83 | return (NULL((void*)0)); |
| 84 | } |
| 85 | #endif |
| 86 | rv->k = k; |
| 87 | rv->maxwds = x; |
| 88 | } |
| 89 | FREE_DTOA_LOCK(0)do { if (__isthreaded) _thread_cb.tc_mutex_unlock(&__dtoa_locks [0]); } while (0); |
| 90 | rv->sign = rv->wds = 0; |
| 91 | return rv; |
| 92 | } |
| 93 | |
| 94 | void |
| 95 | Bfree__Bfree_D2A |
| 96 | #ifdef KR_headers |
| 97 | (v) Bigint *v; |
| 98 | #else |
| 99 | (Bigint *v) |
| 100 | #endif |
| 101 | { |
| 102 | if (v) { |
| 103 | if (v->k > Kmax9) |
| 104 | #ifdef FREE |
| 105 | FREE(v); |
| 106 | #else |
| 107 | free(v); |
| 108 | #endif |
| 109 | else { |
| 110 | ACQUIRE_DTOA_LOCK(0)do { if (__isthreaded) _thread_cb.tc_mutex_lock(&__dtoa_locks [0]); } while (0); |
| 111 | v->next = freelist[v->k]; |
| 112 | freelist[v->k] = v; |
| 113 | FREE_DTOA_LOCK(0)do { if (__isthreaded) _thread_cb.tc_mutex_unlock(&__dtoa_locks [0]); } while (0); |
| 114 | } |
| 115 | } |
| 116 | } |
| 117 | |
| 118 | int |
| 119 | lo0bits__lo0bits_D2A |
| 120 | #ifdef KR_headers |
| 121 | (y) ULong *y; |
| 122 | #else |
| 123 | (ULong *y) |
| 124 | #endif |
| 125 | { |
| 126 | int k; |
| 127 | ULong x = *y; |
| 128 | |
| 129 | if (x & 7) { |
| 130 | if (x & 1) |
| 131 | return 0; |
| 132 | if (x & 2) { |
| 133 | *y = x >> 1; |
| 134 | return 1; |
| 135 | } |
| 136 | *y = x >> 2; |
| 137 | return 2; |
| 138 | } |
| 139 | k = 0; |
| 140 | if (!(x & 0xffff)) { |
| 141 | k = 16; |
| 142 | x >>= 16; |
| 143 | } |
| 144 | if (!(x & 0xff)) { |
| 145 | k += 8; |
| 146 | x >>= 8; |
| 147 | } |
| 148 | if (!(x & 0xf)) { |
| 149 | k += 4; |
| 150 | x >>= 4; |
| 151 | } |
| 152 | if (!(x & 0x3)) { |
| 153 | k += 2; |
| 154 | x >>= 2; |
| 155 | } |
| 156 | if (!(x & 1)) { |
| 157 | k++; |
| 158 | x >>= 1; |
| 159 | if (!x) |
| 160 | return 32; |
| 161 | } |
| 162 | *y = x; |
| 163 | return k; |
| 164 | } |
| 165 | |
| 166 | Bigint * |
| 167 | multadd__multadd_D2A |
| 168 | #ifdef KR_headers |
| 169 | (b, m, a) Bigint *b; int m, a; |
| 170 | #else |
| 171 | (Bigint *b, int m, int a) /* multiply by m and add a */ |
| 172 | #endif |
| 173 | { |
| 174 | int i, wds; |
| 175 | #ifdef ULLongunsigned long long |
| 176 | ULong *x; |
| 177 | ULLongunsigned long long carry, y; |
| 178 | #else |
| 179 | ULong carry, *x, y; |
| 180 | #ifdef Pack_32 |
| 181 | ULong xi, z; |
| 182 | #endif |
| 183 | #endif |
| 184 | Bigint *b1; |
| 185 | |
| 186 | wds = b->wds; |
| 187 | x = b->x; |
| 188 | i = 0; |
| 189 | carry = a; |
| 190 | do { |
| 191 | #ifdef ULLongunsigned long long |
| 192 | y = *x * (ULLongunsigned long long)m + carry; |
| 193 | carry = y >> 32; |
| 194 | *x++ = y & 0xffffffffUL; |
| 195 | #else |
| 196 | #ifdef Pack_32 |
| 197 | xi = *x; |
| 198 | y = (xi & 0xffff) * m + carry; |
| 199 | z = (xi >> 16) * m + (y >> 16); |
| 200 | carry = z >> 16; |
| 201 | *x++ = (z << 16) + (y & 0xffff); |
| 202 | #else |
| 203 | y = *x * m + carry; |
| 204 | carry = y >> 16; |
| 205 | *x++ = y & 0xffff; |
| 206 | #endif |
| 207 | #endif |
| 208 | } |
| 209 | while(++i < wds); |
| 210 | if (carry) { |
| 211 | if (wds >= b->maxwds) { |
| 212 | b1 = Balloc__Balloc_D2A(b->k+1); |
| 213 | if (b1 == NULL((void*)0)) |
| 214 | return (NULL((void*)0)); |
| 215 | Bcopy(b1, b)memcpy(&b1->sign,&b->sign,b->wds*sizeof(ULong ) + 2*sizeof(int)); |
| 216 | Bfree__Bfree_D2A(b); |
| 217 | b = b1; |
| 218 | } |
| 219 | b->x[wds++] = carry; |
| 220 | b->wds = wds; |
| 221 | } |
| 222 | return b; |
| 223 | } |
| 224 | |
| 225 | int |
| 226 | hi0bits_D2A__hi0bits_D2A |
| 227 | #ifdef KR_headers |
| 228 | (x) ULong x; |
| 229 | #else |
| 230 | (ULong x) |
| 231 | #endif |
| 232 | { |
| 233 | int k = 0; |
| 234 | |
| 235 | if (!(x & 0xffff0000)) { |
| 236 | k = 16; |
| 237 | x <<= 16; |
| 238 | } |
| 239 | if (!(x & 0xff000000)) { |
| 240 | k += 8; |
| 241 | x <<= 8; |
| 242 | } |
| 243 | if (!(x & 0xf0000000)) { |
| 244 | k += 4; |
| 245 | x <<= 4; |
| 246 | } |
| 247 | if (!(x & 0xc0000000)) { |
| 248 | k += 2; |
| 249 | x <<= 2; |
| 250 | } |
| 251 | if (!(x & 0x80000000)) { |
| 252 | k++; |
| 253 | if (!(x & 0x40000000)) |
| 254 | return 32; |
| 255 | } |
| 256 | return k; |
| 257 | } |
| 258 | |
| 259 | Bigint * |
| 260 | i2b__i2b_D2A |
| 261 | #ifdef KR_headers |
| 262 | (i) int i; |
| 263 | #else |
| 264 | (int i) |
| 265 | #endif |
| 266 | { |
| 267 | Bigint *b; |
| 268 | |
| 269 | b = Balloc__Balloc_D2A(1); |
| 270 | if (b == NULL((void*)0)) |
| 271 | return (NULL((void*)0)); |
| 272 | b->x[0] = i; |
| 273 | b->wds = 1; |
| 274 | return b; |
| 275 | } |
| 276 | |
| 277 | Bigint * |
| 278 | mult__mult_D2A |
| 279 | #ifdef KR_headers |
| 280 | (a, b) Bigint *a, *b; |
| 281 | #else |
| 282 | (Bigint *a, Bigint *b) |
| 283 | #endif |
| 284 | { |
| 285 | Bigint *c; |
| 286 | int k, wa, wb, wc; |
| 287 | ULong *x, *xa, *xae, *xb, *xbe, *xc, *xc0; |
| 288 | ULong y; |
| 289 | #ifdef ULLongunsigned long long |
| 290 | ULLongunsigned long long carry, z; |
| 291 | #else |
| 292 | ULong carry, z; |
| 293 | #ifdef Pack_32 |
| 294 | ULong z2; |
| 295 | #endif |
| 296 | #endif |
| 297 | |
| 298 | if (a->wds < b->wds) { |
| 299 | c = a; |
| 300 | a = b; |
| 301 | b = c; |
| 302 | } |
| 303 | k = a->k; |
| 304 | wa = a->wds; |
| 305 | wb = b->wds; |
| 306 | wc = wa + wb; |
| 307 | if (wc > a->maxwds) |
| 308 | k++; |
| 309 | c = Balloc__Balloc_D2A(k); |
| 310 | if (c == NULL((void*)0)) |
| 311 | return (NULL((void*)0)); |
| 312 | for(x = c->x, xa = x + wc; x < xa; x++) |
| 313 | *x = 0; |
| 314 | xa = a->x; |
| 315 | xae = xa + wa; |
| 316 | xb = b->x; |
| 317 | xbe = xb + wb; |
| 318 | xc0 = c->x; |
| 319 | #ifdef ULLongunsigned long long |
| 320 | for(; xb < xbe; xc0++) { |
| 321 | if ( (y = *xb++) !=0) { |
| 322 | x = xa; |
| 323 | xc = xc0; |
| 324 | carry = 0; |
| 325 | do { |
| 326 | z = *x++ * (ULLongunsigned long long)y + *xc + carry; |
| 327 | carry = z >> 32; |
| 328 | *xc++ = z & 0xffffffffUL; |
| 329 | } |
| 330 | while(x < xae); |
| 331 | *xc = carry; |
| 332 | } |
| 333 | } |
| 334 | #else |
| 335 | #ifdef Pack_32 |
| 336 | for(; xb < xbe; xb++, xc0++) { |
| 337 | if ( (y = *xb & 0xffff) !=0) { |
| 338 | x = xa; |
| 339 | xc = xc0; |
| 340 | carry = 0; |
| 341 | do { |
| 342 | z = (*x & 0xffff) * y + (*xc & 0xffff) + carry; |
| 343 | carry = z >> 16; |
| 344 | z2 = (*x++ >> 16) * y + (*xc >> 16) + carry; |
| 345 | carry = z2 >> 16; |
| 346 | Storeinc(xc, z2, z)(((unsigned short *)xc)[1] = (unsigned short)z2, ((unsigned short *)xc)[0] = (unsigned short)z, xc++); |
| 347 | } |
| 348 | while(x < xae); |
| 349 | *xc = carry; |
| 350 | } |
| 351 | if ( (y = *xb >> 16) !=0) { |
| 352 | x = xa; |
| 353 | xc = xc0; |
| 354 | carry = 0; |
| 355 | z2 = *xc; |
| 356 | do { |
| 357 | z = (*x & 0xffff) * y + (*xc >> 16) + carry; |
| 358 | carry = z >> 16; |
| 359 | Storeinc(xc, z, z2)(((unsigned short *)xc)[1] = (unsigned short)z, ((unsigned short *)xc)[0] = (unsigned short)z2, xc++); |
| 360 | z2 = (*x++ >> 16) * y + (*xc & 0xffff) + carry; |
| 361 | carry = z2 >> 16; |
| 362 | } |
| 363 | while(x < xae); |
| 364 | *xc = z2; |
| 365 | } |
| 366 | } |
| 367 | #else |
| 368 | for(; xb < xbe; xc0++) { |
| 369 | if ( (y = *xb++) !=0) { |
| 370 | x = xa; |
| 371 | xc = xc0; |
| 372 | carry = 0; |
| 373 | do { |
| 374 | z = *x++ * y + *xc + carry; |
| 375 | carry = z >> 16; |
| 376 | *xc++ = z & 0xffff; |
| 377 | } |
| 378 | while(x < xae); |
| 379 | *xc = carry; |
| 380 | } |
| 381 | } |
| 382 | #endif |
| 383 | #endif |
| 384 | for(xc0 = c->x, xc = xc0 + wc; wc > 0 && !*--xc; --wc) ; |
| 385 | c->wds = wc; |
| 386 | return c; |
| 387 | } |
| 388 | |
| 389 | static Bigint *p5s; |
| 390 | |
| 391 | Bigint * |
| 392 | pow5mult__pow5mult_D2A |
| 393 | #ifdef KR_headers |
| 394 | (b, k) Bigint *b; int k; |
| 395 | #else |
| 396 | (Bigint *b, int k) |
| 397 | #endif |
| 398 | { |
| 399 | Bigint *b1, *p5, *p51; |
| 400 | int i; |
| 401 | static int p05[3] = { 5, 25, 125 }; |
| 402 | |
| 403 | if ( (i = k & 3) !=0) { |
| 404 | b = multadd__multadd_D2A(b, p05[i-1], 0); |
| 405 | if (b == NULL((void*)0)) |
| 406 | return (NULL((void*)0)); |
| 407 | } |
| 408 | |
| 409 | if (!(k >>= 2)) |
| 410 | return b; |
| 411 | if ((p5 = p5s) == 0) { |
| 412 | /* first time */ |
| 413 | #ifdef MULTIPLE_THREADS1 |
| 414 | ACQUIRE_DTOA_LOCK(1)do { if (__isthreaded) _thread_cb.tc_mutex_lock(&__dtoa_locks [1]); } while (0); |
| 415 | if (!(p5 = p5s)) { |
| 416 | p5 = p5s = i2b__i2b_D2A(625); |
| 417 | if (p5 == NULL((void*)0)) |
| 418 | return (NULL((void*)0)); |
| 419 | p5->next = 0; |
| 420 | } |
| 421 | FREE_DTOA_LOCK(1)do { if (__isthreaded) _thread_cb.tc_mutex_unlock(&__dtoa_locks [1]); } while (0); |
| 422 | #else |
| 423 | p5 = p5s = i2b__i2b_D2A(625); |
| 424 | if (p5 == NULL((void*)0)) |
| 425 | return (NULL((void*)0)); |
| 426 | p5->next = 0; |
| 427 | #endif |
| 428 | } |
| 429 | for(;;) { |
| 430 | if (k & 1) { |
| 431 | b1 = mult__mult_D2A(b, p5); |
| 432 | if (b1 == NULL((void*)0)) |
| 433 | return (NULL((void*)0)); |
| 434 | Bfree__Bfree_D2A(b); |
| 435 | b = b1; |
| 436 | } |
| 437 | if (!(k >>= 1)) |
| 438 | break; |
| 439 | if ((p51 = p5->next) == 0) { |
| 440 | #ifdef MULTIPLE_THREADS1 |
| 441 | ACQUIRE_DTOA_LOCK(1)do { if (__isthreaded) _thread_cb.tc_mutex_lock(&__dtoa_locks [1]); } while (0); |
| 442 | if (!(p51 = p5->next)) { |
| 443 | p51 = p5->next = mult__mult_D2A(p5,p5); |
| 444 | if (p51 == NULL((void*)0)) |
| 445 | return (NULL((void*)0)); |
| 446 | p51->next = 0; |
| 447 | } |
| 448 | FREE_DTOA_LOCK(1)do { if (__isthreaded) _thread_cb.tc_mutex_unlock(&__dtoa_locks [1]); } while (0); |
| 449 | #else |
| 450 | p51 = p5->next = mult__mult_D2A(p5,p5); |
| 451 | if (p51 == NULL((void*)0)) |
| 452 | return (NULL((void*)0)); |
| 453 | p51->next = 0; |
| 454 | #endif |
| 455 | } |
| 456 | p5 = p51; |
| 457 | } |
| 458 | return b; |
| 459 | } |
| 460 | |
| 461 | Bigint * |
| 462 | lshift__lshift_D2A |
| 463 | #ifdef KR_headers |
| 464 | (b, k) Bigint *b; int k; |
| 465 | #else |
| 466 | (Bigint *b, int k) |
| 467 | #endif |
| 468 | { |
| 469 | int i, k1, n, n1; |
| 470 | Bigint *b1; |
| 471 | ULong *x, *x1, *xe, z; |
| 472 | |
| 473 | n = k >> kshift5; |
| 474 | k1 = b->k; |
| 475 | n1 = n + b->wds + 1; |
| 476 | for(i = b->maxwds; n1 > i; i <<= 1) |
| 477 | k1++; |
| 478 | b1 = Balloc__Balloc_D2A(k1); |
| 479 | if (b1 == NULL((void*)0)) |
| 480 | return (NULL((void*)0)); |
| 481 | x1 = b1->x; |
| 482 | for(i = 0; i < n; i++) |
| 483 | *x1++ = 0; |
| 484 | x = b->x; |
| 485 | xe = x + b->wds; |
| 486 | if (k &= kmask31) { |
| 487 | #ifdef Pack_32 |
| 488 | k1 = 32 - k; |
| 489 | z = 0; |
| 490 | do { |
| 491 | *x1++ = *x << k | z; |
| 492 | z = *x++ >> k1; |
| 493 | } |
| 494 | while(x < xe); |
| 495 | if ((*x1 = z) !=0) |
| 496 | ++n1; |
| 497 | #else |
| 498 | k1 = 16 - k; |
| 499 | z = 0; |
| 500 | do { |
| 501 | *x1++ = *x << k & 0xffff | z; |
| 502 | z = *x++ >> k1; |
| 503 | } |
| 504 | while(x < xe); |
| 505 | if (*x1 = z) |
| 506 | ++n1; |
| 507 | #endif |
| 508 | } |
| 509 | else do |
| 510 | *x1++ = *x++; |
| 511 | while(x < xe); |
| 512 | b1->wds = n1 - 1; |
| 513 | Bfree__Bfree_D2A(b); |
| 514 | return b1; |
| 515 | } |
| 516 | |
| 517 | int |
| 518 | cmp__cmp_D2A |
| 519 | #ifdef KR_headers |
| 520 | (a, b) Bigint *a, *b; |
| 521 | #else |
| 522 | (Bigint *a, Bigint *b) |
| 523 | #endif |
| 524 | { |
| 525 | ULong *xa, *xa0, *xb, *xb0; |
| 526 | int i, j; |
| 527 | |
| 528 | i = a->wds; |
| 529 | j = b->wds; |
| 530 | #ifdef DEBUG |
| 531 | if (i > 1 && !a->x[i-1]) |
| 532 | Bug("cmp called with a->x[a->wds-1] == 0"); |
| 533 | if (j > 1 && !b->x[j-1]) |
| 534 | Bug("cmp called with b->x[b->wds-1] == 0"); |
| 535 | #endif |
| 536 | if (i -= j) |
| 537 | return i; |
| 538 | xa0 = a->x; |
| 539 | xa = xa0 + j; |
| 540 | xb0 = b->x; |
| 541 | xb = xb0 + j; |
| 542 | for(;;) { |
| 543 | if (*--xa != *--xb) |
| 544 | return *xa < *xb ? -1 : 1; |
| 545 | if (xa <= xa0) |
| 546 | break; |
| 547 | } |
| 548 | return 0; |
| 549 | } |
| 550 | |
| 551 | Bigint * |
| 552 | diff__diff_D2A |
| 553 | #ifdef KR_headers |
| 554 | (a, b) Bigint *a, *b; |
| 555 | #else |
| 556 | (Bigint *a, Bigint *b) |
| 557 | #endif |
| 558 | { |
| 559 | Bigint *c; |
| 560 | int i, wa, wb; |
| 561 | ULong *xa, *xae, *xb, *xbe, *xc; |
| 562 | #ifdef ULLongunsigned long long |
| 563 | ULLongunsigned long long borrow, y; |
| 564 | #else |
| 565 | ULong borrow, y; |
| 566 | #ifdef Pack_32 |
| 567 | ULong z; |
| 568 | #endif |
| 569 | #endif |
| 570 | |
| 571 | i = cmp__cmp_D2A(a,b); |
| 572 | if (!i) { |
| 573 | c = Balloc__Balloc_D2A(0); |
| 574 | if (c == NULL((void*)0)) |
| 575 | return (NULL((void*)0)); |
| 576 | c->wds = 1; |
| 577 | c->x[0] = 0; |
| 578 | return c; |
| 579 | } |
| 580 | if (i < 0) { |
| 581 | c = a; |
| 582 | a = b; |
| 583 | b = c; |
| 584 | i = 1; |
| 585 | } |
| 586 | else |
| 587 | i = 0; |
| 588 | c = Balloc__Balloc_D2A(a->k); |
| 589 | if (c == NULL((void*)0)) |
| 590 | return (NULL((void*)0)); |
| 591 | c->sign = i; |
| 592 | wa = a->wds; |
| 593 | xa = a->x; |
| 594 | xae = xa + wa; |
| 595 | wb = b->wds; |
| 596 | xb = b->x; |
| 597 | xbe = xb + wb; |
| 598 | xc = c->x; |
| 599 | borrow = 0; |
| 600 | #ifdef ULLongunsigned long long |
| 601 | do { |
| 602 | y = (ULLongunsigned long long)*xa++ - *xb++ - borrow; |
| 603 | borrow = y >> 32 & 1UL; |
| 604 | *xc++ = y & 0xffffffffUL; |
| 605 | } |
| 606 | while(xb < xbe); |
| 607 | while(xa < xae) { |
| 608 | y = *xa++ - borrow; |
| 609 | borrow = y >> 32 & 1UL; |
| 610 | *xc++ = y & 0xffffffffUL; |
| 611 | } |
| 612 | #else |
| 613 | #ifdef Pack_32 |
| 614 | do { |
| 615 | y = (*xa & 0xffff) - (*xb & 0xffff) - borrow; |
| 616 | borrow = (y & 0x10000) >> 16; |
| 617 | z = (*xa++ >> 16) - (*xb++ >> 16) - borrow; |
| 618 | borrow = (z & 0x10000) >> 16; |
| 619 | Storeinc(xc, z, y)(((unsigned short *)xc)[1] = (unsigned short)z, ((unsigned short *)xc)[0] = (unsigned short)y, xc++); |
| 620 | } |
| 621 | while(xb < xbe); |
| 622 | while(xa < xae) { |
| 623 | y = (*xa & 0xffff) - borrow; |
| 624 | borrow = (y & 0x10000) >> 16; |
| 625 | z = (*xa++ >> 16) - borrow; |
| 626 | borrow = (z & 0x10000) >> 16; |
| 627 | Storeinc(xc, z, y)(((unsigned short *)xc)[1] = (unsigned short)z, ((unsigned short *)xc)[0] = (unsigned short)y, xc++); |
| 628 | } |
| 629 | #else |
| 630 | do { |
| 631 | y = *xa++ - *xb++ - borrow; |
| 632 | borrow = (y & 0x10000) >> 16; |
| 633 | *xc++ = y & 0xffff; |
| 634 | } |
| 635 | while(xb < xbe); |
| 636 | while(xa < xae) { |
| 637 | y = *xa++ - borrow; |
| 638 | borrow = (y & 0x10000) >> 16; |
| 639 | *xc++ = y & 0xffff; |
| 640 | } |
| 641 | #endif |
| 642 | #endif |
| 643 | while(!*--xc) |
| 644 | wa--; |
| 645 | c->wds = wa; |
| 646 | return c; |
| 647 | } |
| 648 | |
| 649 | double |
| 650 | b2d__b2d_D2A |
| 651 | #ifdef KR_headers |
| 652 | (a, e) Bigint *a; int *e; |
| 653 | #else |
| 654 | (Bigint *a, int *e) |
| 655 | #endif |
| 656 | { |
| 657 | ULong *xa, *xa0, w, y, z; |
| 658 | int k; |
| 659 | U d; |
| 660 | #ifdef VAX |
| 661 | ULong d0, d1; |
| 662 | #else |
| 663 | #define d0 word0(&d)(&d)->L[1] |
| 664 | #define d1 word1(&d)(&d)->L[0] |
| 665 | #endif |
| 666 | |
| 667 | xa0 = a->x; |
| 668 | xa = xa0 + a->wds; |
| 669 | y = *--xa; |
| 670 | #ifdef DEBUG |
| 671 | if (!y) Bug("zero y in b2d"); |
| 672 | #endif |
| 673 | k = hi0bits(y)__hi0bits_D2A((ULong)(y)); |
| 674 | *e = 32 - k; |
| 675 | #ifdef Pack_32 |
| 676 | if (k < Ebits11) { |
| 677 | d0 = Exp_10x3ff00000 | y >> (Ebits11 - k); |
| 678 | w = xa > xa0 ? *--xa : 0; |
| 679 | d1 = y << ((32-Ebits11) + k) | w >> (Ebits11 - k); |
| 680 | goto ret_d; |
| 681 | } |
| 682 | z = xa > xa0 ? *--xa : 0; |
| 683 | if (k -= Ebits11) { |
| 684 | d0 = Exp_10x3ff00000 | y << k | z >> (32 - k); |
| 685 | y = xa > xa0 ? *--xa : 0; |
| 686 | d1 = z << k | y >> (32 - k); |
| 687 | } |
| 688 | else { |
| 689 | d0 = Exp_10x3ff00000 | y; |
| 690 | d1 = z; |
| 691 | } |
| 692 | #else |
| 693 | if (k < Ebits11 + 16) { |
| 694 | z = xa > xa0 ? *--xa : 0; |
| 695 | d0 = Exp_10x3ff00000 | y << k - Ebits11 | z >> Ebits11 + 16 - k; |
| 696 | w = xa > xa0 ? *--xa : 0; |
| 697 | y = xa > xa0 ? *--xa : 0; |
| 698 | d1 = z << k + 16 - Ebits11 | w << k - Ebits11 | y >> 16 + Ebits11 - k; |
| 699 | goto ret_d; |
| 700 | } |
| 701 | z = xa > xa0 ? *--xa : 0; |
| 702 | w = xa > xa0 ? *--xa : 0; |
| 703 | k -= Ebits11 + 16; |
| 704 | d0 = Exp_10x3ff00000 | y << k + 16 | z << k | w >> 16 - k; |
| 705 | y = xa > xa0 ? *--xa : 0; |
| 706 | d1 = w << k + 16 | y << k; |
| 707 | #endif |
| 708 | ret_d: |
| 709 | #ifdef VAX |
| 710 | word0(&d)(&d)->L[1] = d0 >> 16 | d0 << 16; |
| 711 | word1(&d)(&d)->L[0] = d1 >> 16 | d1 << 16; |
| 712 | #endif |
| 713 | return dval(&d)(&d)->d; |
| 714 | } |
| 715 | #undef d0 |
| 716 | #undef d1 |
| 717 | |
| 718 | Bigint * |
| 719 | d2b__d2b_D2A |
| 720 | #ifdef KR_headers |
| 721 | (dd, e, bits) double dd; int *e, *bits; |
| 722 | #else |
| 723 | (double dd, int *e, int *bits) |
| 724 | #endif |
| 725 | { |
| 726 | Bigint *b; |
| 727 | U d; |
| 728 | #ifndef Sudden_Underflow |
| 729 | int i; |
| 730 | #endif |
| 731 | int de, k; |
| 732 | ULong *x, y, z; |
| 733 | #ifdef VAX |
| 734 | ULong d0, d1; |
| 735 | #else |
| 736 | #define d0 word0(&d)(&d)->L[1] |
| 737 | #define d1 word1(&d)(&d)->L[0] |
| 738 | #endif |
| 739 | d.d = dd; |
| 740 | #ifdef VAX |
| 741 | d0 = word0(&d)(&d)->L[1] >> 16 | word0(&d)(&d)->L[1] << 16; |
| 742 | d1 = word1(&d)(&d)->L[0] >> 16 | word1(&d)(&d)->L[0] << 16; |
| 743 | #endif |
| 744 | |
| 745 | #ifdef Pack_32 |
| 746 | b = Balloc__Balloc_D2A(1); |
| 747 | #else |
| 748 | b = Balloc__Balloc_D2A(2); |
| 749 | #endif |
| 750 | if (b == NULL((void*)0)) |
| 751 | return (NULL((void*)0)); |
| 752 | x = b->x; |
| 753 | |
| 754 | z = d0 & Frac_mask0xfffff; |
| 755 | d0 &= 0x7fffffff; /* clear sign bit, which we ignore */ |
| 756 | #ifdef Sudden_Underflow |
| 757 | de = (int)(d0 >> Exp_shift20); |
| 758 | #ifndef IBM |
| 759 | z |= Exp_msk110x100000; |
| 760 | #endif |
| 761 | #else |
| 762 | if ( (de = (int)(d0 >> Exp_shift20)) !=0) |
| 763 | z |= Exp_msk10x100000; |
| 764 | #endif |
| 765 | #ifdef Pack_32 |
| 766 | if ( (y = d1) !=0) { |
| 767 | if ( (k = lo0bits__lo0bits_D2A(&y)) !=0) { |
| 768 | x[0] = y | z << (32 - k); |
| 769 | z >>= k; |
| 770 | } |
| 771 | else |
| 772 | x[0] = y; |
| 773 | #ifndef Sudden_Underflow |
| 774 | i = |
| 775 | #endif |
| 776 | b->wds = (x[1] = z) !=0 ? 2 : 1; |
| 777 | } |
| 778 | else { |
| 779 | k = lo0bits__lo0bits_D2A(&z); |
| 780 | x[0] = z; |
| 781 | #ifndef Sudden_Underflow |
| 782 | i = |
| 783 | #endif |
| 784 | b->wds = 1; |
| 785 | k += 32; |
| 786 | } |
| 787 | #else |
| 788 | if ( (y = d1) !=0) { |
| 789 | if ( (k = lo0bits__lo0bits_D2A(&y)) !=0) |
| 790 | if (k >= 16) { |
| 791 | x[0] = y | z << 32 - k & 0xffff; |
| 792 | x[1] = z >> k - 16 & 0xffff; |
| 793 | x[2] = z >> k; |
| 794 | i = 2; |
| 795 | } |
| 796 | else { |
| 797 | x[0] = y & 0xffff; |
| 798 | x[1] = y >> 16 | z << 16 - k & 0xffff; |
| 799 | x[2] = z >> k & 0xffff; |
| 800 | x[3] = z >> k+16; |
| 801 | i = 3; |
| 802 | } |
| 803 | else { |
| 804 | x[0] = y & 0xffff; |
| 805 | x[1] = y >> 16; |
| 806 | x[2] = z & 0xffff; |
| 807 | x[3] = z >> 16; |
| 808 | i = 3; |
| 809 | } |
| 810 | } |
| 811 | else { |
| 812 | #ifdef DEBUG |
| 813 | if (!z) |
| 814 | Bug("Zero passed to d2b"); |
| 815 | #endif |
| 816 | k = lo0bits__lo0bits_D2A(&z); |
| 817 | if (k >= 16) { |
| 818 | x[0] = z; |
| 819 | i = 0; |
| 820 | } |
| 821 | else { |
| 822 | x[0] = z & 0xffff; |
| 823 | x[1] = z >> 16; |
| 824 | i = 1; |
| 825 | } |
| 826 | k += 32; |
| 827 | } |
| 828 | while(!x[i]) |
| 829 | --i; |
| 830 | b->wds = i + 1; |
| 831 | #endif |
| 832 | #ifndef Sudden_Underflow |
| 833 | if (de) { |
| 834 | #endif |
| 835 | #ifdef IBM |
| 836 | *e = (de - Bias1023 - (P53-1) << 2) + k; |
| 837 | *bits = 4*P53 + 8 - k - hi0bits(word0(&d) & Frac_mask)__hi0bits_D2A((ULong)((&d)->L[1] & 0xfffff)); |
| 838 | #else |
| 839 | *e = de - Bias1023 - (P53-1) + k; |
| 840 | *bits = P53 - k; |
| 841 | #endif |
| 842 | #ifndef Sudden_Underflow |
| 843 | } |
| 844 | else { |
| 845 | *e = de - Bias1023 - (P53-1) + 1 + k; |
| 846 | #ifdef Pack_32 |
| 847 | *bits = 32*i - hi0bits(x[i-1])__hi0bits_D2A((ULong)(x[i-1])); |
| 848 | #else |
| 849 | *bits = (i+2)*16 - hi0bits(x[i])__hi0bits_D2A((ULong)(x[i])); |
| 850 | #endif |
| 851 | } |
| 852 | #endif |
| 853 | return b; |
| 854 | } |
| 855 | #undef d0 |
| 856 | #undef d1 |
| 857 | |
| 858 | CONSTconst double |
| 859 | #ifdef IEEE_Arith |
| 860 | bigtens__bigtens_D2A[] = { 1e16, 1e32, 1e64, 1e128, 1e256 }; |
| 861 | CONSTconst double tinytens__tinytens_D2A[] = { 1e-16, 1e-32, 1e-64, 1e-128, 1e-256 |
| 862 | }; |
| 863 | #else |
| 864 | #ifdef IBM |
| 865 | bigtens__bigtens_D2A[] = { 1e16, 1e32, 1e64 }; |
| 866 | CONSTconst double tinytens__tinytens_D2A[] = { 1e-16, 1e-32, 1e-64 }; |
| 867 | #else |
| 868 | bigtens__bigtens_D2A[] = { 1e16, 1e32 }; |
| 869 | CONSTconst double tinytens__tinytens_D2A[] = { 1e-16, 1e-32 }; |
| 870 | #endif |
| 871 | #endif |
| 872 | |
| 873 | CONSTconst double |
| 874 | tens__tens_D2A[] = { |
| 875 | 1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, |
| 876 | 1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19, |
| 877 | 1e20, 1e21, 1e22 |
| 878 | #ifdef VAX |
| 879 | , 1e23, 1e24 |
| 880 | #endif |
| 881 | }; |
| 882 | |
| 883 | #ifdef NO_STRING_H |
| 884 | |
| 885 | char * |
| 886 | #ifdef KR_headers |
| 887 | strcp_D2A(a, b) char *a; char *b; |
| 888 | #else |
| 889 | strcp_D2A(char *a, CONSTconst char *b) |
| 890 | #endif |
| 891 | { |
| 892 | while((*a = *b++)) |
| 893 | a++; |
| 894 | return a; |
| 895 | } |
| 896 | |
| 897 | Charvoid * |
| 898 | #ifdef KR_headers |
| 899 | memcpy_D2A(a, b, len) Charvoid *a; Charvoid *b; size_t len; |
| 900 | #else |
| 901 | memcpy_D2A(void *a1, void *b1, size_t len) |
| 902 | #endif |
| 903 | { |
| 904 | char *a = (char*)a1, *ae = a + len; |
| 905 | char *b = (char*)b1, *a0 = a; |
| 906 | while(a < ae) |
| 907 | *a++ = *b++; |
| 908 | return a0; |
| 909 | } |
| 910 | |
| 911 | #endif /* NO_STRING_H */ |