1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License, Version 1.0 only 6 * (the "License"). You may not use this file except in compliance 7 * with the License. 8 * 9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 10 * or http://www.opensolaris.org/os/licensing. 11 * See the License for the specific language governing permissions 12 * and limitations under the License. 13 * 14 * When distributing Covered Code, include this CDDL HEADER in each 15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 16 * If applicable, add the following below this CDDL HEADER, with the 17 * fields enclosed by brackets "[]" replaced with your own identifying 18 * information: Portions Copyright [yyyy] [name of copyright owner] 19 * 20 * CDDL HEADER END 21 */ 22 /* 23 * Copyright (c) 1988-1995, by Sun Microsystems, Inc. 24 * All rights reserved. 25 */ 26 27 #pragma ident "%Z%%M% %I% %E% SMI" 28 29 /* Conversion between binary and decimal floating point. */ 30 31 #include "base_conversion.h" 32 33 void 34 decimal_to_binary_integer(ds, ndigs, nzeros, nsig, pb) 35 char ds[]; /* Input decimal integer string. */ 36 unsigned ndigs; /* Input number of explicit digits in ds. */ 37 unsigned nzeros; /* Input number of implicit trailing zeros. */ 38 unsigned nsig; /* Input number of significant bits required. */ 39 _big_float *pb; /* Pointer to big_float to receive result. */ 40 41 /* 42 * Converts a decimal integer string ds with ndigs explicit leading digits 43 * and nzeros implicit trailing zeros to a _big_float **pb, which only 44 * requires nsig significand bits. 45 */ 46 /* Inexactness is indicated by pb->bsignificand[0] |= 1. */ 47 /* 48 * If the input is too big for a big_float, pb->bexponent is set to 0x7fff. 49 */ 50 51 { 52 unsigned nzout; 53 _big_float d, *pbout; 54 55 d.bsize = _BIG_FLOAT_SIZE; 56 _integerstring_to_big_decimal(ds, ndigs, nzeros, &nzout, &d); 57 _big_decimal_to_big_binary(&d, pb); 58 if (nzout != 0) { 59 _big_float_times_power(pb, 10, (int) nzout, (int) nsig, &pbout); 60 switch ((unsigned int)pbout) { 61 case ((unsigned int)BIG_FLOAT_TIMES_TOOBIG): 62 #ifdef DEBUG 63 (void) printf(" decimal_to_binary_integer: decimal exponent %d too large for tables ", nzout); 64 #endif 65 pb->bexponent = 0x7fff; 66 break; 67 case ((unsigned int)BIG_FLOAT_TIMES_NOMEM): 68 { 69 char bcastring[80]; 70 71 (void) sprintf(bcastring, " decimal exponent %d ", nzout); 72 _base_conversion_abort(ENOMEM, bcastring); 73 break; 74 } 75 default: 76 #ifdef DEBUG 77 if (pbout != pb) 78 (void) printf(" decimal_to_binary_integer: large decimal exponent %d needs heap buffer \n", nzout); 79 printf(" decimal_to_binary_integer: product "); 80 _display_big_float(pb, 2); 81 #endif 82 if (pbout != pb) { /* We don't really need such 83 * a large product; the 84 * target can't be more than 85 * a quad! */ 86 int i, allweneed; 87 88 allweneed = 2 + (nsig + 2) / 16; 89 for (i = 0; i < allweneed; i++) 90 pb->bsignificand[i] = pbout->bsignificand[i + pbout->blength - allweneed]; 91 for (i = 0; (pbout->bsignificand[i] == 0); i++); 92 if (i < (pbout->blength - allweneed)) 93 pb->bsignificand[0] |= 1; /* Stick discarded bits. */ 94 95 pb->blength = allweneed; 96 pb->bexponent = pbout->bexponent + 16 * (pbout->blength - allweneed); 97 #ifdef DEBUG 98 printf(" decimal_to_binary_integer: removed %d excess digits from product \n", pbout->blength - allweneed); 99 _display_big_float(pb, 2); 100 #endif 101 _free_big_float(pbout); 102 } 103 break; 104 } 105 } 106 } 107 108 void 109 decimal_to_binary_fraction(ds, ndigs, nzeros, nsig, pb) 110 char ds[]; /* Decimal integer string input. */ 111 unsigned ndigs; /* Number of explicit digits to read. */ 112 unsigned nzeros; /* Number of implicit leading zeros before 113 * digits. */ 114 unsigned nsig; /* Number of significant bits needed. */ 115 _big_float *pb; /* Pointer to intended big_float result. */ 116 117 /* 118 * Converts an explicit decimal string *ds[0]..*ds[ndigs-1] preceded by 119 * nzeros implicit leading zeros after the point into a big_float at *pb. If 120 * the input does not fit exactly in a big_float, the least significant bit 121 * of pbout->significand is stuck on. If the input is too big for the base 122 * conversion tables, pb->bexponent is set to 0x7fff. 123 */ 124 125 { 126 unsigned twopower, twosig; 127 int i, excess; 128 _big_float d, *pdout; 129 130 d.bsize = _BIG_FLOAT_SIZE; 131 _fractionstring_to_big_decimal(ds, ndigs, nzeros, &d); 132 133 twopower = nsig + 3 + (((nzeros + 1) * (unsigned long) 217706) >> 16); 134 twosig = 1 + (((nsig + 2) * (unsigned long) 19729) >> 16); 135 136 #ifdef DEBUG 137 printf(" decimal_to_binary_fraction sigbits %d twopower %d twosig %d \n", 138 nsig, twopower, twosig); 139 #endif 140 _big_float_times_power(&d, 2, (int) twopower, (int) twosig, &pdout); 141 switch ((unsigned int)pdout) { 142 case ((unsigned int)BIG_FLOAT_TIMES_TOOBIG): 143 #ifdef DEBUG 144 (void) printf(" decimal_to_binary_fraction binary exponent %d too large for tables ", twopower); 145 #endif 146 pb->bexponent = 0x7fff; 147 goto ret; 148 case ((unsigned int)BIG_FLOAT_TIMES_NOMEM): 149 { 150 char bcastring[80]; 151 152 (void) sprintf(bcastring, " binary exponent %d ", twopower); 153 _base_conversion_abort(ENOMEM, bcastring); 154 break; 155 } 156 default: 157 #ifdef DEBUG 158 if (&d != pdout) 159 printf(" decimal_to_binary_fraction large binary exponent %d needs heap buffer \n", twopower); 160 printf(" product "); 161 _display_big_float(pdout, 10); 162 #endif 163 break; 164 } 165 166 167 if (pdout->bexponent <= -4) { 168 /* Have computed appropriate decimal part; now toss fraction. */ 169 excess = (-pdout->bexponent) / 4; 170 #ifdef DEBUG 171 printf(" discard %d excess fraction digits \n", 4 * excess); 172 #endif 173 for (i = 0; (i < excess) && ((pdout)->bsignificand[i] == 0); i++); 174 if (i < excess) 175 (pdout)->bsignificand[excess] |= 1; /* Sticky bit for 176 * discarded fraction. */ 177 for (i = excess; i < (pdout)->blength; i++) 178 (pdout)->bsignificand[i - excess] = (pdout)->bsignificand[i]; 179 180 (pdout)->blength -= excess; 181 (pdout)->bexponent += 4 * excess; 182 } 183 _big_decimal_to_big_binary(pdout, pb); 184 if (pdout != &d) 185 _free_big_float(pdout); 186 pb->bexponent = -twopower; 187 188 ret: 189 return; 190 } 191 192 void 193 decimal_to_unpacked(px, pd, significant_bits) 194 unpacked *px; 195 decimal_record *pd; 196 unsigned significant_bits; 197 198 /* 199 * Converts *pd to *px so that *px can be correctly rounded. significant_bits 200 * tells how many bits will be significant in the final result to avoid 201 * superfluous computation. Inexactness is communicated by sticking on the 202 * lsb of px->significand[UNPACKED_SIZE-1]. Integer buffer overflow is 203 * indicated with a huge positive exponent. 204 */ 205 206 { 207 int frac_bits, sigint; 208 unsigned length, ndigs, ntz, nlz, ifrac, nfrac; 209 _big_float bi, bf, *ptounpacked = &bi; 210 211 px->sign = pd->sign; 212 px->fpclass = pd->fpclass; 213 if ((px->fpclass != fp_normal) && (px->fpclass != fp_subnormal)) 214 goto ret; 215 for (length = 0; pd->ds[length] != 0; length++); 216 if (length == 0) { /* A zero significand slipped by. */ 217 px->fpclass = fp_zero; 218 goto ret; 219 } 220 /* Length contains the number of explicit digits in string. */ 221 if (pd->exponent >= 0) {/* All integer digits. */ 222 ndigs = length; 223 ntz = pd->exponent; /* Trailing zeros. */ 224 ifrac = 0; 225 nfrac = 0; /* No fraction digits. */ 226 nlz = 0; 227 } else if (length <= -pd->exponent) { /* No integer digits. */ 228 ndigs = 0; 229 ntz = 0; 230 ifrac = 0; 231 nfrac = length; 232 nlz = -pd->exponent - length; /* Leading zeros. */ 233 } else { /* Some integer digits, some fraction digits. */ 234 ndigs = length + pd->exponent; 235 ntz = 0; 236 ifrac = ndigs; 237 nfrac = -pd->exponent; 238 nlz = 0; 239 while ((pd->ds[ifrac] == '0') && (nfrac != 0)) { 240 ifrac++; 241 nfrac--; 242 nlz++; 243 } /* Remove leading zeros. */ 244 } 245 if (ndigs != 0) { /* Convert integer digits. */ 246 247 bi.bsize = _BIG_FLOAT_SIZE; 248 decimal_to_binary_integer(pd->ds, ndigs, ntz, significant_bits, &bi); 249 if (bi.bexponent == 0x7fff) { /* Too big for buffer. */ 250 px->exponent = 0x000fffff; 251 px->significand[0] = 0x80000000; 252 goto ret; 253 } 254 sigint = 16 * (bi.blength + bi.bexponent - 1); 255 if (sigint < 0) 256 sigint = 0; 257 } else { /* No integer digits. */ 258 bi.blength = 0; 259 bi.bsignificand[0] = 0; 260 bi.bexponent = 0; 261 sigint = 0; 262 } 263 frac_bits = significant_bits - sigint + 2; 264 bf.blength = 0; 265 if ((nfrac != 0) && (frac_bits > 0)) { /* Convert fraction digits, 266 * even if we only need a 267 * round or sticky. */ 268 269 bf.bsize = _BIG_FLOAT_SIZE; 270 decimal_to_binary_fraction(&(pd->ds[ifrac]), nfrac, nlz, (unsigned) frac_bits, &bf); 271 } else { /* Only need fraction bits for sticky. */ 272 if (nfrac != 0) 273 bi.bsignificand[0] |= 1; /* Stick for fraction. */ 274 } 275 if (bi.blength == 0) { /* No integer digits; all fraction. */ 276 if (bf.bexponent == 0x7fff) { /* Buffer overflowed. */ 277 px->exponent = -0x000fffff; 278 px->significand[0] = 0x80000000; 279 goto ret; 280 } 281 ptounpacked = &bf; /* Exceptional case - all fraction. */ 282 goto punpack; 283 } 284 if (bf.blength != 0) { /* Combine integer and fraction bits. */ 285 int expdiff = bi.bexponent - (bf.bexponent + 16 * (bf.blength - 1)); /* Exponent difference. */ 286 int uneeded = 2 + (significant_bits + 2) / 16; /* Number of big float 287 * digits needed. */ 288 int nmove, leftshift, i, if0; 289 290 #ifdef DEBUG 291 printf(" bi+bf exponent diff is %d \n", expdiff); 292 printf(" need %d big float digits \n", uneeded); 293 assert(bi.blength != 0); 294 assert(bf.blength != 0); 295 assert(bi.bsignificand[bi.blength - 1] != 0); /* Normalized bi. */ 296 assert(bf.bsignificand[bf.blength - 1] != 0); /* Normalized bf. */ 297 assert(bi.bexponent >= 0); /* bi is all integer */ 298 assert(((-bf.bexponent - 16 * (bf.blength - 1)) >= 16) || 299 ((bf.bsignificand[bf.blength - 1] >> (-bf.bexponent - 16 * (bf.blength - 1))) == 0)); 300 /* assert either bf << 1 or bf < 1 */ 301 /* 302 * Assert that integer and fraction parts don't overlap by 303 * more than one big digit. 304 */ 305 assert(expdiff > 0); 306 assert(uneeded <= (2 * UNPACKED_SIZE)); 307 #endif 308 309 310 if (bi.blength >= uneeded) { /* bi will overflow unpacked, 311 * so bf is just a sticky. */ 312 bi.bsignificand[0] |= 1; 313 goto punpack; 314 } 315 leftshift = 16 - (expdiff % 16); 316 if (leftshift > 0) { /* shift bf to align with bi. */ 317 expdiff += 16 * bf.blength; 318 _left_shift_base_two(&bf, (short unsigned) leftshift); 319 expdiff -= 16 * bf.blength; /* If bf.blength is 320 * longer, adjust 321 * expdiff. */ 322 } 323 expdiff += leftshift; 324 expdiff /= 16; /* Remaining expdiff in _BIG_FLOAT_DIGITS. */ 325 expdiff--; 326 #ifdef DEBUG 327 assert(expdiff >= 0); /* expdiff is now equal to the size 328 * of the hole between bi and bf. */ 329 #endif 330 nmove = uneeded - bi.blength; 331 /* nmove is the number of words to add to bi. */ 332 if (nmove < 0) 333 nmove = 0; 334 if (nmove > (expdiff + bf.blength)) 335 nmove = (expdiff + bf.blength); 336 #ifdef DEBUG 337 printf(" increase bi by %d words to merge \n", nmove); 338 #endif 339 if (nmove == 0) 340 i = -1; 341 else 342 for (i = (bi.blength - 1 + nmove); i >= nmove; i--) 343 bi.bsignificand[i] = bi.bsignificand[i - nmove]; 344 for (; (i >= 0) && (expdiff > 0); i--) { /* Fill hole with zeros. */ 345 expdiff--; 346 bi.bsignificand[i] = 0; 347 } 348 if0 = i; 349 for (; i >= 0; i--) 350 bi.bsignificand[i] = bf.bsignificand[i + bf.blength - 1 - if0]; 351 for (i = (bf.blength - 2 - if0); bf.bsignificand[i] == 0; i--); 352 /* Find first non-zero. */ 353 if (i >= 0) 354 bi.bsignificand[0] |= 1; /* If non-zero found, 355 * stick it. */ 356 bi.blength += nmove; 357 bi.bexponent -= 16 * nmove; 358 goto punpack; 359 } 360 punpack: 361 ptounpacked->bsignificand[0] |= pd->more; /* Stick in any lost 362 * digits. */ 363 364 #ifdef DEBUG 365 printf(" merged bi and bf: "); 366 _display_big_float(ptounpacked, 2); 367 #endif 368 369 _big_binary_to_unpacked(ptounpacked, px); 370 371 ret: 372 return; 373 } 374 375 /* PUBLIC FUNCTIONS */ 376 377 /* 378 * decimal_to_floating routines convert the decimal record at *pd to the 379 * floating type item at *px, observing the modes specified in *pm and 380 * setting exceptions in *ps. 381 * 382 * pd->sign and pd->fpclass are always taken into account. 383 * 384 * pd->exponent, pd->ds and pd->ndigits are used when pd->fpclass is 385 * fp_normal or fp_subnormal. In these cases pd->ds is expected to 386 * contain one or more ascii digits followed by a null and pd->ndigits 387 * is assumed to be the length of the string pd->ds. Notice that for 388 * efficiency reasons, the assumption that pd->ndigits == strlen(pd->ds) 389 * is NEVER verified. 390 * 391 * px is set to a correctly rounded approximation to 392 * (sign)*(ds)*10**(exponent) If pd->more != 0 then additional nonzero digits 393 * are assumed to follow those in ds; fp_inexact is set accordingly. 394 * 395 * Thus if pd->exponent == -2 and pd->ds = "1234", *px will get 12.34 rounded to 396 * storage precision. 397 * 398 * px is correctly rounded according to the IEEE rounding modes in pm->rd. *ps 399 * is set to contain fp_inexact, fp_underflow, or fp_overflow if any of these 400 * arise. 401 * 402 * pm->df and pm->ndigits are never used. 403 * 404 */ 405 406 void 407 decimal_to_single(px, pm, pd, ps) 408 single *px; 409 decimal_mode *pm; 410 decimal_record *pd; 411 fp_exception_field_type *ps; 412 { 413 single_equivalence kluge; 414 unpacked u; 415 416 *ps = 0; /* Initialize to no floating-point 417 * exceptions. */ 418 kluge.f.msw.sign = pd->sign ? 1 : 0; 419 switch (pd->fpclass) { 420 case fp_zero: 421 kluge.f.msw.exponent = 0; 422 kluge.f.msw.significand = 0; 423 break; 424 case fp_infinity: 425 kluge.f.msw.exponent = 0xff; 426 kluge.f.msw.significand = 0; 427 break; 428 case fp_quiet: 429 kluge.f.msw.exponent = 0xff; 430 kluge.f.msw.significand = 0x7fffff; 431 break; 432 case fp_signaling: 433 kluge.f.msw.exponent = 0xff; 434 kluge.f.msw.significand = 0x3fffff; 435 break; 436 default: 437 if (pd->exponent > SINGLE_MAXE) { /* Guaranteed overflow. */ 438 u.sign = pd->sign == 0 ? 0 : 1; 439 u.fpclass = fp_normal; 440 u.exponent = 0x000fffff; 441 u.significand[0] = 0x80000000; 442 } else if (pd->exponent >= -SINGLE_MAXE) { /* Guaranteed in range. */ 443 goto inrange; 444 } else if (pd->exponent <= (-SINGLE_MAXE - DECIMAL_STRING_LENGTH)) { /* Guaranteed deep 445 * underflow. */ 446 goto underflow; 447 } else { /* Deep underflow possible, depending on 448 * string length. */ 449 int i; 450 451 for (i = 0; (pd->ds[i] != 0) && (i < (-pd->exponent - SINGLE_MAXE)); i++); 452 if (i < (-pd->exponent - SINGLE_MAXE)) { /* Deep underflow */ 453 underflow: 454 u.sign = pd->sign == 0 ? 0 : 1; 455 u.fpclass = fp_normal; 456 u.exponent = -0x000fffff; 457 u.significand[0] = 0x80000000; 458 } else {/* In range. */ 459 inrange: 460 decimal_to_unpacked(&u, pd, 24); 461 } 462 } 463 _fp_current_exceptions = 0; 464 _fp_current_direction = pm->rd; 465 _pack_single(&u, &kluge.x); 466 *ps = _fp_current_exceptions; 467 } 468 *px = kluge.x; 469 } 470 471 void 472 decimal_to_double(px, pm, pd, ps) 473 double *px; 474 decimal_mode *pm; 475 decimal_record *pd; 476 fp_exception_field_type *ps; 477 { 478 double_equivalence kluge; 479 unpacked u; 480 481 *ps = 0; /* Initialize to no floating-point 482 * exceptions. */ 483 kluge.f.msw.sign = pd->sign ? 1 : 0; 484 switch (pd->fpclass) { 485 case fp_zero: 486 kluge.f.msw.exponent = 0; 487 kluge.f.msw.significand = 0; 488 kluge.f.significand2 = 0; 489 break; 490 case fp_infinity: 491 kluge.f.msw.exponent = 0x7ff; 492 kluge.f.msw.significand = 0; 493 kluge.f.significand2 = 0; 494 break; 495 case fp_quiet: 496 kluge.f.msw.exponent = 0x7ff; 497 kluge.f.msw.significand = 0xfffff; 498 kluge.f.significand2 = 0xffffffff; 499 break; 500 case fp_signaling: 501 kluge.f.msw.exponent = 0x7ff; 502 kluge.f.msw.significand = 0x7ffff; 503 kluge.f.significand2 = 0xffffffff; 504 break; 505 default: 506 if (pd->exponent > DOUBLE_MAXE) { /* Guaranteed overflow. */ 507 u.sign = pd->sign == 0 ? 0 : 1; 508 u.fpclass = fp_normal; 509 u.exponent = 0x000fffff; 510 u.significand[0] = 0x80000000; 511 } else if (pd->exponent >= -DOUBLE_MAXE) { /* Guaranteed in range. */ 512 goto inrange; 513 } else if (pd->exponent <= (-DOUBLE_MAXE - DECIMAL_STRING_LENGTH)) { /* Guaranteed deep 514 * underflow. */ 515 goto underflow; 516 } else { /* Deep underflow possible, depending on 517 * string length. */ 518 int i; 519 520 for (i = 0; (pd->ds[i] != 0) && (i < (-pd->exponent - DOUBLE_MAXE)); i++); 521 if (i < (-pd->exponent - DOUBLE_MAXE)) { /* Deep underflow */ 522 underflow: 523 u.sign = pd->sign == 0 ? 0 : 1; 524 u.fpclass = fp_normal; 525 u.exponent = -0x000fffff; 526 u.significand[0] = 0x80000000; 527 } else {/* In range. */ 528 inrange: 529 decimal_to_unpacked(&u, pd, 53); 530 } 531 } 532 _fp_current_exceptions = 0; 533 _fp_current_direction = pm->rd; 534 _pack_double(&u, &kluge.x); 535 *ps = _fp_current_exceptions; 536 } 537 *px = kluge.x; 538 } 539 540 void 541 decimal_to_extended(px, pm, pd, ps) 542 extended *px; 543 decimal_mode *pm; 544 decimal_record *pd; 545 fp_exception_field_type *ps; 546 { 547 extended_equivalence kluge; 548 unpacked u; 549 550 *ps = 0; /* Initialize to no floating-point 551 * exceptions. */ 552 kluge.f.msw.sign = pd->sign ? 1 : 0; 553 switch (pd->fpclass) { 554 case fp_zero: 555 kluge.f.msw.exponent = 0; 556 kluge.f.significand = 0; 557 kluge.f.significand2 = 0; 558 break; 559 case fp_infinity: 560 kluge.f.msw.exponent = 0x7fff; 561 kluge.f.significand = 0; 562 kluge.f.significand2 = 0; 563 break; 564 case fp_quiet: 565 kluge.f.msw.exponent = 0x7fff; 566 kluge.f.significand = 0xffffffff; 567 kluge.f.significand2 = 0xffffffff; 568 break; 569 case fp_signaling: 570 kluge.f.msw.exponent = 0x7fff; 571 kluge.f.significand = 0x3fffffff; 572 kluge.f.significand2 = 0xffffffff; 573 break; 574 default: 575 if (pd->exponent > EXTENDED_MAXE) { /* Guaranteed overflow. */ 576 u.sign = pd->sign == 0 ? 0 : 1; 577 u.fpclass = fp_normal; 578 u.exponent = 0x000fffff; 579 u.significand[0] = 0x80000000; 580 } else if (pd->exponent >= -EXTENDED_MAXE) { /* Guaranteed in range. */ 581 goto inrange; 582 } else if (pd->exponent <= (-EXTENDED_MAXE - DECIMAL_STRING_LENGTH)) { /* Guaranteed deep 583 * underflow. */ 584 goto underflow; 585 } else { /* Deep underflow possible, depending on 586 * string length. */ 587 int i; 588 589 for (i = 0; (pd->ds[i] != 0) && (i < (-pd->exponent - EXTENDED_MAXE)); i++); 590 if (i < (-pd->exponent - EXTENDED_MAXE)) { /* Deep underflow */ 591 underflow: 592 u.sign = pd->sign == 0 ? 0 : 1; 593 u.fpclass = fp_normal; 594 u.exponent = -0x000fffff; 595 u.significand[0] = 0x80000000; 596 } else {/* In range. */ 597 inrange: 598 decimal_to_unpacked(&u, pd, 64); 599 } 600 } 601 _fp_current_exceptions = 0; 602 _fp_current_direction = pm->rd; 603 _fp_current_precision = fp_extended; 604 _pack_extended(&u, px); 605 *ps = _fp_current_exceptions; 606 return; 607 } 608 (*px)[0] = kluge.x[0]; 609 (*px)[1] = kluge.x[1]; 610 (*px)[2] = kluge.x[2]; 611 } 612 613 void 614 decimal_to_quadruple(px, pm, pd, ps) 615 quadruple *px; 616 decimal_mode *pm; 617 decimal_record *pd; 618 fp_exception_field_type *ps; 619 { 620 quadruple_equivalence kluge; 621 unpacked u; 622 int i; 623 624 *ps = 0; /* Initialize to no floating-point 625 * exceptions. */ 626 kluge.f.msw.sign = pd->sign ? 1 : 0; 627 switch (pd->fpclass) { 628 case fp_zero: 629 kluge.f.msw.exponent = 0; 630 kluge.f.msw.significand = 0; 631 kluge.f.significand2 = 0; 632 kluge.f.significand3 = 0; 633 kluge.f.significand4 = 0; 634 break; 635 case fp_infinity: 636 kluge.f.msw.exponent = 0x7fff; 637 kluge.f.msw.significand = 0; 638 kluge.f.significand2 = 0; 639 kluge.f.significand3 = 0; 640 kluge.f.significand4 = 0; 641 break; 642 case fp_quiet: 643 kluge.f.msw.exponent = 0x7fff; 644 kluge.f.msw.significand = 0xffff; 645 kluge.f.significand2 = 0xffffffff; 646 kluge.f.significand3 = 0xffffffff; 647 kluge.f.significand4 = 0xffffffff; 648 break; 649 case fp_signaling: 650 kluge.f.msw.exponent = 0x7fff; 651 kluge.f.msw.significand = 0x7fff; 652 kluge.f.significand2 = 0xffffffff; 653 kluge.f.significand3 = 0xffffffff; 654 kluge.f.significand4 = 0xffffffff; 655 break; 656 default: 657 if (pd->exponent > QUAD_MAXE) { /* Guaranteed overflow. */ 658 u.sign = pd->sign == 0 ? 0 : 1; 659 u.fpclass = fp_normal; 660 u.exponent = 0x000fffff; 661 u.significand[0] = 0x80000000; 662 } else if (pd->exponent >= -QUAD_MAXE) { /* Guaranteed in range. */ 663 goto inrange; 664 } else if (pd->exponent <= (-QUAD_MAXE - DECIMAL_STRING_LENGTH)) { /* Guaranteed deep 665 * underflow. */ 666 goto underflow; 667 } else { /* Deep underflow possible, depending on 668 * string length. */ 669 670 for (i = 0; (pd->ds[i] != 0) && (i < (-pd->exponent - QUAD_MAXE)); i++); 671 if (i < (-pd->exponent - QUAD_MAXE)) { /* Deep underflow */ 672 underflow: 673 u.sign = pd->sign == 0 ? 0 : 1; 674 u.fpclass = fp_normal; 675 u.exponent = -0x000fffff; 676 u.significand[0] = 0x80000000; 677 } else {/* In range. */ 678 inrange: 679 decimal_to_unpacked(&u, pd, 113); 680 } 681 } 682 _fp_current_exceptions = 0; 683 _fp_current_direction = pm->rd; 684 _pack_quadruple(&u, px); 685 *ps = _fp_current_exceptions; 686 return; 687 } 688 #ifdef __STDC__ 689 *px = kluge.x; 690 #else 691 for (i = 0; i < 4; i++) 692 px->u[i] = kluge.x.u[i]; 693 #endif 694 } 695
Indexes created Sat Nov 28 12:39:51 UTC 2009
Terms of Use |
Privacy |
Trademarks |
Copyright Policy |
Site Guidelines |
Help
Your use of this web site or any of its content or software indicates your agreement to be bound by these Terms of Use.
Copyright © 1995-2008 Sun Microsystems, Inc.