/* atof_generic.c - turn a string of digits into a Flonum
Copyright (C) 1987 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 1, or (at your option)
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. */
#define alloca __builtin_alloca
#define bzero(s,n) memset(s,0,n)
/***********************************************************************\
* Given a string of decimal digits , with optional decimal *
* mark and optional decimal exponent (place value) of the *
* lowest_order decimal digit: produce a floating point *
* number. The number is 'generic' floating point: our *
* caller will encode it for a specific machine architecture. *
* this machine uses 2's complement binary integers *
* target flonums use " " " " *
* target flonums exponents fit in a long int *
\***********************************************************************/
<flonum> ::= <optional-sign> <decimal-number> <optional-exponent>
<optional-sign> ::= '+' | '-' | {empty}
<decimal-number> ::= <integer>
| <integer> <radix-character>
| <integer> <radix-character> <integer>
| <radix-character> <integer>
<optional-exponent> ::= {empty} | <exponent-character> <optional-sign> <integer>
<integer> ::= <digit> | <digit> <integer>
<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"}
address_of_string_pointer
, /* return pointer to just AFTER number we read. */
string_of_decimal_marks
, /* At most one per number. */
string_of_decimal_exponent_marks
,
address_of_generic_floating_point_number
)
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
;
int return_value
; /* 0 means OK. */
/* char * last_digit; JF unused */
int number_of_digits_before_decimal
;
int number_of_digits_after_decimal
;
long int decimal_exponent
;
int number_of_digits_available
;
* 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
* We need to know how many digits we have, so we can allocate space for
int seen_significant_digit
;
first_digit
= * address_of_string_pointer
;
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')) {
address_of_generic_floating_point_number
->sign
=0;
address_of_generic_floating_point_number
->exponent
=0;
address_of_generic_floating_point_number
->leader
=address_of_generic_floating_point_number
->low
;
(*address_of_string_pointer
)=first_digit
+3;
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
= digits_sign_char
=='+' ? 'P' : 'N';
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')
&& (first_digit
[6]=='t' || first_digit
[6]=='T')
&& (first_digit
[7]=='y' || first_digit
[7]=='Y'))
(*address_of_string_pointer
)=first_digit
+8;
(*address_of_string_pointer
)=first_digit
+3;
number_of_digits_before_decimal
= 0;
number_of_digits_after_decimal
= 0;
seen_significant_digit
= FALSE
;
&& (!c
|| ! index (string_of_decimal_marks
, c
) )
&& (!c
|| ! index (string_of_decimal_exponent_marks
, c
) );
if (seen_significant_digit
|| c
> '0')
number_of_digits_before_decimal
++;
seen_significant_digit
= TRUE
;
break; /* p -> char after pre-decimal digits. */
} /* For each digit before decimal mark. */
if (c
&& index (string_of_decimal_marks
, c
))
&& (!c
|| ! index (string_of_decimal_exponent_marks
, c
) );
number_of_digits_after_decimal
++; /* This may be retracted below. */
if (/* seen_significant_digit || */ c
> '0')
seen_significant_digit
= TRUE
;
if ( ! seen_significant_digit
)
number_of_digits_after_decimal
= 0;
} /* 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 */
if (c
&& index (string_of_decimal_exponent_marks
, c
) )
char digits_exponent_sign_char
;
digits_exponent_sign_char
= c
;
digits_exponent_sign_char
= '+';
decimal_exponent
= decimal_exponent
* 10 + c
- '0';
* BUG! If we overflow here, we lose!
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
;
if (number_of_digits_available
== 0)
address_of_generic_floating_point_number
-> exponent
= 0; /* Not strictly necessary */
address_of_generic_floating_point_number
-> leader
= -1 + address_of_generic_floating_point_number
-> low
;
address_of_generic_floating_point_number
-> sign
= digits_sign_char
;
/* We have just concocted (+/-)0.0E0 */
LITTLENUM_TYPE
* digits_binary_low
;
int maximum_useful_digits
;
int number_of_digits_to_use
;
int more_than_enough_bits_for_digits
;
int more_than_enough_littlenums_for_digits
;
int size_of_digits_in_littlenums
;
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
); /* Number of destination littlenums. */
/* Includes guard bits (two littlenums worth) */
maximum_useful_digits
= ( ((double) (precision
- 2))
* ((double) (LITTLENUM_NUMBER_OF_BITS
))
+ 2; /* 2 :: guard digits. */
if (number_of_digits_available
> maximum_useful_digits
)
number_of_digits_to_use
= maximum_useful_digits
;
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
* Compute (digits) part. In "12.34E56" this is the "1234" part.
* Arithmetic is exact here. If no digits are supplied then
* this part is a 0 valued binary integer.
* Allocate room to build up the binary number as littlenums.
* We want this memory to disappear when we leave this function.
* 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
);
bzero ((char *)digits_binary_low
, 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[].
* Use a large-precision version of:
* (((1st-digit) * 10 + 2nd-digit) * 10 + 3rd-digit ...) * 10 + last-digit
int count
; /* Number of useful digits left to scan. */
for (p
= first_digit
, count
= number_of_digits_to_use
;
* Multiply by 10. Assume can never overflow.
* Add this digit to digits_binary_low[].
LITTLENUM_TYPE
* littlenum_pointer
;
LITTLENUM_TYPE
* littlenum_limit
;
+ more_than_enough_littlenums_for_digits
carry
= c
- '0'; /* char -> binary */
for (littlenum_pointer
= digits_binary_low
;
littlenum_pointer
<= littlenum_limit
;
work
= carry
+ 10 * (long)(*littlenum_pointer
);
* littlenum_pointer
= work
& LITTLENUM_MASK
;
carry
= work
>> LITTLENUM_NUMBER_OF_BITS
;
* We have a GROSS internal error.
* This should never happen.
abort(); /* RMS prefers abort() to any message. */
++ count
; /* '.' doesn't alter digits used count. */
* Digits_binary_low[] properly encodes the value of the digits.
* Forget about any high-order littlenums that are 0.
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
;
digits_flonum
. exponent
= 0;
* The value of digits_flonum . sign should not be important.
* We have already decided the output's sign.
* We trust that the sign won't influence the other parts of the number!
* So we give it a value for these reasons:
* (1) courtesy to humans reading/debugging
* these numbers so they don't get excited about strange values
* (2) in future there may be more meaning attached to sign,
* harmless noise may become disruptive, ill-conditioned (or worse)
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". */
/* FALSE: decimal_exponent is positive (or 0) */
/* TRUE: decimal_exponent is negative */
FLONUM_TYPE temporary_flonum
;
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_littlenums
* sizeof( LITTLENUM_TYPE
) + 2;
power_binary_low
= (LITTLENUM_TYPE
*) alloca ( size_of_power_in_chars
);
temporary_binary_low
= (LITTLENUM_TYPE
*) alloca ( size_of_power_in_chars
);
bzero ((char *)power_binary_low
, size_of_power_in_chars
);
power_of_10_flonum
. exponent
= 0;
power_of_10_flonum
. low
= power_binary_low
;
power_of_10_flonum
. leader
= power_binary_low
;
power_of_10_flonum
. high
= power_binary_low
+ size_of_power_in_littlenums
- 1;
power_of_10_flonum
. sign
= '+';
temporary_flonum
. low
= temporary_binary_low
;
temporary_flonum
. high
= temporary_binary_low
+ size_of_power_in_littlenums
- 1;
* Space for temporary_flonum allocated.
* DO find next bit (with place value)
* multiply into power mantissa
/* Any 10^(2^n) whose "n" exceeds this */
/* value will fall off the end of */
/* flonum_XXXX_powers_of_ten[]. */
const FLONUM_TYPE
* multiplicand
; /* -> 10^(2^n) */
place_number_limit
= table_size_of_flonum_powers_of_ten
;
= ( decimal_exponent_is_negative
? flonum_negative_powers_of_ten
: flonum_positive_powers_of_ten
);
for (place_number
= 1; /* Place value of this bit of exponent. */
decimal_exponent
; /* Quit when no more 1 bits in exponent. */
if (decimal_exponent
& 1)
if (place_number
> place_number_limit
)
* The decimal exponent has a magnitude so great that
* our tables can't help us fragment it. Although this
* routine is in error because it can't imagine a
* number that big, signal an error as if it is the
* user's fault for presenting such a big number.
return_value
= ERROR_EXPONENT_OVERFLOW
;
* quit out of loop gracefully
printf("before multiply, place_number = %d., power_of_10_flonum:\n", place_number
);
flonum_print( & power_of_10_flonum
);
flonum_multip (multiplicand
+ place_number
, & power_of_10_flonum
, & temporary_flonum
);
flonum_copy (& temporary_flonum
, & power_of_10_flonum
);
} /* If this bit of decimal_exponent was computable.*/
} /* If this bit of decimal_exponent was set. */
} /* For each bit of binary representation of exponent */
printf( " after computing power_of_10_flonum: " );
flonum_print( & power_of_10_flonum
);
* 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. */
/* end: atof_generic.c */