projects / deliverable / binutils-gdb.git / blob
? search:


42fcfa97a159ef57f8bf7e9c94f6093eee09bf30
[deliverable/binutils-gdb.git] / gas / atof-generic.c
1 /* atof_generic.c - turn a string of digits into a Flonum
2 Copyright (C) 1987, 1990, 1991 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 2, or (at your option)
9 any later version.
10
11 GAS is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public 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
18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
19
20 #include <ctype.h>
21 #include <string.h>
22
23 #include "as.h"
24
25 #ifdef __GNUC__
26 #define alloca __builtin_alloca
27 #else
28 #ifdef sparc
29 #include <alloca.h>
30 #endif
31 #endif
32
33 #ifdef USG
34 #define bzero(s,n) memset(s,0,n)
35 #endif
36
37 /* #define FALSE (0) */
38 /* #define TRUE (1) */
39
40 /***********************************************************************\
41 * *
42 * Given a string of decimal digits , with optional decimal *
43 * mark and optional decimal exponent (place value) of the *
44 * lowest_order decimal digit: produce a floating point *
45 * number. The number is 'generic' floating point: our *
46 * caller will encode it for a specific machine architecture. *
47 * *
48 * Assumptions *
49 * uses base (radix) 2 *
50 * this machine uses 2's complement binary integers *
51 * target flonums use " " " " *
52 * target flonums exponents fit in a long *
53 * *
54 \***********************************************************************/
55
56 /*
57
58 Syntax:
59
60 <flonum> ::= <optional-sign> <decimal-number> <optional-exponent>
61 <optional-sign> ::= '+' | '-' | {empty}
62 <decimal-number> ::= <integer>
63 | <integer> <radix-character>
64 | <integer> <radix-character> <integer>
65 | <radix-character> <integer>
66 <optional-exponent> ::= {empty} | <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"}
71
72 */
73 \f
74 int /* 0 if OK */
75 atof_generic (
76 address_of_string_pointer, /* return pointer to just AFTER number we read. */
77 string_of_decimal_marks, /* At most one per number. */
78 string_of_decimal_exponent_marks,
79 address_of_generic_floating_point_number)
80
81 char * * address_of_string_pointer;
82 const char * string_of_decimal_marks;
83 const char * string_of_decimal_exponent_marks;
84 FLONUM_TYPE * address_of_generic_floating_point_number;
85
86 {
87
88 int return_value; /* 0 means OK. */
89 char * first_digit;
90 /* char * last_digit; JF unused */
91 int number_of_digits_before_decimal;
92 int number_of_digits_after_decimal;
93 long decimal_exponent;
94 int number_of_digits_available;
95 char digits_sign_char;
96 \f
97 {
98 /*
99 * Scan the input string, abstracting (1)digits (2)decimal mark (3) exponent.
100 * It would be simpler to modify the string, but we don't; just to be nice
101 * to caller.
102 * We need to know how many digits we have, so we can allocate space for
103 * the digits' value.
104 */
105
106 char * p;
107 char c;
108 int seen_significant_digit;
109
110 first_digit = * address_of_string_pointer;
111 c= *first_digit;
112 if (c=='-' || c=='+')
113 {
114 digits_sign_char = c;
115 first_digit ++;
116 }
117 else
118 digits_sign_char = '+';
119
120 if( (first_digit[0]=='n' || first_digit[0]=='N')
121 && (first_digit[1]=='a' || first_digit[1]=='A')
122 && (first_digit[2]=='n' || first_digit[2]=='N')) {
123 address_of_generic_floating_point_number->sign=0;
124 address_of_generic_floating_point_number->exponent=0;
125 address_of_generic_floating_point_number->leader=address_of_generic_floating_point_number->low;
126 (*address_of_string_pointer)=first_digit+3;
127 return 0;
128 }
129 if( (first_digit[0]=='i' || first_digit[0]=='I')
130 && (first_digit[1]=='n' || first_digit[1]=='N')
131 && (first_digit[2]=='f' || first_digit[2]=='F')) {
132 address_of_generic_floating_point_number->sign= digits_sign_char=='+' ? 'P' : 'N';
133 address_of_generic_floating_point_number->exponent=0;
134 address_of_generic_floating_point_number->leader=address_of_generic_floating_point_number->low;
135 if( (first_digit[3]=='i' || first_digit[3]=='I')
136 && (first_digit[4]=='n' || first_digit[4]=='N')
137 && (first_digit[5]=='i' || first_digit[5]=='I')
138 && (first_digit[6]=='t' || first_digit[6]=='T')
139 && (first_digit[7]=='y' || first_digit[7]=='Y'))
140 (*address_of_string_pointer)=first_digit+8;
141 else
142 (*address_of_string_pointer)=first_digit+3;
143 return 0;
144 }
145
146 number_of_digits_before_decimal = 0;
147 number_of_digits_after_decimal = 0;
148 decimal_exponent = 0;
149 seen_significant_digit = 0;
150 for (p = first_digit;
151 ((c = * p) != '\0')
152 && (!c || ! strchr (string_of_decimal_marks, c) )
153 && (!c || ! strchr (string_of_decimal_exponent_marks, c) );
154 p ++)
155 {
156 if (isdigit(c))
157 {
158 if (seen_significant_digit || c > '0')
159 {
160 number_of_digits_before_decimal ++;
161 seen_significant_digit = 1;
162 }
163 else
164 {
165 first_digit++;
166 }
167 }
168 else
169 {
170 break; /* p -> char after pre-decimal digits. */
171 }
172 } /* For each digit before decimal mark. */
173
174 #ifndef OLD_FLOAT_READS
175 /* Ignore trailing 0's after the decimal point. The original code here
176 * (ifdef'd out) does not do this, and numbers like
177 * 4.29496729600000000000e+09 (2**31)
178 * come out inexact for some reason related to length of the digit
179 * string.
180 */
181 if ( c && strchr(string_of_decimal_marks,c) ){
182 int zeros = 0; /* Length of current string of zeros */
183
184 for ( p++; (c = *p) && isdigit(c); p++ ){
185 if ( c == '0'){
186 zeros++;
187 } else {
188 number_of_digits_after_decimal += 1 + zeros;
189 zeros = 0;
190 }
191 }
192 }
193 #else
194 if (c && strchr (string_of_decimal_marks, c))
195 {
196 for (p ++;
197 ((c = * p) != '\0')
198 && (!c || ! strchr (string_of_decimal_exponent_marks, c) );
199 p ++)
200 {
201 if (isdigit(c))
202 {
203 number_of_digits_after_decimal ++; /* This may be retracted below. */
204 if (/* seen_significant_digit || */ c > '0')
205 {
206 seen_significant_digit = TRUE;
207 }
208 }
209 else
210 {
211 if ( ! seen_significant_digit)
212 {
213 number_of_digits_after_decimal = 0;
214 }
215 break;
216 }
217 } /* For each digit after decimal mark. */
218 }
219 while(number_of_digits_after_decimal && first_digit[number_of_digits_before_decimal+number_of_digits_after_decimal]=='0')
220 --number_of_digits_after_decimal;
221 /* last_digit = p; JF unused */
222 #endif
223
224 if (c && strchr (string_of_decimal_exponent_marks, c) )
225 {
226 char digits_exponent_sign_char;
227
228 c = * ++ p;
229 if (c && strchr ("+-",c))
230 {
231 digits_exponent_sign_char = c;
232 c = * ++ p;
233 }
234 else
235 {
236 digits_exponent_sign_char = '+';
237 }
238 for (;
239 (c);
240 c = * ++ p)
241 {
242 if (isdigit(c))
243 {
244 decimal_exponent = decimal_exponent * 10 + c - '0';
245 /*
246 * BUG! If we overflow here, we lose!
247 */
248 }
249 else
250 {
251 break;
252 }
253 }
254 if (digits_exponent_sign_char == '-')
255 {
256 decimal_exponent = - decimal_exponent;
257 }
258 }
259 * address_of_string_pointer = p;
260 }
261 \f
262 number_of_digits_available =
263 number_of_digits_before_decimal
264 + number_of_digits_after_decimal;
265 return_value = 0;
266 if (number_of_digits_available == 0)
267 {
268 address_of_generic_floating_point_number -> exponent = 0; /* Not strictly necessary */
269 address_of_generic_floating_point_number -> leader
270 = -1 + address_of_generic_floating_point_number -> low;
271 address_of_generic_floating_point_number -> sign = digits_sign_char;
272 /* We have just concocted (+/-)0.0E0 */
273 }
274 else
275 {
276 LITTLENUM_TYPE * digits_binary_low;
277 int precision;
278 int maximum_useful_digits;
279 int number_of_digits_to_use;
280 int more_than_enough_bits_for_digits;
281 int more_than_enough_littlenums_for_digits;
282 int size_of_digits_in_littlenums;
283 int size_of_digits_in_chars;
284 FLONUM_TYPE power_of_10_flonum;
285 FLONUM_TYPE digits_flonum;
286
287
288 precision = (address_of_generic_floating_point_number -> high
289 - address_of_generic_floating_point_number -> low
290 + 1
291 ); /* Number of destination littlenums. */
292 /* Includes guard bits (two littlenums worth) */
293 maximum_useful_digits = ( ((double) (precision - 2))
294 * ((double) (LITTLENUM_NUMBER_OF_BITS))
295 / (LOG_TO_BASE_2_OF_10)
296 )
297 + 2; /* 2 :: guard digits. */
298 if (number_of_digits_available > maximum_useful_digits)
299 {
300 number_of_digits_to_use = maximum_useful_digits;
301 }
302 else
303 {
304 number_of_digits_to_use = number_of_digits_available;
305 }
306 decimal_exponent += number_of_digits_before_decimal - number_of_digits_to_use;
307
308 more_than_enough_bits_for_digits
309 = ((((double)number_of_digits_to_use) * LOG_TO_BASE_2_OF_10) + 1);
310 more_than_enough_littlenums_for_digits
311 = ( more_than_enough_bits_for_digits
312 / LITTLENUM_NUMBER_OF_BITS
313 )
314 + 2;
315
316 /*
317 * Compute (digits) part. In "12.34E56" this is the "1234" part.
318 * Arithmetic is exact here. If no digits are supplied then
319 * this part is a 0 valued binary integer.
320 * Allocate room to build up the binary number as littlenums.
321 * We want this memory to disappear when we leave this function.
322 * Assume no alignment problems => (room for n objects) ==
323 * n * (room for 1 object).
324 */
325
326 size_of_digits_in_littlenums = more_than_enough_littlenums_for_digits;
327 size_of_digits_in_chars = size_of_digits_in_littlenums
328 * sizeof( LITTLENUM_TYPE );
329 digits_binary_low = (LITTLENUM_TYPE *)
330 alloca (size_of_digits_in_chars);
331 bzero ((char *)digits_binary_low, size_of_digits_in_chars);
332
333 /* Digits_binary_low[] is allocated and zeroed. */
334
335 {
336 /*
337 * Parse the decimal digits as if * digits_low was in the units position.
338 * Emit a binary number into digits_binary_low[].
339 *
340 * Use a large-precision version of:
341 * (((1st-digit) * 10 + 2nd-digit) * 10 + 3rd-digit ...) * 10 + last-digit
342 */
343
344 char * p;
345 char c;
346 int count; /* Number of useful digits left to scan. */
347
348 for (p = first_digit, count = number_of_digits_to_use;
349 count;
350 p ++, -- count)
351 {
352 c = * p;
353 if (isdigit(c))
354 {
355 /*
356 * Multiply by 10. Assume can never overflow.
357 * Add this digit to digits_binary_low[].
358 */
359
360 long carry;
361 LITTLENUM_TYPE * littlenum_pointer;
362 LITTLENUM_TYPE * littlenum_limit;
363
364 littlenum_limit
365 = digits_binary_low
366 + more_than_enough_littlenums_for_digits
367 - 1;
368 carry = c - '0'; /* char -> binary */
369 for (littlenum_pointer = digits_binary_low;
370 littlenum_pointer <= littlenum_limit;
371 littlenum_pointer ++)
372 {
373 long work;
374
375 work = carry + 10 * (long)(*littlenum_pointer);
376 * littlenum_pointer = work & LITTLENUM_MASK;
377 carry = work >> LITTLENUM_NUMBER_OF_BITS;
378 }
379 if (carry != 0)
380 {
381 /*
382 * We have a GROSS internal error.
383 * This should never happen.
384 */
385 as_fatal("failed sanity check."); /* RMS prefers abort() to any message. */
386 }
387 }
388 else
389 {
390 ++ count; /* '.' doesn't alter digits used count. */
391 } /* if valid digit */
392 } /* for each digit */
393 }
394
395 /*
396 * Digits_binary_low[] properly encodes the value of the digits.
397 * Forget about any high-order littlenums that are 0.
398 */
399 while (digits_binary_low [size_of_digits_in_littlenums - 1] == 0
400 && size_of_digits_in_littlenums >= 2)
401 size_of_digits_in_littlenums --;
402
403 digits_flonum . low = digits_binary_low;
404 digits_flonum . high = digits_binary_low + size_of_digits_in_littlenums - 1;
405 digits_flonum . leader = digits_flonum . high;
406 digits_flonum . exponent = 0;
407 /*
408 * The value of digits_flonum . sign should not be important.
409 * We have already decided the output's sign.
410 * We trust that the sign won't influence the other parts of the number!
411 * So we give it a value for these reasons:
412 * (1) courtesy to humans reading/debugging
413 * these numbers so they don't get excited about strange values
414 * (2) in future there may be more meaning attached to sign,
415 * and what was
416 * harmless noise may become disruptive, ill-conditioned (or worse)
417 * input.
418 */
419 digits_flonum . sign = '+';
420
421 {
422 /*
423 * Compute the mantssa (& exponent) of the power of 10.
424 * If sucessful, then multiply the power of 10 by the digits
425 * giving return_binary_mantissa and return_binary_exponent.
426 */
427
428 LITTLENUM_TYPE *power_binary_low;
429 int decimal_exponent_is_negative;
430 /* This refers to the "-56" in "12.34E-56". */
431 /* FALSE: decimal_exponent is positive (or 0) */
432 /* TRUE: decimal_exponent is negative */
433 FLONUM_TYPE temporary_flonum;
434 LITTLENUM_TYPE *temporary_binary_low;
435 int size_of_power_in_littlenums;
436 int size_of_power_in_chars;
437
438 size_of_power_in_littlenums = precision;
439 /* Precision has a built-in fudge factor so we get a few guard bits. */
440
441
442 decimal_exponent_is_negative = decimal_exponent < 0;
443 if (decimal_exponent_is_negative)
444 {
445 decimal_exponent = - decimal_exponent;
446 }
447 /* From now on: the decimal exponent is > 0. Its sign is seperate. */
448
449 size_of_power_in_chars
450 = size_of_power_in_littlenums
451 * sizeof( LITTLENUM_TYPE ) + 2;
452 power_binary_low = (LITTLENUM_TYPE *) alloca ( size_of_power_in_chars );
453 temporary_binary_low = (LITTLENUM_TYPE *) alloca ( size_of_power_in_chars );
454 bzero ((char *)power_binary_low, size_of_power_in_chars);
455 * power_binary_low = 1;
456 power_of_10_flonum . exponent = 0;
457 power_of_10_flonum . low = power_binary_low;
458 power_of_10_flonum . leader = power_binary_low;
459 power_of_10_flonum . high = power_binary_low + size_of_power_in_littlenums - 1;
460 power_of_10_flonum . sign = '+';
461 temporary_flonum . low = temporary_binary_low;
462 temporary_flonum . high = temporary_binary_low + size_of_power_in_littlenums - 1;
463 /*
464 * (power) == 1.
465 * Space for temporary_flonum allocated.
466 */
467
468 /*
469 * ...
470 *
471 * WHILE more bits
472 * DO find next bit (with place value)
473 * multiply into power mantissa
474 * OD
475 */
476 {
477 int place_number_limit;
478 /* Any 10^(2^n) whose "n" exceeds this */
479 /* value will fall off the end of */
480 /* flonum_XXXX_powers_of_ten[]. */
481 int place_number;
482 const FLONUM_TYPE * multiplicand; /* -> 10^(2^n) */
483
484 place_number_limit = table_size_of_flonum_powers_of_ten;
485 multiplicand
486 = ( decimal_exponent_is_negative
487 ? flonum_negative_powers_of_ten
488 : flonum_positive_powers_of_ten);
489 for (place_number = 1; /* Place value of this bit of exponent. */
490 decimal_exponent; /* Quit when no more 1 bits in exponent. */
491 decimal_exponent >>= 1
492 , place_number ++)
493 {
494 if (decimal_exponent & 1)
495 {
496 if (place_number > place_number_limit)
497 {
498 /*
499 * The decimal exponent has a magnitude so great that
500 * our tables can't help us fragment it. Although this
501 * routine is in error because it can't imagine a
502 * number that big, signal an error as if it is the
503 * user's fault for presenting such a big number.
504 */
505 return_value = ERROR_EXPONENT_OVERFLOW;
506 /*
507 * quit out of loop gracefully
508 */
509 decimal_exponent = 0;
510 }
511 else
512 {
513 #ifdef TRACE
514 printf("before multiply, place_number = %d., power_of_10_flonum:\n", place_number);
515 flonum_print( & power_of_10_flonum );
516 (void)putchar('\n');
517 #endif
518 flonum_multip(multiplicand + place_number, &power_of_10_flonum, &temporary_flonum);
519 flonum_copy (& temporary_flonum, & power_of_10_flonum);
520 } /* If this bit of decimal_exponent was computable.*/
521 } /* If this bit of decimal_exponent was set. */
522 } /* For each bit of binary representation of exponent */
523 #ifdef TRACE
524 printf( " after computing power_of_10_flonum: " );
525 flonum_print( & power_of_10_flonum );
526 (void)putchar('\n');
527 #endif
528 }
529
530 }
531
532 /*
533 * power_of_10_flonum is power of ten in binary (mantissa) , (exponent).
534 * It may be the number 1, in which case we don't NEED to multiply.
535 *
536 * Multiply (decimal digits) by power_of_10_flonum.
537 */
538
539 flonum_multip (& power_of_10_flonum, & digits_flonum, address_of_generic_floating_point_number);
540 /* Assert sign of the number we made is '+'. */
541 address_of_generic_floating_point_number -> sign = digits_sign_char;
542
543 } /* If we had any significant digits. */
544 return (return_value);
545 } /* atof_generic () */
546
547 /* end of atof_generic.c */
GDB Binutils - Deliverables
This page took 0.06294 seconds and 3 git commands to generate.