diff options
Diffstat (limited to 'gnu/usr.bin/as/atof-generic.c')
| -rw-r--r-- | gnu/usr.bin/as/atof-generic.c | 118 |
1 files changed, 59 insertions, 59 deletions
diff --git a/gnu/usr.bin/as/atof-generic.c b/gnu/usr.bin/as/atof-generic.c index b4e0971c8a7b..47a58b1409a4 100644 --- a/gnu/usr.bin/as/atof-generic.c +++ b/gnu/usr.bin/as/atof-generic.c @@ -1,24 +1,24 @@ /* atof_generic.c - turn a string of digits into a Flonum Copyright (C) 1987, 1990, 1991, 1992 Free Software Foundation, Inc. - + This file is part of GAS, the GNU Assembler. - + GAS is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. - + GAS is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. - + You should have received a copy of the GNU General Public License along with GAS; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ #ifndef lint -static char rcsid[] = "$Id: atof-generic.c,v 1.3 1993/10/02 20:57:17 pk Exp $"; +static char rcsid[] = "$Id: atof-generic.c,v 1.2 1993/11/03 00:51:14 paul Exp $"; #endif #include <ctype.h> @@ -54,14 +54,14 @@ static char rcsid[] = "$Id: atof-generic.c,v 1.3 1993/10/02 20:57:17 pk Exp $"; \***********************************************************************/ /* - + Syntax: - + <flonum> ::= <optional-sign> <decimal-number> <optional-exponent> <optional-sign> ::= '+' | '-' | {empty} <decimal-number> ::= <integer> - | <integer> <radix-character> - | <integer> <radix-character> <integer> + | <integer> <radix-character> + | <integer> <radix-character> <integer> | <radix-character> <integer> <optional-exponent> ::= {empty} @@ -71,7 +71,7 @@ static char rcsid[] = "$Id: atof-generic.c,v 1.3 1993/10/02 20:57:17 pk Exp $"; <digit> ::= '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' <exponent-character> ::= {one character from "string_of_decimal_exponent_marks"} <radix-character> ::= {one character from "string_of_decimal_marks"} - + */ int /* 0 if OK */ @@ -94,7 +94,7 @@ FLONUM_TYPE *address_of_generic_floating_point_number; long decimal_exponent; int number_of_digits_available; char digits_sign_char; - + /* * Scan the input string, abstracting (1)digits (2)decimal mark (3) exponent. * It would be simpler to modify the string, but we don't; just to be nice @@ -102,20 +102,20 @@ FLONUM_TYPE *address_of_generic_floating_point_number; * We need to know how many digits we have, so we can allocate space for * the digits' value. */ - + char *p; char c; int seen_significant_digit; - + first_digit = *address_of_string_pointer; c = *first_digit; - + if (c == '-' || c == '+') { digits_sign_char = c; first_digit++; } else digits_sign_char = '+'; - + if ((first_digit[0] == 'n' || first_digit[0] == 'N') && (first_digit[1] == 'a' || first_digit[1] == 'A') && (first_digit[2] == 'n' || first_digit[2] == 'N')) { @@ -126,9 +126,9 @@ FLONUM_TYPE *address_of_generic_floating_point_number; *address_of_string_pointer = first_digit + 3; return(0); } - + /* 99e999 is a "special" token to some older, broken compilers. */ - if ((first_digit[0] == 'i' || first_digit[0] == 'I') + if ((first_digit[0] == 'i' || first_digit[0] == 'I') && (first_digit[1] == 'n' || first_digit[1] == 'N') && (first_digit[2] == 'f' || first_digit[2] == 'F')) { address_of_generic_floating_point_number->sign = @@ -136,7 +136,7 @@ FLONUM_TYPE *address_of_generic_floating_point_number; address_of_generic_floating_point_number->exponent = 0; address_of_generic_floating_point_number->leader = address_of_generic_floating_point_number->low; - + if ((first_digit[3] == 'i' || first_digit[3] == 'I') && (first_digit[4] == 'n' || first_digit[4] == 'N') && (first_digit[5] == 'i' || first_digit[5] == 'I') @@ -148,7 +148,7 @@ FLONUM_TYPE *address_of_generic_floating_point_number; } return(0); } - + if (strncmp(first_digit, "99e999", 6) == 0) { address_of_generic_floating_point_number->sign = digits_sign_char == '+' ? 'P' : 'N'; @@ -178,7 +178,7 @@ FLONUM_TYPE *address_of_generic_floating_point_number; break; /* p -> char after pre-decimal digits. */ } } /* For each digit before decimal mark. */ - + #ifndef OLD_FLOAT_READS /* Ignore trailing 0's after the decimal point. The original code here * (ifdef'd out) does not do this, and numbers like @@ -188,7 +188,7 @@ FLONUM_TYPE *address_of_generic_floating_point_number; */ if (c && strchr(string_of_decimal_marks, c)) { int zeros = 0; /* Length of current string of zeros */ - + for (p++; (c = *p) && isdigit(c); p++) { if (c == '0') { zeros++; @@ -216,16 +216,16 @@ FLONUM_TYPE *address_of_generic_floating_point_number; } } /* For each digit after decimal mark. */ } - + while (number_of_digits_after_decimal && first_digit[number_of_digits_before_decimal + number_of_digits_after_decimal] == '0') --number_of_digits_after_decimal; /* last_digit = p; JF unused */ #endif - + if (c && strchr(string_of_decimal_exponent_marks, c) ) { char digits_exponent_sign_char; - + c = *++p; if (c && strchr ("+-",c)) { digits_exponent_sign_char = c; @@ -233,7 +233,7 @@ FLONUM_TYPE *address_of_generic_floating_point_number; } else { digits_exponent_sign_char = '+'; } - + for ( ; (c); c = *++p) { if (isdigit(c)) { decimal_exponent = decimal_exponent * 10 + c - '0'; @@ -244,16 +244,16 @@ FLONUM_TYPE *address_of_generic_floating_point_number; break; } } - + if (digits_exponent_sign_char == '-') { decimal_exponent = -decimal_exponent; } } - + *address_of_string_pointer = p; - + number_of_digits_available = number_of_digits_before_decimal + number_of_digits_after_decimal; return_value = 0; @@ -266,7 +266,7 @@ FLONUM_TYPE *address_of_generic_floating_point_number; } else { int count; /* Number of useful digits left to scan. */ - + LITTLENUM_TYPE *digits_binary_low; int precision; int maximum_useful_digits; @@ -277,33 +277,33 @@ FLONUM_TYPE *address_of_generic_floating_point_number; int size_of_digits_in_chars; FLONUM_TYPE power_of_10_flonum; FLONUM_TYPE digits_flonum; - + precision = (address_of_generic_floating_point_number->high - address_of_generic_floating_point_number->low + 1); /* Number of destination littlenums. */ - + /* Includes guard bits (two littlenums worth) */ maximum_useful_digits = (((double) (precision - 2)) * ((double) (LITTLENUM_NUMBER_OF_BITS)) / (LOG_TO_BASE_2_OF_10)) + 2; /* 2 :: guard digits. */ - + if (number_of_digits_available > maximum_useful_digits) { number_of_digits_to_use = maximum_useful_digits; } else { number_of_digits_to_use = number_of_digits_available; } - + decimal_exponent += number_of_digits_before_decimal - number_of_digits_to_use; - + more_than_enough_bits_for_digits = ((((double)number_of_digits_to_use) * LOG_TO_BASE_2_OF_10) + 1); - + more_than_enough_littlenums_for_digits = (more_than_enough_bits_for_digits / LITTLENUM_NUMBER_OF_BITS) + 2; - + /* * Compute (digits) part. In "12.34E56" this is the "1234" part. * Arithmetic is exact here. If no digits are supplied then @@ -313,18 +313,18 @@ FLONUM_TYPE *address_of_generic_floating_point_number; * Assume no alignment problems => (room for n objects) == * n * (room for 1 object). */ - + size_of_digits_in_littlenums = more_than_enough_littlenums_for_digits; size_of_digits_in_chars = size_of_digits_in_littlenums * sizeof(LITTLENUM_TYPE); - + digits_binary_low = (LITTLENUM_TYPE *) alloca(size_of_digits_in_chars); - + memset((char *)digits_binary_low, '\0', size_of_digits_in_chars); - + /* Digits_binary_low[] is allocated and zeroed. */ - + /* * Parse the decimal digits as if * digits_low was in the units position. * Emit a binary number into digits_binary_low[]. @@ -332,7 +332,7 @@ FLONUM_TYPE *address_of_generic_floating_point_number; * Use a large-precision version of: * (((1st-digit) * 10 + 2nd-digit) * 10 + 3rd-digit ...) * 10 + last-digit */ - + for (p = first_digit, count = number_of_digits_to_use; count; p++, --count) { c = *p; if (isdigit(c)) { @@ -340,11 +340,11 @@ FLONUM_TYPE *address_of_generic_floating_point_number; * Multiply by 10. Assume can never overflow. * Add this digit to digits_binary_low[]. */ - + long carry; LITTLENUM_TYPE *littlenum_pointer; LITTLENUM_TYPE *littlenum_limit; - + littlenum_limit = digits_binary_low + more_than_enough_littlenums_for_digits - 1; @@ -355,7 +355,7 @@ FLONUM_TYPE *address_of_generic_floating_point_number; littlenum_pointer <= littlenum_limit; littlenum_pointer++) { long work; - + work = carry + 10 * (long) (*littlenum_pointer); *littlenum_pointer = work & LITTLENUM_MASK; carry = work >> LITTLENUM_NUMBER_OF_BITS; @@ -372,8 +372,8 @@ FLONUM_TYPE *address_of_generic_floating_point_number; ++ count; /* '.' doesn't alter digits used count. */ } /* if valid digit */ } /* for each digit */ - - + + /* * Digits_binary_low[] properly encodes the value of the digits. * Forget about any high-order littlenums that are 0. @@ -381,7 +381,7 @@ FLONUM_TYPE *address_of_generic_floating_point_number; while (digits_binary_low[size_of_digits_in_littlenums - 1] == 0 && size_of_digits_in_littlenums >= 2) size_of_digits_in_littlenums--; - + digits_flonum.low = digits_binary_low; digits_flonum.high = digits_binary_low + size_of_digits_in_littlenums - 1; digits_flonum.leader = digits_flonum.high; @@ -399,14 +399,14 @@ FLONUM_TYPE *address_of_generic_floating_point_number; * input. */ digits_flonum.sign = '+'; - + { /* * Compute the mantssa (& exponent) of the power of 10. * If sucessful, then multiply the power of 10 by the digits * giving return_binary_mantissa and return_binary_exponent. */ - + LITTLENUM_TYPE *power_binary_low; int decimal_exponent_is_negative; /* This refers to the "-56" in "12.34E-56". */ @@ -416,17 +416,17 @@ FLONUM_TYPE *address_of_generic_floating_point_number; LITTLENUM_TYPE *temporary_binary_low; int size_of_power_in_littlenums; int size_of_power_in_chars; - + size_of_power_in_littlenums = precision; /* Precision has a built-in fudge factor so we get a few guard bits. */ - + decimal_exponent_is_negative = decimal_exponent < 0; if (decimal_exponent_is_negative) { decimal_exponent = -decimal_exponent; } /* From now on: the decimal exponent is > 0. Its sign is seperate. */ - + size_of_power_in_chars = size_of_power_in_littlenums * sizeof(LITTLENUM_TYPE) + 2; @@ -445,7 +445,7 @@ FLONUM_TYPE *address_of_generic_floating_point_number; * (power) == 1. * Space for temporary_flonum allocated. */ - + /* * ... * @@ -461,7 +461,7 @@ FLONUM_TYPE *address_of_generic_floating_point_number; /* flonum_XXXX_powers_of_ten[]. */ int place_number; const FLONUM_TYPE *multiplicand; /* -> 10^(2^n) */ - + place_number_limit = table_size_of_flonum_powers_of_ten; multiplicand = (decimal_exponent_is_negative @@ -505,20 +505,20 @@ FLONUM_TYPE *address_of_generic_floating_point_number; (void) putchar('\n'); #endif } - + } - + /* * power_of_10_flonum is power of ten in binary (mantissa) , (exponent). * It may be the number 1, in which case we don't NEED to multiply. * * Multiply (decimal digits) by power_of_10_flonum. */ - + flonum_multip(&power_of_10_flonum, &digits_flonum, address_of_generic_floating_point_number); /* Assert sign of the number we made is '+'. */ address_of_generic_floating_point_number->sign = digits_sign_char; - + } /* If we had any significant digits. */ return(return_value); } /* atof_generic () */ |