White space and comment changes. #ifdef __STDC__ becomes #if __STDC__

== 1.  Get the declarations right in listing.[hc].

1 files changed, 430 insertions, 457 deletions

diff --git a/gas/atof-generic.c b/gas/atof-generic.c
index 42fcfa9..198e980 100644
--- a/gas/atof-generic.c
+++ b/gas/atof-generic.c
@@ -1,5 +1,5 @@
 /* atof_generic.c - turn a string of digits into a Flonum
-   Copyright (C) 1987, 1990, 1991 Free Software Foundation, Inc.
+   Copyright (C) 1987, 1990, 1991, 1992 Free Software Foundation, Inc.
    
    This file is part of GAS, the GNU Assembler.
    
@@ -34,7 +34,7 @@
 #define bzero(s,n) memset(s,0,n)
 #endif
 
-/* #define	FALSE (0) */
+/* #define FALSE (0) */
 /* #define TRUE  (1) */
 
 /***********************************************************************\
@@ -57,491 +57,464 @@
   
   Syntax:
   
-  <flonum>		::=	<optional-sign> <decimal-number> <optional-exponent>
-  <optional-sign>		::=	'+' | '-' | {empty}
-  <decimal-number>	::=	  <integer>
+  <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"}
+  | <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"}
   
   */
-
+
 int				/* 0 if OK */
     atof_generic (
-		  address_of_string_pointer, /* return pointer to just AFTER number we read. */
+		  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;
-
+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 * first_digit;
+	/* char *last_digit; JF unused */
+	int number_of_digits_before_decimal;
+	int number_of_digits_after_decimal;
+	long decimal_exponent;
+	int number_of_digits_available;
+	char digits_sign_char;
 	
-	int			return_value; /* 0 means OK. */
-	char *		first_digit;
-	/* char *		last_digit; JF unused */
-	int			number_of_digits_before_decimal;
-	int			number_of_digits_after_decimal;
-	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
-		 * to caller.
-		 * 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 = '+';
+	/*
+	 * 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
+	 * to caller.
+	 * 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')) {
+		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;
+		return(0);
+	}
+	
+	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[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;
-			return 0;
+		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;
+		} else {
+			*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;
-			else
-			    (*address_of_string_pointer)=first_digit+3;
-			return 0;
+		return(0);
+	}
+	
+	number_of_digits_before_decimal = 0;
+	number_of_digits_after_decimal = 0;
+	decimal_exponent = 0;
+	seen_significant_digit = 0;
+	for (p = first_digit; (((c = * p) != '\0')
+			       && (!c || ! strchr(string_of_decimal_marks, c))
+			       && (!c || !strchr(string_of_decimal_exponent_marks, c)));
+	     p++) {
+		if (isdigit(c)) {
+			if (seen_significant_digit || c > '0') {
+				++number_of_digits_before_decimal;
+				seen_significant_digit = 1;
+			} else {
+				first_digit++;
+			}
+		} else {
+			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
+	 *	4.29496729600000000000e+09	(2**31)
+	 * come out inexact for some reason related to length of the digit
+	 * string.
+	 */
+	if (c && strchr(string_of_decimal_marks, c)) {
+		int zeros = 0;	/* Length of current string of zeros */
 		
-		number_of_digits_before_decimal = 0;
-		number_of_digits_after_decimal = 0;
-		decimal_exponent = 0;
-		seen_significant_digit = 0;
-		for (p = first_digit;
-		     ((c = * p) != '\0')
-		     && (!c || ! strchr (string_of_decimal_marks,          c) )
-		     && (!c || ! strchr (string_of_decimal_exponent_marks, c) );
-		     p ++)
-		    {
-			    if (isdigit(c))
-				{
-					if (seen_significant_digit || c > '0')
-					    {
-						    number_of_digits_before_decimal ++;
-						    seen_significant_digit = 1;
-					    }
-					else
-					    {
-						    first_digit++;
-					    }
+		for (p++; (c = *p) && isdigit(c); p++) {
+			if (c == '0') {
+				zeros++;
+			} else {
+				number_of_digits_after_decimal += 1 + zeros;
+				zeros = 0;
+			}
+		}
+	}
+#else
+	if (c && strchr(string_of_decimal_marks, c)) {
+		for (p++; (((c = *p) != '\0')
+			   && (!c || !strchr(string_of_decimal_exponent_marks, c)));
+		     p++) {
+			if (isdigit(c)) {
+				number_of_digits_after_decimal++; /* This may be retracted below. */
+				if (/* seen_significant_digit || */ c > '0') {
+					seen_significant_digit = TRUE;
 				}
-			    else
-				{
-					break;		/* p -> char after pre-decimal digits. */
+			} else {
+				if (!seen_significant_digit) {
+					number_of_digits_after_decimal = 0;
 				}
-		    }				/* For each digit before decimal mark. */
+				break;
+			}
+		} /* 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;
 		
-#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
-		 *	4.29496729600000000000e+09	(2**31)
-		 * come out inexact for some reason related to length of the digit
-		 * string.
-		 */
-		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++;
-				} else {
-					number_of_digits_after_decimal += 1 + zeros;
-					zeros = 0;
-				}
+		c = *++p;
+		if (c && strchr ("+-",c)) {
+			digits_exponent_sign_char = c;
+			c = *++p;
+		} else {
+			digits_exponent_sign_char = '+';
+		}
+		
+		for ( ; (c); c = *++p) {
+			if (isdigit(c)) {
+				decimal_exponent = decimal_exponent * 10 + c - '0';
+				/*
+				 * BUG! If we overflow here, we lose!
+				 */
+			} else {
+				break;
 			}
 		}
-#else
-		if (c && strchr (string_of_decimal_marks, c))
-		    {
-			    for (p ++;
-				 ((c = * p) != '\0')
-				 && (!c || ! strchr (string_of_decimal_exponent_marks, c) );
-				 p ++)
-				{
-					if (isdigit(c))
-					    {
-						    number_of_digits_after_decimal ++; /* This may be retracted below. */
-						    if (/* seen_significant_digit || */ c > '0')
-							{
-								seen_significant_digit = TRUE;
-							}
-					    }
-					else
-					    {
-						    if ( ! seen_significant_digit)
-							{
-								number_of_digits_after_decimal = 0;
-							}
-						    break;
-					    }
-				}			/* 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;
-					c = * ++ p;
-				}
-			    else
-				{
-					digits_exponent_sign_char = '+';
-				}
-			    for (;
-				 (c);
-				 c = * ++ p)
-				{
-					if (isdigit(c))
-					    {
-						    decimal_exponent = decimal_exponent * 10 + c - '0';
-						    /*
-						     * BUG! If we overflow here, we lose!
-						     */
-					    }
-					else
-					    {
-						    break;
-					    }
-				}
-			    if (digits_exponent_sign_char == '-')
-				{
-					decimal_exponent = - decimal_exponent;
-				}
-		    }
-		* address_of_string_pointer = p;
+		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;
+	    number_of_digits_before_decimal + number_of_digits_after_decimal;
 	return_value = 0;
-	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 */
-	    }
-	else
-	    {
-		    LITTLENUM_TYPE *	digits_binary_low;
-		    int		precision;
-		    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
-				 + 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;
+	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 */
+
+	} else {
+		int count;	/* Number of useful digits left to scan. */
+		
+		LITTLENUM_TYPE *digits_binary_low;
+		int precision;
+		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
+			     + 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
+		 * 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
+		 */
+		
+		for (p = first_digit, count = number_of_digits_to_use; count; p++,  --count) {
+			c = *p;
+			if (isdigit(c)) {
+				/*
+				 * 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;
+
+				carry = c - '0'; /* char -> binary */
+
+				for (littlenum_pointer = digits_binary_low;
+				     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;
+				}
+
+				if (carry != 0) {
+					/*
+					 * We have a GROSS internal error.
+					 * This should never happen.
+					 */
+					as_fatal("failed sanity check.");	/* RMS prefers abort() to any message. */
+				}
+			} else {
+				++ 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.
+		 */
+		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,
+		 *     and what was
+		 *     harmless noise may become disruptive, ill-conditioned (or worse)
+		 *     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". */
+			/* 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;
 			}
-		    else
+
+			/* 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;
+
+			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_binary_low = 1;
+			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;
+			/*
+			 * (power) == 1.
+			 * Space for temporary_flonum allocated.
+			 */
+			
+			/*
+			 * ...
+			 *
+			 * WHILE	more bits
+			 * DO	find next bit (with place value)
+			 *	multiply into power mantissa
+			 * OD
+			 */
 			{
-				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
-		     * 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
-			     */
-			    
-			    char *		p;
-			    char		c;
-			    int		count;	/* Number of useful digits left to scan. */
-			    
-			    for (p = first_digit, count = number_of_digits_to_use;
-				 count;
-				 p ++,  -- count)
-				{
-					c = * p;
-					if (isdigit(c))
-					    {
-						    /*
-						     * 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;
-						    carry = c - '0';	/* char -> binary */
-						    for (littlenum_pointer = digits_binary_low;
-							 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;
-							}
-						    if (carry != 0)
-							{
-								/*
-								 * We have a GROSS internal error.
-								 * This should never happen.
-								 */
-								as_fatal("failed sanity check.");	/* RMS prefers abort() to any message. */
-							}
-					    }
-					else
-					    {
-						    ++ 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.
-		     */
-		    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,
-		     *     and what was
-		     *     harmless noise may become disruptive, ill-conditioned (or worse)
-		     *     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". */
-			    /* 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_chars
-				=   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_binary_low = 1;
-			    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;
-			    /*
-			     * (power) == 1.
-			     * Space for temporary_flonum allocated.
-			     */
-			    
-			    /*
-			     * ...
-			     *
-			     * WHILE	more bits
-			     * DO	find next bit (with place value)
-			     *	multiply into power mantissa
-			     * OD
-			     */
-			    {
-				    int		place_number_limit;
-				    /* Any 10^(2^n) whose "n" exceeds this */
-				    /* value will fall off the end of */
-				    /* 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
-					   ? 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. */
-					 decimal_exponent >>= 1
-					 , place_number ++)
-					{
-						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
-									 */
-									decimal_exponent = 0;
-								}
-							    else
-								{
+				int place_number_limit;
+				/* Any 10^(2^n) whose "n" exceeds this */
+				/* value will fall off the end of */
+				/* 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
+						? 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. */
+				     decimal_exponent >>= 1, place_number++) {
+					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
+							 */
+							decimal_exponent = 0;
+						} else {
 #ifdef TRACE
-									printf("before multiply, place_number = %d., power_of_10_flonum:\n", place_number);
-									flonum_print( & power_of_10_flonum );
-									(void)putchar('\n');
+							printf("before multiply, place_number = %d., power_of_10_flonum:\n",
+							       place_number);
+
+							flonum_print(&power_of_10_flonum);
+							(void)putchar('\n');
 #endif
-									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 */
+							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 */
 #ifdef TRACE
-				    printf( " after computing power_of_10_flonum: " );
-				    flonum_print( & power_of_10_flonum );
-				    (void)putchar('\n');
+				printf(" after computing power_of_10_flonum: ");
+				flonum_print(&power_of_10_flonum );
+				(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);
+			}
+			
+		}
+		
+		/*
+		 * 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 () */
 
 /* end of atof_generic.c */