1 /* atof_generic.c - turn a string of digits into a Flonum
2 Copyright (C) 1987-2019 Free Software Foundation, Inc.
4 This file is part of GAS, the GNU Assembler.
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)
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.
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
22 #include "safe-ctype.h"
32 static void flonum_print (const FLONUM_TYPE *);
35 #define ASSUME_DECIMAL_MARK_IS_DOT
37 /***********************************************************************\
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. *
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 *
51 \***********************************************************************/
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>
64 <optional-exponent> ::= {empty}
65 | <exponent-character> <optional-sign> <integer>
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"}
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)
82 int return_value; /* 0 means OK. */
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;
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
94 * We need to know how many digits we have, so we can allocate space for
100 int seen_significant_digit;
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) == '.')
107 #define IS_DECIMAL_MARK(c) (0 != strchr (string_of_decimal_marks, (c)))
110 first_digit = *address_of_string_pointer;
113 if (c == '-' || c == '+')
115 digits_sign_char = c;
119 digits_sign_char = '+';
121 switch (first_digit[0])
125 if (!strncasecmp ("nan", first_digit, 3))
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;
138 if (!strncasecmp ("inf", first_digit, 3))
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;
147 if (!strncasecmp ("inity", first_digit, 5))
150 *address_of_string_pointer = first_digit;
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;
163 && (!c || !IS_DECIMAL_MARK (c))
164 && (!c || !strchr (string_of_decimal_exponent_marks, c)));
169 if (seen_significant_digit || c > '0')
171 ++number_of_digits_before_decimal;
172 seen_significant_digit = 1;
181 break; /* p -> char after pre-decimal digits. */
183 } /* For each digit before decimal mark. */
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
192 /* The case number_of_digits_before_decimal = 0 is handled for
193 deleting zeros after decimal. In this case the decimal mark and
194 the first zero digits after decimal mark are skipped. */
195 seen_significant_digit = 0;
196 signed long subtract_decimal_exponent = 0;
198 if (c && IS_DECIMAL_MARK (c))
200 unsigned int zeros = 0; /* Length of current string of zeros. */
202 if (number_of_digits_before_decimal == 0)
203 /* Skip decimal mark. */
206 for (p++; (c = *p) && ISDIGIT (c); p++)
210 if (number_of_digits_before_decimal == 0
211 && !seen_significant_digit)
213 /* Skip '0' and the decimal mark. */
215 subtract_decimal_exponent--;
222 seen_significant_digit = 1;
223 number_of_digits_after_decimal += 1 + zeros;
229 if (c && IS_DECIMAL_MARK (c))
233 && (!c || !strchr (string_of_decimal_exponent_marks, c)));
238 /* This may be retracted below. */
239 number_of_digits_after_decimal++;
241 if ( /* seen_significant_digit || */ c > '0')
243 seen_significant_digit = TRUE;
248 if (!seen_significant_digit)
250 number_of_digits_after_decimal = 0;
254 } /* For each digit after decimal mark. */
257 while (number_of_digits_after_decimal
258 && first_digit[number_of_digits_before_decimal
259 + number_of_digits_after_decimal] == '0')
260 --number_of_digits_after_decimal;
268 if (c && strchr (string_of_decimal_exponent_marks, c))
270 char digits_exponent_sign_char;
278 if (c && strchr ("+-", c))
280 digits_exponent_sign_char = c;
285 digits_exponent_sign_char = '+';
288 for (; (c); c = *++p)
292 decimal_exponent = decimal_exponent * 10 + c - '0';
294 * BUG! If we overflow here, we lose!
303 if (digits_exponent_sign_char == '-')
305 decimal_exponent = -decimal_exponent;
309 #ifndef OLD_FLOAT_READS
310 /* Subtract_decimal_exponent != 0 when number_of_digits_before_decimal = 0
311 and first digit after decimal is '0'. */
312 decimal_exponent += subtract_decimal_exponent;
315 *address_of_string_pointer = p;
317 number_of_digits_available =
318 number_of_digits_before_decimal + number_of_digits_after_decimal;
320 if (number_of_digits_available == 0)
322 address_of_generic_floating_point_number->exponent = 0; /* Not strictly necessary */
323 address_of_generic_floating_point_number->leader
324 = -1 + address_of_generic_floating_point_number->low;
325 address_of_generic_floating_point_number->sign = digits_sign_char;
326 /* We have just concocted (+/-)0.0E0 */
331 int count; /* Number of useful digits left to scan. */
333 LITTLENUM_TYPE *temporary_binary_low = NULL;
334 LITTLENUM_TYPE *power_binary_low = NULL;
335 LITTLENUM_TYPE *digits_binary_low;
336 unsigned int precision;
337 unsigned int maximum_useful_digits;
338 unsigned int number_of_digits_to_use;
339 unsigned int more_than_enough_bits_for_digits;
340 unsigned int more_than_enough_littlenums_for_digits;
341 unsigned int size_of_digits_in_littlenums;
342 unsigned int size_of_digits_in_chars;
343 FLONUM_TYPE power_of_10_flonum;
344 FLONUM_TYPE digits_flonum;
346 precision = (address_of_generic_floating_point_number->high
347 - address_of_generic_floating_point_number->low
348 + 1); /* Number of destination littlenums. */
350 /* Includes guard bits (two littlenums worth) */
351 maximum_useful_digits = (((precision - 2))
352 * ( (LITTLENUM_NUMBER_OF_BITS))
354 + 2; /* 2 :: guard digits. */
356 if (number_of_digits_available > maximum_useful_digits)
358 number_of_digits_to_use = maximum_useful_digits;
362 number_of_digits_to_use = number_of_digits_available;
365 /* Cast these to SIGNED LONG first, otherwise, on systems with
366 LONG wider than INT (such as Alpha OSF/1), unsignedness may
367 cause unexpected results. */
368 decimal_exponent += ((long) number_of_digits_before_decimal
369 - (long) number_of_digits_to_use);
371 more_than_enough_bits_for_digits
372 = (number_of_digits_to_use * 3321928 / 1000000 + 1);
374 more_than_enough_littlenums_for_digits
375 = (more_than_enough_bits_for_digits
376 / LITTLENUM_NUMBER_OF_BITS)
379 /* Compute (digits) part. In "12.34E56" this is the "1234" part.
380 Arithmetic is exact here. If no digits are supplied then this
381 part is a 0 valued binary integer. Allocate room to build up
382 the binary number as littlenums. We want this memory to
383 disappear when we leave this function. Assume no alignment
384 problems => (room for n objects) == n * (room for 1
387 size_of_digits_in_littlenums = more_than_enough_littlenums_for_digits;
388 size_of_digits_in_chars = size_of_digits_in_littlenums
389 * sizeof (LITTLENUM_TYPE);
391 digits_binary_low = (LITTLENUM_TYPE *)
392 xmalloc (size_of_digits_in_chars);
394 memset ((char *) digits_binary_low, '\0', size_of_digits_in_chars);
396 /* Digits_binary_low[] is allocated and zeroed. */
399 * Parse the decimal digits as if * digits_low was in the units position.
400 * Emit a binary number into digits_binary_low[].
402 * Use a large-precision version of:
403 * (((1st-digit) * 10 + 2nd-digit) * 10 + 3rd-digit ...) * 10 + last-digit
406 for (p = first_digit, count = number_of_digits_to_use; count; p++, --count)
412 * Multiply by 10. Assume can never overflow.
413 * Add this digit to digits_binary_low[].
417 LITTLENUM_TYPE *littlenum_pointer;
418 LITTLENUM_TYPE *littlenum_limit;
420 littlenum_limit = digits_binary_low
421 + more_than_enough_littlenums_for_digits
424 carry = c - '0'; /* char -> binary */
426 for (littlenum_pointer = digits_binary_low;
427 littlenum_pointer <= littlenum_limit;
432 work = carry + 10 * (long) (*littlenum_pointer);
433 *littlenum_pointer = work & LITTLENUM_MASK;
434 carry = work >> LITTLENUM_NUMBER_OF_BITS;
440 * We have a GROSS internal error.
441 * This should never happen.
443 as_fatal (_("failed sanity check"));
448 ++count; /* '.' doesn't alter digits used count. */
453 * Digits_binary_low[] properly encodes the value of the digits.
454 * Forget about any high-order littlenums that are 0.
456 while (digits_binary_low[size_of_digits_in_littlenums - 1] == 0
457 && size_of_digits_in_littlenums >= 2)
458 size_of_digits_in_littlenums--;
460 digits_flonum.low = digits_binary_low;
461 digits_flonum.high = digits_binary_low + size_of_digits_in_littlenums - 1;
462 digits_flonum.leader = digits_flonum.high;
463 digits_flonum.exponent = 0;
465 * The value of digits_flonum . sign should not be important.
466 * We have already decided the output's sign.
467 * We trust that the sign won't influence the other parts of the number!
468 * So we give it a value for these reasons:
469 * (1) courtesy to humans reading/debugging
470 * these numbers so they don't get excited about strange values
471 * (2) in future there may be more meaning attached to sign,
473 * harmless noise may become disruptive, ill-conditioned (or worse)
476 digits_flonum.sign = '+';
480 * Compute the mantissa (& exponent) of the power of 10.
481 * If successful, then multiply the power of 10 by the digits
482 * giving return_binary_mantissa and return_binary_exponent.
485 int decimal_exponent_is_negative;
486 /* This refers to the "-56" in "12.34E-56". */
487 /* FALSE: decimal_exponent is positive (or 0) */
488 /* TRUE: decimal_exponent is negative */
489 FLONUM_TYPE temporary_flonum;
490 unsigned int size_of_power_in_littlenums;
491 unsigned int size_of_power_in_chars;
493 size_of_power_in_littlenums = precision;
494 /* Precision has a built-in fudge factor so we get a few guard bits. */
496 decimal_exponent_is_negative = decimal_exponent < 0;
497 if (decimal_exponent_is_negative)
499 decimal_exponent = -decimal_exponent;
502 /* From now on: the decimal exponent is > 0. Its sign is separate. */
504 size_of_power_in_chars = size_of_power_in_littlenums
505 * sizeof (LITTLENUM_TYPE) + 2;
507 power_binary_low = (LITTLENUM_TYPE *) xmalloc (size_of_power_in_chars);
508 temporary_binary_low = (LITTLENUM_TYPE *) xmalloc (size_of_power_in_chars);
510 memset ((char *) power_binary_low, '\0', size_of_power_in_chars);
511 *power_binary_low = 1;
512 power_of_10_flonum.exponent = 0;
513 power_of_10_flonum.low = power_binary_low;
514 power_of_10_flonum.leader = power_binary_low;
515 power_of_10_flonum.high = power_binary_low + size_of_power_in_littlenums - 1;
516 power_of_10_flonum.sign = '+';
517 temporary_flonum.low = temporary_binary_low;
518 temporary_flonum.high = temporary_binary_low + size_of_power_in_littlenums - 1;
521 * Space for temporary_flonum allocated.
528 * DO find next bit (with place value)
529 * multiply into power mantissa
533 int place_number_limit;
534 /* Any 10^(2^n) whose "n" exceeds this */
535 /* value will fall off the end of */
536 /* flonum_XXXX_powers_of_ten[]. */
538 const FLONUM_TYPE *multiplicand; /* -> 10^(2^n) */
540 place_number_limit = table_size_of_flonum_powers_of_ten;
542 multiplicand = (decimal_exponent_is_negative
543 ? flonum_negative_powers_of_ten
544 : flonum_positive_powers_of_ten);
546 for (place_number = 1;/* Place value of this bit of exponent. */
547 decimal_exponent;/* Quit when no more 1 bits in exponent. */
548 decimal_exponent >>= 1, place_number++)
550 if (decimal_exponent & 1)
552 if (place_number > place_number_limit)
554 /* The decimal exponent has a magnitude so great
555 that our tables can't help us fragment it.
556 Although this routine is in error because it
557 can't imagine a number that big, signal an
558 error as if it is the user's fault for
559 presenting such a big number. */
560 return_value = ERROR_EXPONENT_OVERFLOW;
561 /* quit out of loop gracefully */
562 decimal_exponent = 0;
567 printf ("before multiply, place_number = %d., power_of_10_flonum:\n",
570 flonum_print (&power_of_10_flonum);
571 (void) putchar ('\n');
574 printf ("multiplier:\n");
575 flonum_print (multiplicand + place_number);
576 (void) putchar ('\n');
578 flonum_multip (multiplicand + place_number,
579 &power_of_10_flonum, &temporary_flonum);
581 printf ("after multiply:\n");
582 flonum_print (&temporary_flonum);
583 (void) putchar ('\n');
585 flonum_copy (&temporary_flonum, &power_of_10_flonum);
587 printf ("after copy:\n");
588 flonum_print (&power_of_10_flonum);
589 (void) putchar ('\n');
591 } /* If this bit of decimal_exponent was computable.*/
592 } /* If this bit of decimal_exponent was set. */
593 } /* For each bit of binary representation of exponent */
595 printf ("after computing power_of_10_flonum:\n");
596 flonum_print (&power_of_10_flonum);
597 (void) putchar ('\n');
603 * power_of_10_flonum is power of ten in binary (mantissa) , (exponent).
604 * It may be the number 1, in which case we don't NEED to multiply.
606 * Multiply (decimal digits) by power_of_10_flonum.
609 flonum_multip (&power_of_10_flonum, &digits_flonum, address_of_generic_floating_point_number);
610 /* Assert sign of the number we made is '+'. */
611 address_of_generic_floating_point_number->sign = digits_sign_char;
613 if (temporary_binary_low)
614 free (temporary_binary_low);
615 if (power_binary_low)
616 free (power_binary_low);
617 free (digits_binary_low);
625 const FLONUM_TYPE *f;
628 char littlenum_format[10];
629 sprintf (littlenum_format, " %%0%dx", sizeof (LITTLENUM_TYPE) * 2);
630 #define print_littlenum(LP) (printf (littlenum_format, LP))
631 printf ("flonum @%p %c e%ld", f, f->sign, f->exponent);
632 if (f->low < f->high)
633 for (lp = f->high; lp >= f->low; lp--)
634 print_littlenum (*lp);
636 for (lp = f->low; lp <= f->high; lp++)
637 print_littlenum (*lp);
643 /* end of atof_generic.c */