1 /* atof_generic.c - turn a string of digits into a Flonum 2 Copyright (C) 1987-2014 Free Software Foundation, Inc. 3 4 This file is part of GAS, the GNU Assembler. 5 6 GAS is free software; you can redistribute it and/or modify 7 it under the terms of the GNU General Public License as published by 8 the Free Software Foundation; either version 3, or (at your option) 9 any later version. 10 11 GAS is distributed in the hope that it will be useful, but WITHOUT 12 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY 13 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public 14 License for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with GAS; see the file COPYING. If not, write to the Free 18 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA 19 02110-1301, USA. */ 20 21 #include "as.h" 22 #include "safe-ctype.h" 23 24 #ifndef FALSE 25 #define FALSE (0) 26 #endif 27 #ifndef TRUE 28 #define TRUE (1) 29 #endif 30 31 #ifdef TRACE 32 static void flonum_print (const FLONUM_TYPE *); 33 #endif 34 35 #define ASSUME_DECIMAL_MARK_IS_DOT 36 37 /***********************************************************************\ 38 * * 39 * Given a string of decimal digits , with optional decimal * 40 * mark and optional decimal exponent (place value) of the * 41 * lowest_order decimal digit: produce a floating point * 42 * number. The number is 'generic' floating point: our * 43 * caller will encode it for a specific machine architecture. * 44 * * 45 * Assumptions * 46 * uses base (radix) 2 * 47 * this machine uses 2's complement binary integers * 48 * target flonums use " " " " * 49 * target flonums exponents fit in a long * 50 * * 51 \***********************************************************************/ 52 53 /* 54 55 Syntax: 56 57 <flonum> ::= <optional-sign> <decimal-number> <optional-exponent> 58 <optional-sign> ::= '+' | '-' | {empty} 59 <decimal-number> ::= <integer> 60 | <integer> <radix-character> 61 | <integer> <radix-character> <integer> 62 | <radix-character> <integer> 63 64 <optional-exponent> ::= {empty} 65 | <exponent-character> <optional-sign> <integer> 66 67 <integer> ::= <digit> | <digit> <integer> 68 <digit> ::= '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' 69 <exponent-character> ::= {one character from "string_of_decimal_exponent_marks"} 70 <radix-character> ::= {one character from "string_of_decimal_marks"} 71 72 */ 73 74 int 75 atof_generic (/* return pointer to just AFTER number we read. */ 76 char **address_of_string_pointer, 77 /* At most one per number. */ 78 const char *string_of_decimal_marks, 79 const char *string_of_decimal_exponent_marks, 80 FLONUM_TYPE *address_of_generic_floating_point_number) 81 { 82 int return_value; /* 0 means OK. */ 83 char *first_digit; 84 unsigned int number_of_digits_before_decimal; 85 unsigned int number_of_digits_after_decimal; 86 long decimal_exponent; 87 unsigned int number_of_digits_available; 88 char digits_sign_char; 89 90 /* 91 * Scan the input string, abstracting (1)digits (2)decimal mark (3) exponent. 92 * It would be simpler to modify the string, but we don't; just to be nice 93 * to caller. 94 * We need to know how many digits we have, so we can allocate space for 95 * the digits' value. 96 */ 97 98 char *p; 99 char c; 100 int seen_significant_digit; 101 102 #ifdef ASSUME_DECIMAL_MARK_IS_DOT 103 gas_assert (string_of_decimal_marks[0] == '.' 104 && string_of_decimal_marks[1] == 0); 105 #define IS_DECIMAL_MARK(c) ((c) == '.') 106 #else 107 #define IS_DECIMAL_MARK(c) (0 != strchr (string_of_decimal_marks, (c))) 108 #endif 109 110 first_digit = *address_of_string_pointer; 111 c = *first_digit; 112 113 if (c == '-' || c == '+') 114 { 115 digits_sign_char = c; 116 first_digit++; 117 } 118 else 119 digits_sign_char = '+'; 120 121 switch (first_digit[0]) 122 { 123 case 'n': 124 case 'N': 125 if (!strncasecmp ("nan", first_digit, 3)) 126 { 127 address_of_generic_floating_point_number->sign = 0; 128 address_of_generic_floating_point_number->exponent = 0; 129 address_of_generic_floating_point_number->leader = 130 address_of_generic_floating_point_number->low; 131 *address_of_string_pointer = first_digit + 3; 132 return 0; 133 } 134 break; 135 136 case 'i': 137 case 'I': 138 if (!strncasecmp ("inf", first_digit, 3)) 139 { 140 address_of_generic_floating_point_number->sign = 141 digits_sign_char == '+' ? 'P' : 'N'; 142 address_of_generic_floating_point_number->exponent = 0; 143 address_of_generic_floating_point_number->leader = 144 address_of_generic_floating_point_number->low; 145 146 first_digit += 3; 147 if (!strncasecmp ("inity", first_digit, 5)) 148 first_digit += 5; 149 150 *address_of_string_pointer = first_digit; 151 152 return 0; 153 } 154 break; 155 } 156 157 number_of_digits_before_decimal = 0; 158 number_of_digits_after_decimal = 0; 159 decimal_exponent = 0; 160 seen_significant_digit = 0; 161 for (p = first_digit; 162 (((c = *p) != '\0') 163 && (!c || !IS_DECIMAL_MARK (c)) 164 && (!c || !strchr (string_of_decimal_exponent_marks, c))); 165 p++) 166 { 167 if (ISDIGIT (c)) 168 { 169 if (seen_significant_digit || c > '0') 170 { 171 ++number_of_digits_before_decimal; 172 seen_significant_digit = 1; 173 } 174 else 175 { 176 first_digit++; 177 } 178 } 179 else 180 { 181 break; /* p -> char after pre-decimal digits. */ 182 } 183 } /* For each digit before decimal mark. */ 184 185 #ifndef OLD_FLOAT_READS 186 /* Ignore trailing 0's after the decimal point. The original code here 187 * (ifdef'd out) does not do this, and numbers like 188 * 4.29496729600000000000e+09 (2**31) 189 * come out inexact for some reason related to length of the digit 190 * string. 191 */ 192 if (c && IS_DECIMAL_MARK (c)) 193 { 194 unsigned int zeros = 0; /* Length of current string of zeros */ 195 196 for (p++; (c = *p) && ISDIGIT (c); p++) 197 { 198 if (c == '0') 199 { 200 zeros++; 201 } 202 else 203 { 204 number_of_digits_after_decimal += 1 + zeros; 205 zeros = 0; 206 } 207 } 208 } 209 #else 210 if (c && IS_DECIMAL_MARK (c)) 211 { 212 for (p++; 213 (((c = *p) != '\0') 214 && (!c || !strchr (string_of_decimal_exponent_marks, c))); 215 p++) 216 { 217 if (ISDIGIT (c)) 218 { 219 /* This may be retracted below. */ 220 number_of_digits_after_decimal++; 221 222 if ( /* seen_significant_digit || */ c > '0') 223 { 224 seen_significant_digit = TRUE; 225 } 226 } 227 else 228 { 229 if (!seen_significant_digit) 230 { 231 number_of_digits_after_decimal = 0; 232 } 233 break; 234 } 235 } /* For each digit after decimal mark. */ 236 } 237 238 while (number_of_digits_after_decimal 239 && first_digit[number_of_digits_before_decimal 240 + number_of_digits_after_decimal] == '0') 241 --number_of_digits_after_decimal; 242 #endif 243 244 if (flag_m68k_mri) 245 { 246 while (c == '_') 247 c = *++p; 248 } 249 if (c && strchr (string_of_decimal_exponent_marks, c)) 250 { 251 char digits_exponent_sign_char; 252 253 c = *++p; 254 if (flag_m68k_mri) 255 { 256 while (c == '_') 257 c = *++p; 258 } 259 if (c && strchr ("+-", c)) 260 { 261 digits_exponent_sign_char = c; 262 c = *++p; 263 } 264 else 265 { 266 digits_exponent_sign_char = '+'; 267 } 268 269 for (; (c); c = *++p) 270 { 271 if (ISDIGIT (c)) 272 { 273 decimal_exponent = decimal_exponent * 10 + c - '0'; 274 /* 275 * BUG! If we overflow here, we lose! 276 */ 277 } 278 else 279 { 280 break; 281 } 282 } 283 284 if (digits_exponent_sign_char == '-') 285 { 286 decimal_exponent = -decimal_exponent; 287 } 288 } 289 290 *address_of_string_pointer = p; 291 292 number_of_digits_available = 293 number_of_digits_before_decimal + number_of_digits_after_decimal; 294 return_value = 0; 295 if (number_of_digits_available == 0) 296 { 297 address_of_generic_floating_point_number->exponent = 0; /* Not strictly necessary */ 298 address_of_generic_floating_point_number->leader 299 = -1 + address_of_generic_floating_point_number->low; 300 address_of_generic_floating_point_number->sign = digits_sign_char; 301 /* We have just concocted (+/-)0.0E0 */ 302 303 } 304 else 305 { 306 int count; /* Number of useful digits left to scan. */ 307 308 LITTLENUM_TYPE *digits_binary_low; 309 unsigned int precision; 310 unsigned int maximum_useful_digits; 311 unsigned int number_of_digits_to_use; 312 unsigned int more_than_enough_bits_for_digits; 313 unsigned int more_than_enough_littlenums_for_digits; 314 unsigned int size_of_digits_in_littlenums; 315 unsigned int size_of_digits_in_chars; 316 FLONUM_TYPE power_of_10_flonum; 317 FLONUM_TYPE digits_flonum; 318 319 precision = (address_of_generic_floating_point_number->high 320 - address_of_generic_floating_point_number->low 321 + 1); /* Number of destination littlenums. */ 322 323 /* Includes guard bits (two littlenums worth) */ 324 maximum_useful_digits = (((precision - 2)) 325 * ( (LITTLENUM_NUMBER_OF_BITS)) 326 * 1000000 / 3321928) 327 + 2; /* 2 :: guard digits. */ 328 329 if (number_of_digits_available > maximum_useful_digits) 330 { 331 number_of_digits_to_use = maximum_useful_digits; 332 } 333 else 334 { 335 number_of_digits_to_use = number_of_digits_available; 336 } 337 338 /* Cast these to SIGNED LONG first, otherwise, on systems with 339 LONG wider than INT (such as Alpha OSF/1), unsignedness may 340 cause unexpected results. */ 341 decimal_exponent += ((long) number_of_digits_before_decimal 342 - (long) number_of_digits_to_use); 343 344 more_than_enough_bits_for_digits 345 = (number_of_digits_to_use * 3321928 / 1000000 + 1); 346 347 more_than_enough_littlenums_for_digits 348 = (more_than_enough_bits_for_digits 349 / LITTLENUM_NUMBER_OF_BITS) 350 + 2; 351 352 /* Compute (digits) part. In "12.34E56" this is the "1234" part. 353 Arithmetic is exact here. If no digits are supplied then this 354 part is a 0 valued binary integer. Allocate room to build up 355 the binary number as littlenums. We want this memory to 356 disappear when we leave this function. Assume no alignment 357 problems => (room for n objects) == n * (room for 1 358 object). */ 359 360 size_of_digits_in_littlenums = more_than_enough_littlenums_for_digits; 361 size_of_digits_in_chars = size_of_digits_in_littlenums 362 * sizeof (LITTLENUM_TYPE); 363 364 digits_binary_low = (LITTLENUM_TYPE *) 365 alloca (size_of_digits_in_chars); 366 367 memset ((char *) digits_binary_low, '\0', size_of_digits_in_chars); 368 369 /* Digits_binary_low[] is allocated and zeroed. */ 370 371 /* 372 * Parse the decimal digits as if * digits_low was in the units position. 373 * Emit a binary number into digits_binary_low[]. 374 * 375 * Use a large-precision version of: 376 * (((1st-digit) * 10 + 2nd-digit) * 10 + 3rd-digit ...) * 10 + last-digit 377 */ 378 379 for (p = first_digit, count = number_of_digits_to_use; count; p++, --count) 380 { 381 c = *p; 382 if (ISDIGIT (c)) 383 { 384 /* 385 * Multiply by 10. Assume can never overflow. 386 * Add this digit to digits_binary_low[]. 387 */ 388 389 long carry; 390 LITTLENUM_TYPE *littlenum_pointer; 391 LITTLENUM_TYPE *littlenum_limit; 392 393 littlenum_limit = digits_binary_low 394 + more_than_enough_littlenums_for_digits 395 - 1; 396 397 carry = c - '0'; /* char -> binary */ 398 399 for (littlenum_pointer = digits_binary_low; 400 littlenum_pointer <= littlenum_limit; 401 littlenum_pointer++) 402 { 403 long work; 404 405 work = carry + 10 * (long) (*littlenum_pointer); 406 *littlenum_pointer = work & LITTLENUM_MASK; 407 carry = work >> LITTLENUM_NUMBER_OF_BITS; 408 } 409 410 if (carry != 0) 411 { 412 /* 413 * We have a GROSS internal error. 414 * This should never happen. 415 */ 416 as_fatal (_("failed sanity check")); 417 } 418 } 419 else 420 { 421 ++count; /* '.' doesn't alter digits used count. */ 422 } 423 } 424 425 /* 426 * Digits_binary_low[] properly encodes the value of the digits. 427 * Forget about any high-order littlenums that are 0. 428 */ 429 while (digits_binary_low[size_of_digits_in_littlenums - 1] == 0 430 && size_of_digits_in_littlenums >= 2) 431 size_of_digits_in_littlenums--; 432 433 digits_flonum.low = digits_binary_low; 434 digits_flonum.high = digits_binary_low + size_of_digits_in_littlenums - 1; 435 digits_flonum.leader = digits_flonum.high; 436 digits_flonum.exponent = 0; 437 /* 438 * The value of digits_flonum . sign should not be important. 439 * We have already decided the output's sign. 440 * We trust that the sign won't influence the other parts of the number! 441 * So we give it a value for these reasons: 442 * (1) courtesy to humans reading/debugging 443 * these numbers so they don't get excited about strange values 444 * (2) in future there may be more meaning attached to sign, 445 * and what was 446 * harmless noise may become disruptive, ill-conditioned (or worse) 447 * input. 448 */ 449 digits_flonum.sign = '+'; 450 451 { 452 /* 453 * Compute the mantssa (& exponent) of the power of 10. 454 * If successful, then multiply the power of 10 by the digits 455 * giving return_binary_mantissa and return_binary_exponent. 456 */ 457 458 LITTLENUM_TYPE *power_binary_low; 459 int decimal_exponent_is_negative; 460 /* This refers to the "-56" in "12.34E-56". */ 461 /* FALSE: decimal_exponent is positive (or 0) */ 462 /* TRUE: decimal_exponent is negative */ 463 FLONUM_TYPE temporary_flonum; 464 LITTLENUM_TYPE *temporary_binary_low; 465 unsigned int size_of_power_in_littlenums; 466 unsigned int size_of_power_in_chars; 467 468 size_of_power_in_littlenums = precision; 469 /* Precision has a built-in fudge factor so we get a few guard bits. */ 470 471 decimal_exponent_is_negative = decimal_exponent < 0; 472 if (decimal_exponent_is_negative) 473 { 474 decimal_exponent = -decimal_exponent; 475 } 476 477 /* From now on: the decimal exponent is > 0. Its sign is separate. */ 478 479 size_of_power_in_chars = size_of_power_in_littlenums 480 * sizeof (LITTLENUM_TYPE) + 2; 481 482 power_binary_low = (LITTLENUM_TYPE *) alloca (size_of_power_in_chars); 483 temporary_binary_low = (LITTLENUM_TYPE *) alloca (size_of_power_in_chars); 484 memset ((char *) power_binary_low, '\0', size_of_power_in_chars); 485 *power_binary_low = 1; 486 power_of_10_flonum.exponent = 0; 487 power_of_10_flonum.low = power_binary_low; 488 power_of_10_flonum.leader = power_binary_low; 489 power_of_10_flonum.high = power_binary_low + size_of_power_in_littlenums - 1; 490 power_of_10_flonum.sign = '+'; 491 temporary_flonum.low = temporary_binary_low; 492 temporary_flonum.high = temporary_binary_low + size_of_power_in_littlenums - 1; 493 /* 494 * (power) == 1. 495 * Space for temporary_flonum allocated. 496 */ 497 498 /* 499 * ... 500 * 501 * WHILE more bits 502 * DO find next bit (with place value) 503 * multiply into power mantissa 504 * OD 505 */ 506 { 507 int place_number_limit; 508 /* Any 10^(2^n) whose "n" exceeds this */ 509 /* value will fall off the end of */ 510 /* flonum_XXXX_powers_of_ten[]. */ 511 int place_number; 512 const FLONUM_TYPE *multiplicand; /* -> 10^(2^n) */ 513 514 place_number_limit = table_size_of_flonum_powers_of_ten; 515 516 multiplicand = (decimal_exponent_is_negative 517 ? flonum_negative_powers_of_ten 518 : flonum_positive_powers_of_ten); 519 520 for (place_number = 1;/* Place value of this bit of exponent. */ 521 decimal_exponent;/* Quit when no more 1 bits in exponent. */ 522 decimal_exponent >>= 1, place_number++) 523 { 524 if (decimal_exponent & 1) 525 { 526 if (place_number > place_number_limit) 527 { 528 /* The decimal exponent has a magnitude so great 529 that our tables can't help us fragment it. 530 Although this routine is in error because it 531 can't imagine a number that big, signal an 532 error as if it is the user's fault for 533 presenting such a big number. */ 534 return_value = ERROR_EXPONENT_OVERFLOW; 535 /* quit out of loop gracefully */ 536 decimal_exponent = 0; 537 } 538 else 539 { 540 #ifdef TRACE 541 printf ("before multiply, place_number = %d., power_of_10_flonum:\n", 542 place_number); 543 544 flonum_print (&power_of_10_flonum); 545 (void) putchar ('\n'); 546 #endif 547 #ifdef TRACE 548 printf ("multiplier:\n"); 549 flonum_print (multiplicand + place_number); 550 (void) putchar ('\n'); 551 #endif 552 flonum_multip (multiplicand + place_number, 553 &power_of_10_flonum, &temporary_flonum); 554 #ifdef TRACE 555 printf ("after multiply:\n"); 556 flonum_print (&temporary_flonum); 557 (void) putchar ('\n'); 558 #endif 559 flonum_copy (&temporary_flonum, &power_of_10_flonum); 560 #ifdef TRACE 561 printf ("after copy:\n"); 562 flonum_print (&power_of_10_flonum); 563 (void) putchar ('\n'); 564 #endif 565 } /* If this bit of decimal_exponent was computable.*/ 566 } /* If this bit of decimal_exponent was set. */ 567 } /* For each bit of binary representation of exponent */ 568 #ifdef TRACE 569 printf ("after computing power_of_10_flonum:\n"); 570 flonum_print (&power_of_10_flonum); 571 (void) putchar ('\n'); 572 #endif 573 } 574 575 } 576 577 /* 578 * power_of_10_flonum is power of ten in binary (mantissa) , (exponent). 579 * It may be the number 1, in which case we don't NEED to multiply. 580 * 581 * Multiply (decimal digits) by power_of_10_flonum. 582 */ 583 584 flonum_multip (&power_of_10_flonum, &digits_flonum, address_of_generic_floating_point_number); 585 /* Assert sign of the number we made is '+'. */ 586 address_of_generic_floating_point_number->sign = digits_sign_char; 587 588 } 589 return return_value; 590 } 591 592 #ifdef TRACE 593 static void 594 flonum_print (f) 595 const FLONUM_TYPE *f; 596 { 597 LITTLENUM_TYPE *lp; 598 char littlenum_format[10]; 599 sprintf (littlenum_format, " %%0%dx", sizeof (LITTLENUM_TYPE) * 2); 600 #define print_littlenum(LP) (printf (littlenum_format, LP)) 601 printf ("flonum @%p %c e%ld", f, f->sign, f->exponent); 602 if (f->low < f->high) 603 for (lp = f->high; lp >= f->low; lp--) 604 print_littlenum (*lp); 605 else 606 for (lp = f->low; lp <= f->high; lp++) 607 print_littlenum (*lp); 608 printf ("\n"); 609 fflush (stdout); 610 } 611 #endif 612 613 /* end of atof_generic.c */ 614
