1 /* atof_generic.c - turn a string of digits into a Flonum
2 Copyright (C) 1987-2016 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
atof_generic(char ** address_of_string_pointer,const char * string_of_decimal_marks,const char * string_of_decimal_exponent_marks,FLONUM_TYPE * address_of_generic_floating_point_number)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 *temporary_binary_low = NULL;
309 LITTLENUM_TYPE *power_binary_low = NULL;
310 LITTLENUM_TYPE *digits_binary_low;
311 unsigned int precision;
312 unsigned int maximum_useful_digits;
313 unsigned int number_of_digits_to_use;
314 unsigned int more_than_enough_bits_for_digits;
315 unsigned int more_than_enough_littlenums_for_digits;
316 unsigned int size_of_digits_in_littlenums;
317 unsigned int size_of_digits_in_chars;
318 FLONUM_TYPE power_of_10_flonum;
319 FLONUM_TYPE digits_flonum;
320
321 precision = (address_of_generic_floating_point_number->high
322 - address_of_generic_floating_point_number->low
323 + 1); /* Number of destination littlenums. */
324
325 /* Includes guard bits (two littlenums worth) */
326 maximum_useful_digits = (((precision - 2))
327 * ( (LITTLENUM_NUMBER_OF_BITS))
328 * 1000000 / 3321928)
329 + 2; /* 2 :: guard digits. */
330
331 if (number_of_digits_available > maximum_useful_digits)
332 {
333 number_of_digits_to_use = maximum_useful_digits;
334 }
335 else
336 {
337 number_of_digits_to_use = number_of_digits_available;
338 }
339
340 /* Cast these to SIGNED LONG first, otherwise, on systems with
341 LONG wider than INT (such as Alpha OSF/1), unsignedness may
342 cause unexpected results. */
343 decimal_exponent += ((long) number_of_digits_before_decimal
344 - (long) number_of_digits_to_use);
345
346 more_than_enough_bits_for_digits
347 = (number_of_digits_to_use * 3321928 / 1000000 + 1);
348
349 more_than_enough_littlenums_for_digits
350 = (more_than_enough_bits_for_digits
351 / LITTLENUM_NUMBER_OF_BITS)
352 + 2;
353
354 /* Compute (digits) part. In "12.34E56" this is the "1234" part.
355 Arithmetic is exact here. If no digits are supplied then this
356 part is a 0 valued binary integer. Allocate room to build up
357 the binary number as littlenums. We want this memory to
358 disappear when we leave this function. Assume no alignment
359 problems => (room for n objects) == n * (room for 1
360 object). */
361
362 size_of_digits_in_littlenums = more_than_enough_littlenums_for_digits;
363 size_of_digits_in_chars = size_of_digits_in_littlenums
364 * sizeof (LITTLENUM_TYPE);
365
366 digits_binary_low = (LITTLENUM_TYPE *)
367 xmalloc (size_of_digits_in_chars);
368
369 memset ((char *) digits_binary_low, '\0', size_of_digits_in_chars);
370
371 /* Digits_binary_low[] is allocated and zeroed. */
372
373 /*
374 * Parse the decimal digits as if * digits_low was in the units position.
375 * Emit a binary number into digits_binary_low[].
376 *
377 * Use a large-precision version of:
378 * (((1st-digit) * 10 + 2nd-digit) * 10 + 3rd-digit ...) * 10 + last-digit
379 */
380
381 for (p = first_digit, count = number_of_digits_to_use; count; p++, --count)
382 {
383 c = *p;
384 if (ISDIGIT (c))
385 {
386 /*
387 * Multiply by 10. Assume can never overflow.
388 * Add this digit to digits_binary_low[].
389 */
390
391 long carry;
392 LITTLENUM_TYPE *littlenum_pointer;
393 LITTLENUM_TYPE *littlenum_limit;
394
395 littlenum_limit = digits_binary_low
396 + more_than_enough_littlenums_for_digits
397 - 1;
398
399 carry = c - '0'; /* char -> binary */
400
401 for (littlenum_pointer = digits_binary_low;
402 littlenum_pointer <= littlenum_limit;
403 littlenum_pointer++)
404 {
405 long work;
406
407 work = carry + 10 * (long) (*littlenum_pointer);
408 *littlenum_pointer = work & LITTLENUM_MASK;
409 carry = work >> LITTLENUM_NUMBER_OF_BITS;
410 }
411
412 if (carry != 0)
413 {
414 /*
415 * We have a GROSS internal error.
416 * This should never happen.
417 */
418 as_fatal (_("failed sanity check"));
419 }
420 }
421 else
422 {
423 ++count; /* '.' doesn't alter digits used count. */
424 }
425 }
426
427 /*
428 * Digits_binary_low[] properly encodes the value of the digits.
429 * Forget about any high-order littlenums that are 0.
430 */
431 while (digits_binary_low[size_of_digits_in_littlenums - 1] == 0
432 && size_of_digits_in_littlenums >= 2)
433 size_of_digits_in_littlenums--;
434
435 digits_flonum.low = digits_binary_low;
436 digits_flonum.high = digits_binary_low + size_of_digits_in_littlenums - 1;
437 digits_flonum.leader = digits_flonum.high;
438 digits_flonum.exponent = 0;
439 /*
440 * The value of digits_flonum . sign should not be important.
441 * We have already decided the output's sign.
442 * We trust that the sign won't influence the other parts of the number!
443 * So we give it a value for these reasons:
444 * (1) courtesy to humans reading/debugging
445 * these numbers so they don't get excited about strange values
446 * (2) in future there may be more meaning attached to sign,
447 * and what was
448 * harmless noise may become disruptive, ill-conditioned (or worse)
449 * input.
450 */
451 digits_flonum.sign = '+';
452
453 {
454 /*
455 * Compute the mantssa (& exponent) of the power of 10.
456 * If successful, then multiply the power of 10 by the digits
457 * giving return_binary_mantissa and return_binary_exponent.
458 */
459
460 int decimal_exponent_is_negative;
461 /* This refers to the "-56" in "12.34E-56". */
462 /* FALSE: decimal_exponent is positive (or 0) */
463 /* TRUE: decimal_exponent is negative */
464 FLONUM_TYPE temporary_flonum;
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 *) xmalloc (size_of_power_in_chars);
483 temporary_binary_low = (LITTLENUM_TYPE *) xmalloc (size_of_power_in_chars);
484
485 memset ((char *) power_binary_low, '\0', size_of_power_in_chars);
486 *power_binary_low = 1;
487 power_of_10_flonum.exponent = 0;
488 power_of_10_flonum.low = power_binary_low;
489 power_of_10_flonum.leader = power_binary_low;
490 power_of_10_flonum.high = power_binary_low + size_of_power_in_littlenums - 1;
491 power_of_10_flonum.sign = '+';
492 temporary_flonum.low = temporary_binary_low;
493 temporary_flonum.high = temporary_binary_low + size_of_power_in_littlenums - 1;
494 /*
495 * (power) == 1.
496 * Space for temporary_flonum allocated.
497 */
498
499 /*
500 * ...
501 *
502 * WHILE more bits
503 * DO find next bit (with place value)
504 * multiply into power mantissa
505 * OD
506 */
507 {
508 int place_number_limit;
509 /* Any 10^(2^n) whose "n" exceeds this */
510 /* value will fall off the end of */
511 /* flonum_XXXX_powers_of_ten[]. */
512 int place_number;
513 const FLONUM_TYPE *multiplicand; /* -> 10^(2^n) */
514
515 place_number_limit = table_size_of_flonum_powers_of_ten;
516
517 multiplicand = (decimal_exponent_is_negative
518 ? flonum_negative_powers_of_ten
519 : flonum_positive_powers_of_ten);
520
521 for (place_number = 1;/* Place value of this bit of exponent. */
522 decimal_exponent;/* Quit when no more 1 bits in exponent. */
523 decimal_exponent >>= 1, place_number++)
524 {
525 if (decimal_exponent & 1)
526 {
527 if (place_number > place_number_limit)
528 {
529 /* The decimal exponent has a magnitude so great
530 that our tables can't help us fragment it.
531 Although this routine is in error because it
532 can't imagine a number that big, signal an
533 error as if it is the user's fault for
534 presenting such a big number. */
535 return_value = ERROR_EXPONENT_OVERFLOW;
536 /* quit out of loop gracefully */
537 decimal_exponent = 0;
538 }
539 else
540 {
541 #ifdef TRACE
542 printf ("before multiply, place_number = %d., power_of_10_flonum:\n",
543 place_number);
544
545 flonum_print (&power_of_10_flonum);
546 (void) putchar ('\n');
547 #endif
548 #ifdef TRACE
549 printf ("multiplier:\n");
550 flonum_print (multiplicand + place_number);
551 (void) putchar ('\n');
552 #endif
553 flonum_multip (multiplicand + place_number,
554 &power_of_10_flonum, &temporary_flonum);
555 #ifdef TRACE
556 printf ("after multiply:\n");
557 flonum_print (&temporary_flonum);
558 (void) putchar ('\n');
559 #endif
560 flonum_copy (&temporary_flonum, &power_of_10_flonum);
561 #ifdef TRACE
562 printf ("after copy:\n");
563 flonum_print (&power_of_10_flonum);
564 (void) putchar ('\n');
565 #endif
566 } /* If this bit of decimal_exponent was computable.*/
567 } /* If this bit of decimal_exponent was set. */
568 } /* For each bit of binary representation of exponent */
569 #ifdef TRACE
570 printf ("after computing power_of_10_flonum:\n");
571 flonum_print (&power_of_10_flonum);
572 (void) putchar ('\n');
573 #endif
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 if (temporary_binary_low)
589 free (temporary_binary_low);
590 if (power_binary_low)
591 free (power_binary_low);
592 free (digits_binary_low);
593 }
594 return return_value;
595 }
596
597 #ifdef TRACE
598 static void
flonum_print(f)599 flonum_print (f)
600 const FLONUM_TYPE *f;
601 {
602 LITTLENUM_TYPE *lp;
603 char littlenum_format[10];
604 sprintf (littlenum_format, " %%0%dx", sizeof (LITTLENUM_TYPE) * 2);
605 #define print_littlenum(LP) (printf (littlenum_format, LP))
606 printf ("flonum @%p %c e%ld", f, f->sign, f->exponent);
607 if (f->low < f->high)
608 for (lp = f->high; lp >= f->low; lp--)
609 print_littlenum (*lp);
610 else
611 for (lp = f->low; lp <= f->high; lp++)
612 print_littlenum (*lp);
613 printf ("\n");
614 fflush (stdout);
615 }
616 #endif
617
618 /* end of atof_generic.c */
619