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