atof-ieee.c revision 60484
1238104Sdes/* atof_ieee.c - turn a Flonum into an IEEE floating point number 2238104Sdes Copyright (C) 1987, 92, 93, 94, 95, 96, 97, 98, 99, 2000 3238104Sdes Free Software Foundation, Inc. 4238104Sdes 5238104Sdes This file is part of GAS, the GNU Assembler. 6238104Sdes 7238104Sdes GAS is free software; you can redistribute it and/or modify 8238104Sdes it under the terms of the GNU General Public License as published by 9238104Sdes the Free Software Foundation; either version 2, or (at your option) 10238104Sdes any later version. 11238104Sdes 12238104Sdes GAS is distributed in the hope that it will be useful, 13238104Sdes but WITHOUT ANY WARRANTY; without even the implied warranty of 14238104Sdes MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15238104Sdes GNU General Public License for more details. 16238104Sdes 17238104Sdes You should have received a copy of the GNU General Public License 18238104Sdes along with GAS; see the file COPYING. If not, write to the Free 19238104Sdes Software Foundation, 59 Temple Place - Suite 330, Boston, MA 20238104Sdes 02111-1307, USA. */ 21238104Sdes 22238104Sdes#include "as.h" 23238104Sdes 24238104Sdes/* Flonums returned here. */ 25238104Sdesextern FLONUM_TYPE generic_floating_point_number; 26238104Sdes 27238104Sdesstatic int next_bits PARAMS ((int)); 28238104Sdesstatic void unget_bits PARAMS ((int)); 29238104Sdesstatic void make_invalid_floating_point_number PARAMS ((LITTLENUM_TYPE *)); 30238104Sdes 31238104Sdesextern const char EXP_CHARS[]; 32238104Sdes/* Precision in LittleNums. */ 33238104Sdes/* Don't count the gap in the m68k extended precision format. */ 34238104Sdes#define MAX_PRECISION (5) 35238104Sdes#define F_PRECISION (2) 36238104Sdes#define D_PRECISION (4) 37238104Sdes#define X_PRECISION (5) 38238104Sdes#define P_PRECISION (5) 39238104Sdes 40238104Sdes/* Length in LittleNums of guard bits. */ 41238104Sdes#define GUARD (2) 42238104Sdes 43238104Sdesstatic const unsigned long mask[] = 44238104Sdes{ 45238104Sdes 0x00000000, 46238104Sdes 0x00000001, 47238104Sdes 0x00000003, 48238104Sdes 0x00000007, 49238104Sdes 0x0000000f, 50238104Sdes 0x0000001f, 51238104Sdes 0x0000003f, 52238104Sdes 0x0000007f, 53238104Sdes 0x000000ff, 54238104Sdes 0x000001ff, 55238104Sdes 0x000003ff, 56238104Sdes 0x000007ff, 57238104Sdes 0x00000fff, 58238104Sdes 0x00001fff, 59238104Sdes 0x00003fff, 60238104Sdes 0x00007fff, 61238104Sdes 0x0000ffff, 62238104Sdes 0x0001ffff, 63238104Sdes 0x0003ffff, 64238104Sdes 0x0007ffff, 65238104Sdes 0x000fffff, 66238104Sdes 0x001fffff, 67238104Sdes 0x003fffff, 68238104Sdes 0x007fffff, 69238104Sdes 0x00ffffff, 70238104Sdes 0x01ffffff, 71238104Sdes 0x03ffffff, 72238104Sdes 0x07ffffff, 73238104Sdes 0x0fffffff, 74238104Sdes 0x1fffffff, 75238104Sdes 0x3fffffff, 76238104Sdes 0x7fffffff, 77238104Sdes 0xffffffff, 78238104Sdes}; 79238104Sdes 80238104Sdes 81238104Sdesstatic int bits_left_in_littlenum; 82238104Sdesstatic int littlenums_left; 83238104Sdesstatic LITTLENUM_TYPE *littlenum_pointer; 84238104Sdes 85238104Sdesstatic int 86238104Sdesnext_bits (number_of_bits) 87238104Sdes int number_of_bits; 88238104Sdes{ 89238104Sdes int return_value; 90238104Sdes 91238104Sdes if (!littlenums_left) 92238104Sdes return (0); 93238104Sdes if (number_of_bits >= bits_left_in_littlenum) 94238104Sdes { 95238104Sdes return_value = mask[bits_left_in_littlenum] & *littlenum_pointer; 96238104Sdes number_of_bits -= bits_left_in_littlenum; 97238104Sdes return_value <<= number_of_bits; 98238104Sdes 99238104Sdes if (--littlenums_left) 100238104Sdes { 101238104Sdes bits_left_in_littlenum = LITTLENUM_NUMBER_OF_BITS - number_of_bits; 102238104Sdes --littlenum_pointer; 103238104Sdes return_value |= (*littlenum_pointer >> bits_left_in_littlenum) & mask[number_of_bits]; 104238104Sdes } 105238104Sdes } 106238104Sdes else 107238104Sdes { 108238104Sdes bits_left_in_littlenum -= number_of_bits; 109238104Sdes return_value = mask[number_of_bits] & (*littlenum_pointer >> bits_left_in_littlenum); 110238104Sdes } 111238104Sdes return (return_value); 112238104Sdes} 113238104Sdes 114238104Sdes/* Num had better be less than LITTLENUM_NUMBER_OF_BITS */ 115238104Sdesstatic void 116238104Sdesunget_bits (num) 117238104Sdes int num; 118238104Sdes{ 119238104Sdes if (!littlenums_left) 120238104Sdes { 121238104Sdes ++littlenum_pointer; 122238104Sdes ++littlenums_left; 123238104Sdes bits_left_in_littlenum = num; 124238104Sdes } 125238104Sdes else if (bits_left_in_littlenum + num > LITTLENUM_NUMBER_OF_BITS) 126238104Sdes { 127238104Sdes bits_left_in_littlenum = num - (LITTLENUM_NUMBER_OF_BITS - bits_left_in_littlenum); 128238104Sdes ++littlenum_pointer; 129238104Sdes ++littlenums_left; 130238104Sdes } 131238104Sdes else 132238104Sdes bits_left_in_littlenum += num; 133238104Sdes} 134238104Sdes 135238104Sdesstatic void 136make_invalid_floating_point_number (words) 137 LITTLENUM_TYPE *words; 138{ 139 as_bad (_("cannot create floating-point number")); 140 words[0] = (LITTLENUM_TYPE) ((unsigned) -1) >> 1; /* Zero the leftmost bit */ 141 words[1] = (LITTLENUM_TYPE) -1; 142 words[2] = (LITTLENUM_TYPE) -1; 143 words[3] = (LITTLENUM_TYPE) -1; 144 words[4] = (LITTLENUM_TYPE) -1; 145 words[5] = (LITTLENUM_TYPE) -1; 146} 147 148/************************************************************************\ 149 * Warning: this returns 16-bit LITTLENUMs. It is up to the caller * 150 * to figure out any alignment problems and to conspire for the * 151 * bytes/word to be emitted in the right order. Bigendians beware! * 152 * * 153\************************************************************************/ 154 155/* Note that atof-ieee always has X and P precisions enabled. it is up 156 to md_atof to filter them out if the target machine does not support 157 them. */ 158 159/* Returns pointer past text consumed. */ 160char * 161atof_ieee (str, what_kind, words) 162 char *str; /* Text to convert to binary. */ 163 int what_kind; /* 'd', 'f', 'g', 'h' */ 164 LITTLENUM_TYPE *words; /* Build the binary here. */ 165{ 166 /* Extra bits for zeroed low-order bits. The 1st MAX_PRECISION are 167 zeroed, the last contain flonum bits. */ 168 static LITTLENUM_TYPE bits[MAX_PRECISION + MAX_PRECISION + GUARD]; 169 char *return_value; 170 /* Number of 16-bit words in the format. */ 171 int precision; 172 long exponent_bits; 173 FLONUM_TYPE save_gen_flonum; 174 175 /* We have to save the generic_floating_point_number because it 176 contains storage allocation about the array of LITTLENUMs where 177 the value is actually stored. We will allocate our own array of 178 littlenums below, but have to restore the global one on exit. */ 179 save_gen_flonum = generic_floating_point_number; 180 181 return_value = str; 182 generic_floating_point_number.low = bits + MAX_PRECISION; 183 generic_floating_point_number.high = NULL; 184 generic_floating_point_number.leader = NULL; 185 generic_floating_point_number.exponent = 0; 186 generic_floating_point_number.sign = '\0'; 187 188 /* Use more LittleNums than seems necessary: the highest flonum may 189 have 15 leading 0 bits, so could be useless. */ 190 191 memset (bits, '\0', sizeof (LITTLENUM_TYPE) * MAX_PRECISION); 192 193 switch (what_kind) 194 { 195 case 'f': 196 case 'F': 197 case 's': 198 case 'S': 199 precision = F_PRECISION; 200 exponent_bits = 8; 201 break; 202 203 case 'd': 204 case 'D': 205 case 'r': 206 case 'R': 207 precision = D_PRECISION; 208 exponent_bits = 11; 209 break; 210 211 case 'x': 212 case 'X': 213 case 'e': 214 case 'E': 215 precision = X_PRECISION; 216 exponent_bits = 15; 217 break; 218 219 case 'p': 220 case 'P': 221 222 precision = P_PRECISION; 223 exponent_bits = -1; 224 break; 225 226 default: 227 make_invalid_floating_point_number (words); 228 return (NULL); 229 } 230 231 generic_floating_point_number.high 232 = generic_floating_point_number.low + precision - 1 + GUARD; 233 234 if (atof_generic (&return_value, ".", EXP_CHARS, 235 &generic_floating_point_number)) 236 { 237 make_invalid_floating_point_number (words); 238 return (NULL); 239 } 240 gen_to_words (words, precision, exponent_bits); 241 242 /* Restore the generic_floating_point_number's storage alloc (and 243 everything else). */ 244 generic_floating_point_number = save_gen_flonum; 245 246 return return_value; 247} 248 249/* Turn generic_floating_point_number into a real float/double/extended. */ 250int 251gen_to_words (words, precision, exponent_bits) 252 LITTLENUM_TYPE *words; 253 int precision; 254 long exponent_bits; 255{ 256 int return_value = 0; 257 258 long exponent_1; 259 long exponent_2; 260 long exponent_3; 261 long exponent_4; 262 int exponent_skippage; 263 LITTLENUM_TYPE word1; 264 LITTLENUM_TYPE *lp; 265 LITTLENUM_TYPE *words_end; 266 267 words_end = words + precision; 268#ifdef TC_M68K 269 if (precision == X_PRECISION) 270 /* On the m68k the extended precision format has a gap of 16 bits 271 between the exponent and the mantissa. */ 272 words_end++; 273#endif 274 275 if (generic_floating_point_number.low > generic_floating_point_number.leader) 276 { 277 /* 0.0e0 seen. */ 278 if (generic_floating_point_number.sign == '+') 279 words[0] = 0x0000; 280 else 281 words[0] = 0x8000; 282 memset (&words[1], '\0', 283 (words_end - words - 1) * sizeof (LITTLENUM_TYPE)); 284 return (return_value); 285 } 286 287 /* NaN: Do the right thing */ 288 if (generic_floating_point_number.sign == 0) 289 { 290 if (precision == F_PRECISION) 291 { 292 words[0] = 0x7fff; 293 words[1] = 0xffff; 294 } 295 else if (precision == X_PRECISION) 296 { 297#ifdef TC_M68K 298 words[0] = 0x7fff; 299 words[1] = 0; 300 words[2] = 0xffff; 301 words[3] = 0xffff; 302 words[4] = 0xffff; 303 words[5] = 0xffff; 304#else /* ! TC_M68K */ 305#ifdef TC_I386 306 words[0] = 0xffff; 307 words[1] = 0xc000; 308 words[2] = 0; 309 words[3] = 0; 310 words[4] = 0; 311#else /* ! TC_I386 */ 312 abort (); 313#endif /* ! TC_I386 */ 314#endif /* ! TC_M68K */ 315 } 316 else 317 { 318 words[0] = 0x7fff; 319 words[1] = 0xffff; 320 words[2] = 0xffff; 321 words[3] = 0xffff; 322 } 323 return return_value; 324 } 325 else if (generic_floating_point_number.sign == 'P') 326 { 327 /* +INF: Do the right thing */ 328 if (precision == F_PRECISION) 329 { 330 words[0] = 0x7f80; 331 words[1] = 0; 332 } 333 else if (precision == X_PRECISION) 334 { 335#ifdef TC_M68K 336 words[0] = 0x7fff; 337 words[1] = 0; 338 words[2] = 0; 339 words[3] = 0; 340 words[4] = 0; 341 words[5] = 0; 342#else /* ! TC_M68K */ 343#ifdef TC_I386 344 words[0] = 0x7fff; 345 words[1] = 0x8000; 346 words[2] = 0; 347 words[3] = 0; 348 words[4] = 0; 349#else /* ! TC_I386 */ 350 abort (); 351#endif /* ! TC_I386 */ 352#endif /* ! TC_M68K */ 353 } 354 else 355 { 356 words[0] = 0x7ff0; 357 words[1] = 0; 358 words[2] = 0; 359 words[3] = 0; 360 } 361 return (return_value); 362 } 363 else if (generic_floating_point_number.sign == 'N') 364 { 365 /* Negative INF */ 366 if (precision == F_PRECISION) 367 { 368 words[0] = 0xff80; 369 words[1] = 0x0; 370 } 371 else if (precision == X_PRECISION) 372 { 373#ifdef TC_M68K 374 words[0] = 0xffff; 375 words[1] = 0; 376 words[2] = 0; 377 words[3] = 0; 378 words[4] = 0; 379 words[5] = 0; 380#else /* ! TC_M68K */ 381#ifdef TC_I386 382 words[0] = 0xffff; 383 words[1] = 0x8000; 384 words[2] = 0; 385 words[3] = 0; 386 words[4] = 0; 387#else /* ! TC_I386 */ 388 abort (); 389#endif /* ! TC_I386 */ 390#endif /* ! TC_M68K */ 391 } 392 else 393 { 394 words[0] = 0xfff0; 395 words[1] = 0x0; 396 words[2] = 0x0; 397 words[3] = 0x0; 398 } 399 return (return_value); 400 } 401 /* 402 * The floating point formats we support have: 403 * Bit 15 is sign bit. 404 * Bits 14:n are excess-whatever exponent. 405 * Bits n-1:0 (if any) are most significant bits of fraction. 406 * Bits 15:0 of the next word(s) are the next most significant bits. 407 * 408 * So we need: number of bits of exponent, number of bits of 409 * mantissa. 410 */ 411 bits_left_in_littlenum = LITTLENUM_NUMBER_OF_BITS; 412 littlenum_pointer = generic_floating_point_number.leader; 413 littlenums_left = (1 414 + generic_floating_point_number.leader 415 - generic_floating_point_number.low); 416 /* Seek (and forget) 1st significant bit */ 417 for (exponent_skippage = 0; !next_bits (1); ++exponent_skippage);; 418 exponent_1 = (generic_floating_point_number.exponent 419 + generic_floating_point_number.leader 420 + 1 421 - generic_floating_point_number.low); 422 /* Radix LITTLENUM_RADIX, point just higher than 423 generic_floating_point_number.leader. */ 424 exponent_2 = exponent_1 * LITTLENUM_NUMBER_OF_BITS; 425 /* Radix 2. */ 426 exponent_3 = exponent_2 - exponent_skippage; 427 /* Forget leading zeros, forget 1st bit. */ 428 exponent_4 = exponent_3 + ((1 << (exponent_bits - 1)) - 2); 429 /* Offset exponent. */ 430 431 lp = words; 432 433 /* Word 1. Sign, exponent and perhaps high bits. */ 434 word1 = ((generic_floating_point_number.sign == '+') 435 ? 0 436 : (1 << (LITTLENUM_NUMBER_OF_BITS - 1))); 437 438 /* Assume 2's complement integers. */ 439 if (exponent_4 <= 0) 440 { 441 int prec_bits; 442 int num_bits; 443 444 unget_bits (1); 445 num_bits = -exponent_4; 446 prec_bits = LITTLENUM_NUMBER_OF_BITS * precision - (exponent_bits + 1 + num_bits); 447#ifdef TC_I386 448 if (precision == X_PRECISION && exponent_bits == 15) 449 { 450 /* On the i386 a denormalized extended precision float is 451 shifted down by one, effectively decreasing the exponent 452 bias by one. */ 453 prec_bits -= 1; 454 num_bits += 1; 455 } 456#endif 457 458 if (num_bits >= LITTLENUM_NUMBER_OF_BITS - exponent_bits) 459 { 460 /* Bigger than one littlenum */ 461 num_bits -= (LITTLENUM_NUMBER_OF_BITS - 1) - exponent_bits; 462 *lp++ = word1; 463 if (num_bits + exponent_bits + 1 > precision * LITTLENUM_NUMBER_OF_BITS) 464 { 465 /* Exponent overflow */ 466 make_invalid_floating_point_number (words); 467 return (return_value); 468 } 469#ifdef TC_M68K 470 if (precision == X_PRECISION && exponent_bits == 15) 471 *lp++ = 0; 472#endif 473 while (num_bits >= LITTLENUM_NUMBER_OF_BITS) 474 { 475 num_bits -= LITTLENUM_NUMBER_OF_BITS; 476 *lp++ = 0; 477 } 478 if (num_bits) 479 *lp++ = next_bits (LITTLENUM_NUMBER_OF_BITS - (num_bits)); 480 } 481 else 482 { 483 if (precision == X_PRECISION && exponent_bits == 15) 484 { 485 *lp++ = word1; 486#ifdef TC_M68K 487 *lp++ = 0; 488#endif 489 *lp++ = next_bits (LITTLENUM_NUMBER_OF_BITS - num_bits); 490 } 491 else 492 { 493 word1 |= next_bits ((LITTLENUM_NUMBER_OF_BITS - 1) - (exponent_bits + num_bits)); 494 *lp++ = word1; 495 } 496 } 497 while (lp < words_end) 498 *lp++ = next_bits (LITTLENUM_NUMBER_OF_BITS); 499 500 /* Round the mantissa up, but don't change the number */ 501 if (next_bits (1)) 502 { 503 --lp; 504 if (prec_bits >= LITTLENUM_NUMBER_OF_BITS) 505 { 506 int n = 0; 507 int tmp_bits; 508 509 n = 0; 510 tmp_bits = prec_bits; 511 while (tmp_bits > LITTLENUM_NUMBER_OF_BITS) 512 { 513 if (lp[n] != (LITTLENUM_TYPE) - 1) 514 break; 515 --n; 516 tmp_bits -= LITTLENUM_NUMBER_OF_BITS; 517 } 518 if (tmp_bits > LITTLENUM_NUMBER_OF_BITS 519 || (lp[n] & mask[tmp_bits]) != mask[tmp_bits] 520 || (prec_bits != (precision * LITTLENUM_NUMBER_OF_BITS 521 - exponent_bits - 1) 522#ifdef TC_I386 523 /* An extended precision float with only the integer 524 bit set would be invalid. That must be converted 525 to the smallest normalized number. */ 526 && !(precision == X_PRECISION 527 && prec_bits == (precision * LITTLENUM_NUMBER_OF_BITS 528 - exponent_bits - 2)) 529#endif 530 )) 531 { 532 unsigned long carry; 533 534 for (carry = 1; carry && (lp >= words); lp--) 535 { 536 carry = *lp + carry; 537 *lp = carry; 538 carry >>= LITTLENUM_NUMBER_OF_BITS; 539 } 540 } 541 else 542 { 543 /* This is an overflow of the denormal numbers. We 544 need to forget what we have produced, and instead 545 generate the smallest normalized number. */ 546 lp = words; 547 word1 = ((generic_floating_point_number.sign == '+') 548 ? 0 549 : (1 << (LITTLENUM_NUMBER_OF_BITS - 1))); 550 word1 |= (1 551 << ((LITTLENUM_NUMBER_OF_BITS - 1) 552 - exponent_bits)); 553 *lp++ = word1; 554#ifdef TC_I386 555 /* Set the integer bit in the extended precision format. 556 This cannot happen on the m68k where the mantissa 557 just overflows into the integer bit above. */ 558 if (precision == X_PRECISION) 559 *lp++ = 1 << (LITTLENUM_NUMBER_OF_BITS - 1); 560#endif 561 while (lp < words_end) 562 *lp++ = 0; 563 } 564 } 565 else 566 *lp += 1; 567 } 568 569 return return_value; 570 } 571 else if ((unsigned long) exponent_4 >= mask[exponent_bits]) 572 { 573 /* 574 * Exponent overflow. Lose immediately. 575 */ 576 577 /* 578 * We leave return_value alone: admit we read the 579 * number, but return a floating exception 580 * because we can't encode the number. 581 */ 582 make_invalid_floating_point_number (words); 583 return return_value; 584 } 585 else 586 { 587 word1 |= (exponent_4 << ((LITTLENUM_NUMBER_OF_BITS - 1) - exponent_bits)) 588 | next_bits ((LITTLENUM_NUMBER_OF_BITS - 1) - exponent_bits); 589 } 590 591 *lp++ = word1; 592 593 /* X_PRECISION is special: on the 68k, it has 16 bits of zero in the 594 middle. Either way, it is then followed by a 1 bit. */ 595 if (exponent_bits == 15 && precision == X_PRECISION) 596 { 597#ifdef TC_M68K 598 *lp++ = 0; 599#endif 600 *lp++ = (1 << (LITTLENUM_NUMBER_OF_BITS - 1) 601 | next_bits (LITTLENUM_NUMBER_OF_BITS - 1)); 602 } 603 604 /* The rest of the words are just mantissa bits. */ 605 while (lp < words_end) 606 *lp++ = next_bits (LITTLENUM_NUMBER_OF_BITS); 607 608 if (next_bits (1)) 609 { 610 unsigned long carry; 611 /* 612 * Since the NEXT bit is a 1, round UP the mantissa. 613 * The cunning design of these hidden-1 floats permits 614 * us to let the mantissa overflow into the exponent, and 615 * it 'does the right thing'. However, we lose if the 616 * highest-order bit of the lowest-order word flips. 617 * Is that clear? 618 */ 619 620 /* #if (sizeof(carry)) < ((sizeof(bits[0]) * BITS_PER_CHAR) + 2) 621 Please allow at least 1 more bit in carry than is in a LITTLENUM. 622 We need that extra bit to hold a carry during a LITTLENUM carry 623 propagation. Another extra bit (kept 0) will assure us that we 624 don't get a sticky sign bit after shifting right, and that 625 permits us to propagate the carry without any masking of bits. 626 #endif */ 627 for (carry = 1, lp--; carry; lp--) 628 { 629 carry = *lp + carry; 630 *lp = carry; 631 carry >>= LITTLENUM_NUMBER_OF_BITS; 632 if (lp == words) 633 break; 634 } 635 if (precision == X_PRECISION && exponent_bits == 15) 636 { 637 /* Extended precision numbers have an explicit integer bit 638 that we may have to restore. */ 639 if (lp == words) 640 { 641#ifdef TC_M68K 642 /* On the m68k there is a gap of 16 bits. We must 643 explicitly propagate the carry into the exponent. */ 644 words[0] += words[1]; 645 words[1] = 0; 646 lp++; 647#endif 648 /* Put back the integer bit. */ 649 lp[1] |= 1 << (LITTLENUM_NUMBER_OF_BITS - 1); 650 } 651 } 652 if ((word1 ^ *words) & (1 << (LITTLENUM_NUMBER_OF_BITS - 1))) 653 { 654 /* We leave return_value alone: admit we read the 655 * number, but return a floating exception 656 * because we can't encode the number. 657 */ 658 *words &= ~(1 << (LITTLENUM_NUMBER_OF_BITS - 1)); 659 /* make_invalid_floating_point_number (words); */ 660 /* return return_value; */ 661 } 662 } 663 return (return_value); 664} 665 666#if 0 /* unused */ 667/* This routine is a real kludge. Someone really should do it better, 668 but I'm too lazy, and I don't understand this stuff all too well 669 anyway. (JF) */ 670static void 671int_to_gen (x) 672 long x; 673{ 674 char buf[20]; 675 char *bufp; 676 677 sprintf (buf, "%ld", x); 678 bufp = &buf[0]; 679 if (atof_generic (&bufp, ".", EXP_CHARS, &generic_floating_point_number)) 680 as_bad (_("Error converting number to floating point (Exponent overflow?)")); 681} 682#endif 683 684#ifdef TEST 685char * 686print_gen (gen) 687 FLONUM_TYPE *gen; 688{ 689 FLONUM_TYPE f; 690 LITTLENUM_TYPE arr[10]; 691 double dv; 692 float fv; 693 static char sbuf[40]; 694 695 if (gen) 696 { 697 f = generic_floating_point_number; 698 generic_floating_point_number = *gen; 699 } 700 gen_to_words (&arr[0], 4, 11); 701 memcpy (&dv, &arr[0], sizeof (double)); 702 sprintf (sbuf, "%x %x %x %x %.14G ", arr[0], arr[1], arr[2], arr[3], dv); 703 gen_to_words (&arr[0], 2, 8); 704 memcpy (&fv, &arr[0], sizeof (float)); 705 sprintf (sbuf + strlen (sbuf), "%x %x %.12g\n", arr[0], arr[1], fv); 706 707 if (gen) 708 { 709 generic_floating_point_number = f; 710 } 711 712 return (sbuf); 713} 714 715#endif 716 717/* end of atof-ieee.c */ 718