1 /* atof_generic.c - turn a string of digits into a Flonum
2 Copyright (C) 1987, 90, 91, 92, 93, 94, 95, 96, 1998
3 Free Software Foundation, Inc.
5 This file is part of GAS, the GNU Assembler.
7 GAS is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GAS is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GAS; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
34 static void flonum_print PARAMS ((const FLONUM_TYPE *));
37 #define ASSUME_DECIMAL_MARK_IS_DOT
39 /***********************************************************************\
41 * Given a string of decimal digits , with optional decimal *
42 * mark and optional decimal exponent (place value) of the *
43 * lowest_order decimal digit: produce a floating point *
44 * number. The number is 'generic' floating point: our *
45 * caller will encode it for a specific machine architecture. *
48 * uses base (radix) 2 *
49 * this machine uses 2's complement binary integers *
50 * target flonums use " " " " *
51 * target flonums exponents fit in a long *
53 \***********************************************************************/
59 <flonum> ::= <optional-sign> <decimal-number> <optional-exponent>
60 <optional-sign> ::= '+' | '-' | {empty}
61 <decimal-number> ::= <integer>
62 | <integer> <radix-character>
63 | <integer> <radix-character> <integer>
64 | <radix-character> <integer>
66 <optional-exponent> ::= {empty}
67 | <exponent-character> <optional-sign> <integer>
69 <integer> ::= <digit> | <digit> <integer>
70 <digit> ::= '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9'
71 <exponent-character> ::= {one character from "string_of_decimal_exponent_marks"}
72 <radix-character> ::= {one character from "string_of_decimal_marks"}
77 atof_generic (address_of_string_pointer,
78 string_of_decimal_marks,
79 string_of_decimal_exponent_marks,
80 address_of_generic_floating_point_number)
81 /* return pointer to just AFTER number we read. */
82 char **address_of_string_pointer;
83 /* At most one per number. */
84 const char *string_of_decimal_marks;
85 const char *string_of_decimal_exponent_marks;
86 FLONUM_TYPE *address_of_generic_floating_point_number;
88 int return_value; /* 0 means OK. */
90 unsigned int number_of_digits_before_decimal;
91 unsigned int number_of_digits_after_decimal;
92 long decimal_exponent;
93 unsigned int number_of_digits_available;
94 char digits_sign_char;
97 * Scan the input string, abstracting (1)digits (2)decimal mark (3) exponent.
98 * It would be simpler to modify the string, but we don't; just to be nice
100 * We need to know how many digits we have, so we can allocate space for
106 int seen_significant_digit;
108 #ifdef ASSUME_DECIMAL_MARK_IS_DOT
109 assert (string_of_decimal_marks[0] == '.'
110 && string_of_decimal_marks[1] == 0);
111 #define IS_DECIMAL_MARK(c) ((c) == '.')
113 #define IS_DECIMAL_MARK(c) (0 != strchr (string_of_decimal_marks, (c)))
116 first_digit = *address_of_string_pointer;
119 if (c == '-' || c == '+')
121 digits_sign_char = c;
125 digits_sign_char = '+';
127 switch (first_digit[0])
131 if (!strncasecmp ("nan", first_digit, 3))
133 address_of_generic_floating_point_number->sign = 0;
134 address_of_generic_floating_point_number->exponent = 0;
135 address_of_generic_floating_point_number->leader =
136 address_of_generic_floating_point_number->low;
137 *address_of_string_pointer = first_digit + 3;
144 if (!strncasecmp ("inf", first_digit, 3))
146 address_of_generic_floating_point_number->sign =
147 digits_sign_char == '+' ? 'P' : 'N';
148 address_of_generic_floating_point_number->exponent = 0;
149 address_of_generic_floating_point_number->leader =
150 address_of_generic_floating_point_number->low;
153 if (!strncasecmp ("inity", first_digit, 5))
156 *address_of_string_pointer = first_digit;
163 number_of_digits_before_decimal = 0;
164 number_of_digits_after_decimal = 0;
165 decimal_exponent = 0;
166 seen_significant_digit = 0;
167 for (p = first_digit;
169 && (!c || !IS_DECIMAL_MARK (c))
170 && (!c || !strchr (string_of_decimal_exponent_marks, c)));
173 if (isdigit ((unsigned char) c))
175 if (seen_significant_digit || c > '0')
177 ++number_of_digits_before_decimal;
178 seen_significant_digit = 1;
187 break; /* p -> char after pre-decimal digits. */
189 } /* For each digit before decimal mark. */
191 #ifndef OLD_FLOAT_READS
192 /* Ignore trailing 0's after the decimal point. The original code here
193 * (ifdef'd out) does not do this, and numbers like
194 * 4.29496729600000000000e+09 (2**31)
195 * come out inexact for some reason related to length of the digit
198 if (c && IS_DECIMAL_MARK (c))
200 unsigned int zeros = 0; /* Length of current string of zeros */
202 for (p++; (c = *p) && isdigit ((unsigned char) c); p++)
210 number_of_digits_after_decimal += 1 + zeros;
216 if (c && IS_DECIMAL_MARK (c))
220 && (!c || !strchr (string_of_decimal_exponent_marks, c)));
225 /* This may be retracted below. */
226 number_of_digits_after_decimal++;
228 if ( /* seen_significant_digit || */ c > '0')
230 seen_significant_digit = TRUE;
235 if (!seen_significant_digit)
237 number_of_digits_after_decimal = 0;
241 } /* For each digit after decimal mark. */
244 while (number_of_digits_after_decimal
245 && first_digit[number_of_digits_before_decimal
246 + number_of_digits_after_decimal] == '0')
247 --number_of_digits_after_decimal;
255 if (c && strchr (string_of_decimal_exponent_marks, c))
257 char digits_exponent_sign_char;
265 if (c && strchr ("+-", c))
267 digits_exponent_sign_char = c;
272 digits_exponent_sign_char = '+';
275 for (; (c); c = *++p)
277 if (isdigit ((unsigned char) c))
279 decimal_exponent = decimal_exponent * 10 + c - '0';
281 * BUG! If we overflow here, we lose!
290 if (digits_exponent_sign_char == '-')
292 decimal_exponent = -decimal_exponent;
296 *address_of_string_pointer = p;
300 number_of_digits_available =
301 number_of_digits_before_decimal + number_of_digits_after_decimal;
303 if (number_of_digits_available == 0)
305 address_of_generic_floating_point_number->exponent = 0; /* Not strictly necessary */
306 address_of_generic_floating_point_number->leader
307 = -1 + address_of_generic_floating_point_number->low;
308 address_of_generic_floating_point_number->sign = digits_sign_char;
309 /* We have just concocted (+/-)0.0E0 */
314 int count; /* Number of useful digits left to scan. */
316 LITTLENUM_TYPE *digits_binary_low;
317 unsigned int precision;
318 unsigned int maximum_useful_digits;
319 unsigned int number_of_digits_to_use;
320 unsigned int more_than_enough_bits_for_digits;
321 unsigned int more_than_enough_littlenums_for_digits;
322 unsigned int size_of_digits_in_littlenums;
323 unsigned int size_of_digits_in_chars;
324 FLONUM_TYPE power_of_10_flonum;
325 FLONUM_TYPE digits_flonum;
327 precision = (address_of_generic_floating_point_number->high
328 - address_of_generic_floating_point_number->low
329 + 1); /* Number of destination littlenums. */
331 /* Includes guard bits (two littlenums worth) */
332 #if 0 /* The integer version below is very close, and it doesn't
333 require floating point support (which is currently buggy on
335 maximum_useful_digits = (((double) (precision - 2))
336 * ((double) (LITTLENUM_NUMBER_OF_BITS))
337 / (LOG_TO_BASE_2_OF_10))
338 + 2; /* 2 :: guard digits. */
340 maximum_useful_digits = (((precision - 2))
341 * ( (LITTLENUM_NUMBER_OF_BITS))
343 + 2; /* 2 :: guard digits. */
346 if (number_of_digits_available > maximum_useful_digits)
348 number_of_digits_to_use = maximum_useful_digits;
352 number_of_digits_to_use = number_of_digits_available;
355 /* Cast these to SIGNED LONG first, otherwise, on systems with
356 LONG wider than INT (such as Alpha OSF/1), unsignedness may
357 cause unexpected results. */
358 decimal_exponent += ((long) number_of_digits_before_decimal
359 - (long) number_of_digits_to_use);
362 more_than_enough_bits_for_digits
363 = ((((double) number_of_digits_to_use) * LOG_TO_BASE_2_OF_10) + 1);
365 more_than_enough_bits_for_digits
366 = (number_of_digits_to_use * 3321928 / 1000000 + 1);
369 more_than_enough_littlenums_for_digits
370 = (more_than_enough_bits_for_digits
371 / LITTLENUM_NUMBER_OF_BITS)
374 /* Compute (digits) part. In "12.34E56" this is the "1234" part.
375 Arithmetic is exact here. If no digits are supplied then this
376 part is a 0 valued binary integer. Allocate room to build up
377 the binary number as littlenums. We want this memory to
378 disappear when we leave this function. Assume no alignment
379 problems => (room for n objects) == n * (room for 1
382 size_of_digits_in_littlenums = more_than_enough_littlenums_for_digits;
383 size_of_digits_in_chars = size_of_digits_in_littlenums
384 * sizeof (LITTLENUM_TYPE);
386 digits_binary_low = (LITTLENUM_TYPE *)
387 alloca (size_of_digits_in_chars);
389 memset ((char *) digits_binary_low, '\0', size_of_digits_in_chars);
391 /* Digits_binary_low[] is allocated and zeroed. */
394 * Parse the decimal digits as if * digits_low was in the units position.
395 * Emit a binary number into digits_binary_low[].
397 * Use a large-precision version of:
398 * (((1st-digit) * 10 + 2nd-digit) * 10 + 3rd-digit ...) * 10 + last-digit
401 for (p = first_digit, count = number_of_digits_to_use; count; p++, --count)
404 if (isdigit ((unsigned char) c))
407 * Multiply by 10. Assume can never overflow.
408 * Add this digit to digits_binary_low[].
412 LITTLENUM_TYPE *littlenum_pointer;
413 LITTLENUM_TYPE *littlenum_limit;
415 littlenum_limit = digits_binary_low
416 + more_than_enough_littlenums_for_digits
419 carry = c - '0'; /* char -> binary */
421 for (littlenum_pointer = digits_binary_low;
422 littlenum_pointer <= littlenum_limit;
427 work = carry + 10 * (long) (*littlenum_pointer);
428 *littlenum_pointer = work & LITTLENUM_MASK;
429 carry = work >> LITTLENUM_NUMBER_OF_BITS;
435 * We have a GROSS internal error.
436 * This should never happen.
438 as_fatal ("failed sanity check.");
443 ++count; /* '.' doesn't alter digits used count. */
449 * Digits_binary_low[] properly encodes the value of the digits.
450 * Forget about any high-order littlenums that are 0.
452 while (digits_binary_low[size_of_digits_in_littlenums - 1] == 0
453 && size_of_digits_in_littlenums >= 2)
454 size_of_digits_in_littlenums--;
456 digits_flonum.low = digits_binary_low;
457 digits_flonum.high = digits_binary_low + size_of_digits_in_littlenums - 1;
458 digits_flonum.leader = digits_flonum.high;
459 digits_flonum.exponent = 0;
461 * The value of digits_flonum . sign should not be important.
462 * We have already decided the output's sign.
463 * We trust that the sign won't influence the other parts of the number!
464 * So we give it a value for these reasons:
465 * (1) courtesy to humans reading/debugging
466 * these numbers so they don't get excited about strange values
467 * (2) in future there may be more meaning attached to sign,
469 * harmless noise may become disruptive, ill-conditioned (or worse)
472 digits_flonum.sign = '+';
476 * Compute the mantssa (& exponent) of the power of 10.
477 * If sucessful, then multiply the power of 10 by the digits
478 * giving return_binary_mantissa and return_binary_exponent.
481 LITTLENUM_TYPE *power_binary_low;
482 int decimal_exponent_is_negative;
483 /* This refers to the "-56" in "12.34E-56". */
484 /* FALSE: decimal_exponent is positive (or 0) */
485 /* TRUE: decimal_exponent is negative */
486 FLONUM_TYPE temporary_flonum;
487 LITTLENUM_TYPE *temporary_binary_low;
488 unsigned int size_of_power_in_littlenums;
489 unsigned int size_of_power_in_chars;
491 size_of_power_in_littlenums = precision;
492 /* Precision has a built-in fudge factor so we get a few guard bits. */
494 decimal_exponent_is_negative = decimal_exponent < 0;
495 if (decimal_exponent_is_negative)
497 decimal_exponent = -decimal_exponent;
500 /* From now on: the decimal exponent is > 0. Its sign is separate. */
502 size_of_power_in_chars = size_of_power_in_littlenums
503 * sizeof (LITTLENUM_TYPE) + 2;
505 power_binary_low = (LITTLENUM_TYPE *) alloca (size_of_power_in_chars);
506 temporary_binary_low = (LITTLENUM_TYPE *) alloca (size_of_power_in_chars);
507 memset ((char *) power_binary_low, '\0', size_of_power_in_chars);
508 *power_binary_low = 1;
509 power_of_10_flonum.exponent = 0;
510 power_of_10_flonum.low = power_binary_low;
511 power_of_10_flonum.leader = power_binary_low;
512 power_of_10_flonum.high = power_binary_low + size_of_power_in_littlenums - 1;
513 power_of_10_flonum.sign = '+';
514 temporary_flonum.low = temporary_binary_low;
515 temporary_flonum.high = temporary_binary_low + size_of_power_in_littlenums - 1;
518 * Space for temporary_flonum allocated.
525 * DO find next bit (with place value)
526 * multiply into power mantissa
530 int place_number_limit;
531 /* Any 10^(2^n) whose "n" exceeds this */
532 /* value will fall off the end of */
533 /* flonum_XXXX_powers_of_ten[]. */
535 const FLONUM_TYPE *multiplicand; /* -> 10^(2^n) */
537 place_number_limit = table_size_of_flonum_powers_of_ten;
539 multiplicand = (decimal_exponent_is_negative
540 ? flonum_negative_powers_of_ten
541 : flonum_positive_powers_of_ten);
543 for (place_number = 1;/* Place value of this bit of exponent. */
544 decimal_exponent;/* Quit when no more 1 bits in exponent. */
545 decimal_exponent >>= 1, place_number++)
547 if (decimal_exponent & 1)
549 if (place_number > place_number_limit)
551 /* The decimal exponent has a magnitude so great
552 that our tables can't help us fragment it.
553 Although this routine is in error because it
554 can't imagine a number that big, signal an
555 error as if it is the user's fault for
556 presenting such a big number. */
557 return_value = ERROR_EXPONENT_OVERFLOW;
558 /* quit out of loop gracefully */
559 decimal_exponent = 0;
564 printf ("before multiply, place_number = %d., power_of_10_flonum:\n",
567 flonum_print (&power_of_10_flonum);
568 (void) putchar ('\n');
571 printf ("multiplier:\n");
572 flonum_print (multiplicand + place_number);
573 (void) putchar ('\n');
575 flonum_multip (multiplicand + place_number,
576 &power_of_10_flonum, &temporary_flonum);
578 printf ("after multiply:\n");
579 flonum_print (&temporary_flonum);
580 (void) putchar ('\n');
582 flonum_copy (&temporary_flonum, &power_of_10_flonum);
584 printf ("after copy:\n");
585 flonum_print (&power_of_10_flonum);
586 (void) putchar ('\n');
588 } /* If this bit of decimal_exponent was computable.*/
589 } /* If this bit of decimal_exponent was set. */
590 } /* For each bit of binary representation of exponent */
592 printf ("after computing power_of_10_flonum:\n");
593 flonum_print (&power_of_10_flonum);
594 (void) putchar ('\n');
601 * power_of_10_flonum is power of ten in binary (mantissa) , (exponent).
602 * It may be the number 1, in which case we don't NEED to multiply.
604 * Multiply (decimal digits) by power_of_10_flonum.
607 flonum_multip (&power_of_10_flonum, &digits_flonum, address_of_generic_floating_point_number);
608 /* Assert sign of the number we made is '+'. */
609 address_of_generic_floating_point_number->sign = digits_sign_char;
618 const FLONUM_TYPE *f;
621 char littlenum_format[10];
622 sprintf (littlenum_format, " %%0%dx", sizeof (LITTLENUM_TYPE) * 2);
623 #define print_littlenum(LP) (printf (littlenum_format, LP))
624 printf ("flonum @%p %c e%ld", f, f->sign, f->exponent);
625 if (f->low < f->high)
626 for (lp = f->high; lp >= f->low; lp--)
627 print_littlenum (*lp);
629 for (lp = f->low; lp <= f->high; lp++)
630 print_littlenum (*lp);
636 /* end of atof_generic.c */