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