2000-08-05 Kazu Hirata <kazu@hxi.com>

	* config/atof-ieee.c: Fix formatting.
	* config/atof-tahoe.c: Likewise.

1 files changed, 104 insertions, 101 deletions

diff --git a/gas/config/atof-ieee.c b/gas/config/atof-ieee.c
index 2e3c0dc6d0..2a916cd823 100644
--- a/gas/config/atof-ieee.c
+++ b/gas/config/atof-ieee.c
@@ -29,7 +29,7 @@ static void unget_bits PARAMS ((int));
 static void make_invalid_floating_point_number PARAMS ((LITTLENUM_TYPE *));
 
 extern const char EXP_CHARS[];
-/* Precision in LittleNums. */
+/* Precision in LittleNums.  */
 /* Don't count the gap in the m68k extended precision format.  */
 #define MAX_PRECISION (5)
 #define F_PRECISION (2)
@@ -37,7 +37,7 @@ extern const char EXP_CHARS[];
 #define X_PRECISION (5)
 #define P_PRECISION (5)
 
-/* Length in LittleNums of guard bits. */
+/* Length in LittleNums of guard bits.  */
 #define GUARD (2)
 
 static const unsigned long mask[] =
@@ -77,7 +77,6 @@ static const unsigned long mask[] =
   0xffffffff,
 };
 
-
 static int bits_left_in_littlenum;
 static int littlenums_left;
 static LITTLENUM_TYPE *littlenum_pointer;
@@ -100,18 +99,22 @@ next_bits (number_of_bits)
 	{
 	  bits_left_in_littlenum = LITTLENUM_NUMBER_OF_BITS - number_of_bits;
 	  --littlenum_pointer;
-	  return_value |= (*littlenum_pointer >> bits_left_in_littlenum) & mask[number_of_bits];
+	  return_value |=
+	    (*littlenum_pointer >> bits_left_in_littlenum)
+	    & mask[number_of_bits];
 	}
     }
   else
     {
       bits_left_in_littlenum -= number_of_bits;
-      return_value = mask[number_of_bits] & (*littlenum_pointer >> bits_left_in_littlenum);
+      return_value =
+	mask[number_of_bits] & (*littlenum_pointer >> bits_left_in_littlenum);
     }
-  return (return_value);
+  return return_value;
 }
 
-/* Num had better be less than LITTLENUM_NUMBER_OF_BITS */
+/* Num had better be less than LITTLENUM_NUMBER_OF_BITS.  */
+
 static void
 unget_bits (num)
      int num;
@@ -124,7 +127,8 @@ unget_bits (num)
     }
   else if (bits_left_in_littlenum + num > LITTLENUM_NUMBER_OF_BITS)
     {
-      bits_left_in_littlenum = num - (LITTLENUM_NUMBER_OF_BITS - bits_left_in_littlenum);
+      bits_left_in_littlenum =
+	num - (LITTLENUM_NUMBER_OF_BITS - bits_left_in_littlenum);
       ++littlenum_pointer;
       ++littlenums_left;
     }
@@ -137,7 +141,8 @@ make_invalid_floating_point_number (words)
      LITTLENUM_TYPE *words;
 {
   as_bad (_("cannot create floating-point number"));
-  words[0] = (LITTLENUM_TYPE) ((unsigned) -1) >> 1; /* Zero the leftmost bit */
+  /* Zero the leftmost bit.  */
+  words[0] = (LITTLENUM_TYPE) ((unsigned) -1) >> 1;
   words[1] = (LITTLENUM_TYPE) -1;
   words[2] = (LITTLENUM_TYPE) -1;
   words[3] = (LITTLENUM_TYPE) -1;
@@ -145,29 +150,27 @@ make_invalid_floating_point_number (words)
   words[5] = (LITTLENUM_TYPE) -1;
 }
 
-/************************************************************************\
- *	Warning: this returns 16-bit LITTLENUMs. It is up to the caller	*
- *	to figure out any alignment problems and to conspire for the	*
- *	bytes/word to be emitted in the right order. Bigendians beware!	*
- *									*
-\************************************************************************/
+/* Warning: This returns 16-bit LITTLENUMs.  It is up to the caller to
+   figure out any alignment problems and to conspire for the
+   bytes/word to be emitted in the right order.  Bigendians beware!  */
 
 /* Note that atof-ieee always has X and P precisions enabled.  it is up
    to md_atof to filter them out if the target machine does not support
    them.  */
 
-/* Returns pointer past text consumed. */
+/* Returns pointer past text consumed.  */
+
 char *
 atof_ieee (str, what_kind, words)
-     char *str;			/* Text to convert to binary. */
-     int what_kind;		/* 'd', 'f', 'g', 'h' */
-     LITTLENUM_TYPE *words;	/* Build the binary here. */
+     char *str;			/* Text to convert to binary.  */
+     int what_kind;		/* 'd', 'f', 'g', 'h'.  */
+     LITTLENUM_TYPE *words;	/* Build the binary here.  */
 {
-  /* Extra bits for zeroed low-order bits.  The 1st MAX_PRECISION are
-     zeroed, the last contain flonum bits. */
+  /* Extra bits for zeroed low-order bits.
+     The 1st MAX_PRECISION are zeroed, the last contain flonum bits.  */
   static LITTLENUM_TYPE bits[MAX_PRECISION + MAX_PRECISION + GUARD];
   char *return_value;
-  /* Number of 16-bit words in the format. */
+  /* Number of 16-bit words in the format.  */
   int precision;
   long exponent_bits;
   FLONUM_TYPE save_gen_flonum;
@@ -186,7 +189,7 @@ atof_ieee (str, what_kind, words)
   generic_floating_point_number.sign = '\0';
 
   /* Use more LittleNums than seems necessary: the highest flonum may
-     have 15 leading 0 bits, so could be useless. */
+     have 15 leading 0 bits, so could be useless.  */
 
   memset (bits, '\0', sizeof (LITTLENUM_TYPE) * MAX_PRECISION);
 
@@ -247,6 +250,7 @@ atof_ieee (str, what_kind, words)
 }
 
 /* Turn generic_floating_point_number into a real float/double/extended.  */
+
 int
 gen_to_words (words, precision, exponent_bits)
      LITTLENUM_TYPE *words;
@@ -274,17 +278,17 @@ gen_to_words (words, precision, exponent_bits)
 
   if (generic_floating_point_number.low > generic_floating_point_number.leader)
     {
-      /* 0.0e0 seen. */
+      /* 0.0e0 seen.  */
       if (generic_floating_point_number.sign == '+')
 	words[0] = 0x0000;
       else
 	words[0] = 0x8000;
       memset (&words[1], '\0',
 	      (words_end - words - 1) * sizeof (LITTLENUM_TYPE));
-      return (return_value);
+      return return_value;
     }
 
-  /* NaN:  Do the right thing */
+  /* NaN:  Do the right thing.  */
   if (generic_floating_point_number.sign == 0)
     {
       if (precision == F_PRECISION)
@@ -301,17 +305,17 @@ gen_to_words (words, precision, exponent_bits)
 	  words[3] = 0xffff;
 	  words[4] = 0xffff;
 	  words[5] = 0xffff;
-#else /* ! TC_M68K */
+#else /* ! TC_M68K  */
 #ifdef TC_I386
 	  words[0] = 0xffff;
 	  words[1] = 0xc000;
 	  words[2] = 0;
 	  words[3] = 0;
 	  words[4] = 0;
-#else /* ! TC_I386 */
+#else /* ! TC_I386  */
 	  abort ();
-#endif /* ! TC_I386 */
-#endif /* ! TC_M68K */
+#endif /* ! TC_I386  */
+#endif /* ! TC_M68K  */
 	}
       else
 	{
@@ -324,7 +328,7 @@ gen_to_words (words, precision, exponent_bits)
     }
   else if (generic_floating_point_number.sign == 'P')
     {
-      /* +INF:  Do the right thing */
+      /* +INF:  Do the right thing.  */
       if (precision == F_PRECISION)
 	{
 	  words[0] = 0x7f80;
@@ -339,17 +343,17 @@ gen_to_words (words, precision, exponent_bits)
 	  words[3] = 0;
 	  words[4] = 0;
 	  words[5] = 0;
-#else /* ! TC_M68K */
+#else /* ! TC_M68K  */
 #ifdef TC_I386
 	  words[0] = 0x7fff;
 	  words[1] = 0x8000;
 	  words[2] = 0;
 	  words[3] = 0;
 	  words[4] = 0;
-#else /* ! TC_I386 */
+#else /* ! TC_I386  */
 	  abort ();
-#endif /* ! TC_I386 */
-#endif /* ! TC_M68K */
+#endif /* ! TC_I386  */
+#endif /* ! TC_M68K  */
 	}
       else
 	{
@@ -358,11 +362,11 @@ gen_to_words (words, precision, exponent_bits)
 	  words[2] = 0;
 	  words[3] = 0;
 	}
-      return (return_value);
+      return return_value;
     }
   else if (generic_floating_point_number.sign == 'N')
     {
-      /* Negative INF */
+      /* Negative INF.  */
       if (precision == F_PRECISION)
 	{
 	  words[0] = 0xff80;
@@ -377,17 +381,17 @@ gen_to_words (words, precision, exponent_bits)
 	  words[3] = 0;
 	  words[4] = 0;
 	  words[5] = 0;
-#else /* ! TC_M68K */
+#else /* ! TC_M68K  */
 #ifdef TC_I386
 	  words[0] = 0xffff;
 	  words[1] = 0x8000;
 	  words[2] = 0;
 	  words[3] = 0;
 	  words[4] = 0;
-#else /* ! TC_I386 */
+#else /* ! TC_I386  */
 	  abort ();
-#endif /* ! TC_I386 */
-#endif /* ! TC_M68K */
+#endif /* ! TC_I386  */
+#endif /* ! TC_M68K  */
 	}
       else
 	{
@@ -396,46 +400,49 @@ gen_to_words (words, precision, exponent_bits)
 	  words[2] = 0x0;
 	  words[3] = 0x0;
 	}
-      return (return_value);
+      return return_value;
     }
-  /*
-   * The floating point formats we support have:
-   * Bit 15 is sign bit.
-   * Bits 14:n are excess-whatever exponent.
-   * Bits n-1:0 (if any) are most significant bits of fraction.
-   * Bits 15:0 of the next word(s) are the next most significant bits.
-   *
-   * So we need: number of bits of exponent, number of bits of
-   * mantissa.
-   */
+
+  /* The floating point formats we support have:
+     Bit 15 is sign bit.
+     Bits 14:n are excess-whatever exponent.
+     Bits n-1:0 (if any) are most significant bits of fraction.
+     Bits 15:0 of the next word(s) are the next most significant bits.
+
+     So we need: number of bits of exponent, number of bits of
+     mantissa.  */
   bits_left_in_littlenum = LITTLENUM_NUMBER_OF_BITS;
   littlenum_pointer = generic_floating_point_number.leader;
   littlenums_left = (1
 		     + generic_floating_point_number.leader
 		     - generic_floating_point_number.low);
-  /* Seek (and forget) 1st significant bit */
+
+  /* Seek (and forget) 1st significant bit.  */
   for (exponent_skippage = 0; !next_bits (1); ++exponent_skippage);;
   exponent_1 = (generic_floating_point_number.exponent
 		+ generic_floating_point_number.leader
 		+ 1
 		- generic_floating_point_number.low);
+
   /* Radix LITTLENUM_RADIX, point just higher than
-     generic_floating_point_number.leader. */
+     generic_floating_point_number.leader.  */
   exponent_2 = exponent_1 * LITTLENUM_NUMBER_OF_BITS;
-  /* Radix 2. */
+
+  /* Radix 2.  */
   exponent_3 = exponent_2 - exponent_skippage;
-  /* Forget leading zeros, forget 1st bit. */
+
+  /* Forget leading zeros, forget 1st bit.  */
   exponent_4 = exponent_3 + ((1 << (exponent_bits - 1)) - 2);
-  /* Offset exponent. */
 
+  /* Offset exponent.  */
   lp = words;
 
-  /* Word 1. Sign, exponent and perhaps high bits. */
+  /* Word 1.  Sign, exponent and perhaps high bits.  */
   word1 = ((generic_floating_point_number.sign == '+')
 	   ? 0
 	   : (1 << (LITTLENUM_NUMBER_OF_BITS - 1)));
 
-  /* Assume 2's complement integers. */
+  /* Assume 2's complement integers.  */
   if (exponent_4 <= 0)
     {
       int prec_bits;
@@ -443,7 +450,8 @@ gen_to_words (words, precision, exponent_bits)
 
       unget_bits (1);
       num_bits = -exponent_4;
-      prec_bits = LITTLENUM_NUMBER_OF_BITS * precision - (exponent_bits + 1 + num_bits);
+      prec_bits =
+	LITTLENUM_NUMBER_OF_BITS * precision - (exponent_bits + 1 + num_bits);
 #ifdef TC_I386
       if (precision == X_PRECISION && exponent_bits == 15)
 	{
@@ -457,14 +465,15 @@ gen_to_words (words, precision, exponent_bits)
 
       if (num_bits >= LITTLENUM_NUMBER_OF_BITS - exponent_bits)
 	{
-	  /* Bigger than one littlenum */
+	  /* Bigger than one littlenum.  */
 	  num_bits -= (LITTLENUM_NUMBER_OF_BITS - 1) - exponent_bits;
 	  *lp++ = word1;
-	  if (num_bits + exponent_bits + 1 > precision * LITTLENUM_NUMBER_OF_BITS)
+	  if (num_bits + exponent_bits + 1
+	      > precision * LITTLENUM_NUMBER_OF_BITS)
 	    {
-	      /* Exponent overflow */
+	      /* Exponent overflow.  */
 	      make_invalid_floating_point_number (words);
-	      return (return_value);
+	      return return_value;
 	    }
 #ifdef TC_M68K
 	  if (precision == X_PRECISION && exponent_bits == 15)
@@ -490,14 +499,15 @@ gen_to_words (words, precision, exponent_bits)
 	    }
 	  else
 	    {
-	      word1 |= next_bits ((LITTLENUM_NUMBER_OF_BITS - 1) - (exponent_bits + num_bits));
+	      word1 |= next_bits ((LITTLENUM_NUMBER_OF_BITS - 1)
+				  - (exponent_bits + num_bits));
 	      *lp++ = word1;
 	    }
 	}
       while (lp < words_end)
 	*lp++ = next_bits (LITTLENUM_NUMBER_OF_BITS);
 
-      /* Round the mantissa up, but don't change the number */
+      /* Round the mantissa up, but don't change the number.  */
       if (next_bits (1))
 	{
 	  --lp;
@@ -570,15 +580,11 @@ gen_to_words (words, precision, exponent_bits)
     }
   else if ((unsigned long) exponent_4 >= mask[exponent_bits])
     {
-      /*
-       * Exponent overflow. Lose immediately.
-       */
-
-      /*
-       * We leave return_value alone: admit we read the
-       * number, but return a floating exception
-       * because we can't encode the number.
-       */
+      /* Exponent overflow.  Lose immediately.  */
+
+      /* We leave return_value alone: admit we read the
+	 number, but return a floating exception
+	 because we can't encode the number.  */
       make_invalid_floating_point_number (words);
       return return_value;
     }
@@ -591,7 +597,7 @@ gen_to_words (words, precision, exponent_bits)
   *lp++ = word1;
 
   /* X_PRECISION is special: on the 68k, it has 16 bits of zero in the
-     middle.  Either way, it is then followed by a 1 bit. */
+     middle.  Either way, it is then followed by a 1 bit.  */
   if (exponent_bits == 15 && precision == X_PRECISION)
     {
 #ifdef TC_M68K
@@ -601,21 +607,19 @@ gen_to_words (words, precision, exponent_bits)
 	       | next_bits (LITTLENUM_NUMBER_OF_BITS - 1));
     }
 
-  /* The rest of the words are just mantissa bits. */
+  /* The rest of the words are just mantissa bits.  */
   while (lp < words_end)
     *lp++ = next_bits (LITTLENUM_NUMBER_OF_BITS);
 
   if (next_bits (1))
     {
       unsigned long carry;
-      /*
-       * Since the NEXT bit is a 1, round UP the mantissa.
-       * The cunning design of these hidden-1 floats permits
-       * us to let the mantissa overflow into the exponent, and
-       * it 'does the right thing'. However, we lose if the
-       * highest-order bit of the lowest-order word flips.
-       * Is that clear?
-       */
+      /* Since the NEXT bit is a 1, round UP the mantissa.
+	 The cunning design of these hidden-1 floats permits
+	 us to let the mantissa overflow into the exponent, and
+	 it 'does the right thing'. However, we lose if the
+	 highest-order bit of the lowest-order word flips.
+	 Is that clear?  */
 
       /* #if (sizeof(carry)) < ((sizeof(bits[0]) * BITS_PER_CHAR) + 2)
 	 Please allow at least 1 more bit in carry than is in a LITTLENUM.
@@ -640,33 +644,36 @@ gen_to_words (words, precision, exponent_bits)
 	    {
 #ifdef TC_M68K
 	      /* On the m68k there is a gap of 16 bits.  We must
-		 explicitly propagate the carry into the exponent. */
+		 explicitly propagate the carry into the exponent.  */
 	      words[0] += words[1];
 	      words[1] = 0;
 	      lp++;
 #endif
-	      /* Put back the integer bit.  */ 
+	      /* Put back the integer bit.  */
 	      lp[1] |= 1 << (LITTLENUM_NUMBER_OF_BITS - 1);
 	    }
- 	}
+	}
       if ((word1 ^ *words) & (1 << (LITTLENUM_NUMBER_OF_BITS - 1)))
 	{
-	  /* We leave return_value alone: admit we read the
-	   * number, but return a floating exception
-	   * because we can't encode the number.
-	   */
+	  /* We leave return_value alone: admit we read the number,
+	     but return a floating exception because we can't encode
+	     the number.  */
 	  *words &= ~(1 << (LITTLENUM_NUMBER_OF_BITS - 1));
-	  /* make_invalid_floating_point_number (words); */
-	  /* return return_value; */
+#if 0
+	  make_invalid_floating_point_number (words);
+	  return return_value;
+#endif
 	}
     }
-  return (return_value);
+  return return_value;
 }
 
-#if 0 /* unused */
+#if 0
+/* Unused.  */
 /* This routine is a real kludge.  Someone really should do it better,
    but I'm too lazy, and I don't understand this stuff all too well
    anyway. (JF)  */
+
 static void
 int_to_gen (x)
      long x;
@@ -705,13 +712,9 @@ print_gen (gen)
   sprintf (sbuf + strlen (sbuf), "%x %x %.12g\n", arr[0], arr[1], fv);
 
   if (gen)
-    {
-      generic_floating_point_number = f;
-    }
+    generic_floating_point_number = f;
 
   return (sbuf);
 }
 
 #endif
-
-/* end of atof-ieee.c */