1 files changed, 211 insertions, 212 deletions

diff --git a/src/plugins/old/convert_numeric.c b/src/plugins/old/convert_numeric.c
index b345014..35bd65a 100644
--- a/src/plugins/old/convert_numeric.c
+++ b/src/plugins/old/convert_numeric.c
@@ -61,45 +61,44 @@ static unsigned long get_field (const unsigned char *,
                                 unsigned int,
                                 unsigned int,
                                 unsigned int);
+
 static int floatformat_always_valid (const struct EXTRACTOR_floatformat *fmt,
                                      const void *from);
 
 static int
-floatformat_always_valid (const struct EXTRACTOR_floatformat *fmt /*ATTRIBUTE_UNUSED*/,
+floatformat_always_valid (const struct
+                          EXTRACTOR_floatformat *fmt /*ATTRIBUTE_UNUSED*/,
                           const void *from /*ATTRIBUTE_UNUSED*/)
 {
   return 1;
 }
 
+
 /* The odds that CHAR_BIT will be anything but 8 are low enough that I'm not
    going to bother with trying to muck around with whether it is defined in
    a system header, what we do if not, etc.  */
 #define FLOATFORMAT_CHAR_BIT 8
 
 /* floatformats for IEEE single and double, big and little endian.  */
-const struct EXTRACTOR_floatformat EXTRACTOR_floatformat_ieee_single_big =
-{
+const struct EXTRACTOR_floatformat EXTRACTOR_floatformat_ieee_single_big = {
   floatformat_big, 32, 0, 1, 8, 127, 255, 9, 23,
   floatformat_intbit_no,
   "floatformat_ieee_single_big",
   floatformat_always_valid
 };
-const struct EXTRACTOR_floatformat EXTRACTOR_floatformat_ieee_single_little =
-{
+const struct EXTRACTOR_floatformat EXTRACTOR_floatformat_ieee_single_little = {
   floatformat_little, 32, 0, 1, 8, 127, 255, 9, 23,
   floatformat_intbit_no,
   "floatformat_ieee_single_little",
   floatformat_always_valid
 };
-const struct EXTRACTOR_floatformat EXTRACTOR_floatformat_ieee_double_big =
-{
+const struct EXTRACTOR_floatformat EXTRACTOR_floatformat_ieee_double_big = {
   floatformat_big, 64, 0, 1, 11, 1023, 2047, 12, 52,
   floatformat_intbit_no,
   "floatformat_ieee_double_big",
   floatformat_always_valid
 };
-const struct EXTRACTOR_floatformat EXTRACTOR_floatformat_ieee_double_little =
-{
+const struct EXTRACTOR_floatformat EXTRACTOR_floatformat_ieee_double_little = {
   floatformat_little, 64, 0, 1, 11, 1023, 2047, 12, 52,
   floatformat_intbit_no,
   "floatformat_ieee_double_little",
@@ -109,8 +108,8 @@ const struct EXTRACTOR_floatformat EXTRACTOR_floatformat_ieee_double_little =
 /* floatformat for IEEE double, little endian byte order, with big endian word
    ordering, as on the ARM.  */
 
-const struct EXTRACTOR_floatformat EXTRACTOR_floatformat_ieee_double_littlebyte_bigword =
-{
+const struct EXTRACTOR_floatformat
+  EXTRACTOR_floatformat_ieee_double_littlebyte_bigword = {
   floatformat_littlebyte_bigword, 64, 0, 1, 11, 1023, 2047, 12, 52,
   floatformat_intbit_no,
   "floatformat_ieee_double_littlebyte_bigword",
@@ -119,33 +118,32 @@ const struct EXTRACTOR_floatformat EXTRACTOR_floatformat_ieee_double_littlebyte_
 
 /* floatformat for VAX.  Not quite IEEE, but close enough.  */
 
-const struct EXTRACTOR_floatformat EXTRACTOR_floatformat_vax_f =
-{
+const struct EXTRACTOR_floatformat EXTRACTOR_floatformat_vax_f = {
   floatformat_vax, 32, 0, 1, 8, 129, 0, 9, 23,
   floatformat_intbit_no,
   "floatformat_vax_f",
   floatformat_always_valid
 };
-const struct EXTRACTOR_floatformat EXTRACTOR_floatformat_vax_d =
-{
+const struct EXTRACTOR_floatformat EXTRACTOR_floatformat_vax_d = {
   floatformat_vax, 64, 0, 1, 8, 129, 0, 9, 55,
   floatformat_intbit_no,
   "floatformat_vax_d",
   floatformat_always_valid
 };
-const struct EXTRACTOR_floatformat EXTRACTOR_floatformat_vax_g =
-{
+const struct EXTRACTOR_floatformat EXTRACTOR_floatformat_vax_g = {
   floatformat_vax, 64, 0, 1, 11, 1025, 0, 12, 52,
   floatformat_intbit_no,
   "floatformat_vax_g",
   floatformat_always_valid
 };
 
-static int floatformat_i387_ext_is_valid (const struct EXTRACTOR_floatformat *fmt,
-                                          const void *from);
+static int floatformat_i387_ext_is_valid (const struct
+                                          EXTRACTOR_floatformat *fmt,
+                                          const void *from);
 
 static int
-floatformat_i387_ext_is_valid (const struct EXTRACTOR_floatformat *fmt, const void *from)
+floatformat_i387_ext_is_valid (const struct EXTRACTOR_floatformat *fmt, const
+                               void *from)
 {
   /* In the i387 double-extended format, if the exponent is all ones,
      then the integer bit must be set.  If the exponent is neither 0
@@ -155,9 +153,9 @@ floatformat_i387_ext_is_valid (const struct EXTRACTOR_floatformat *fmt, const vo
   const unsigned char *ufrom = (const unsigned char *) from;
 
   exponent = get_field (ufrom, fmt->byteorder, fmt->totalsize,
-                        fmt->exp_start, fmt->exp_len);
+                        fmt->exp_start, fmt->exp_len);
   int_bit = get_field (ufrom, fmt->byteorder, fmt->totalsize,
-                       fmt->man_start, 1);
+                       fmt->man_start, 1);
 
   if ((exponent == 0) != (int_bit == 0))
     return 0;
@@ -165,38 +163,34 @@ floatformat_i387_ext_is_valid (const struct EXTRACTOR_floatformat *fmt, const vo
     return 1;
 }
 
-const struct EXTRACTOR_floatformat EXTRACTOR_floatformat_i387_ext =
-{
+
+const struct EXTRACTOR_floatformat EXTRACTOR_floatformat_i387_ext = {
   floatformat_little, 80, 0, 1, 15, 0x3fff, 0x7fff, 16, 64,
   floatformat_intbit_yes,
   "floatformat_i387_ext",
   floatformat_i387_ext_is_valid
 };
-const struct EXTRACTOR_floatformat EXTRACTOR_floatformat_m68881_ext =
-{
+const struct EXTRACTOR_floatformat EXTRACTOR_floatformat_m68881_ext = {
   /* Note that the bits from 16 to 31 are unused.  */
   floatformat_big, 96, 0, 1, 15, 0x3fff, 0x7fff, 32, 64,
   floatformat_intbit_yes,
   "floatformat_m68881_ext",
   floatformat_always_valid
 };
-const struct EXTRACTOR_floatformat EXTRACTOR_floatformat_i960_ext =
-{
+const struct EXTRACTOR_floatformat EXTRACTOR_floatformat_i960_ext = {
   /* Note that the bits from 0 to 15 are unused.  */
   floatformat_little, 96, 16, 17, 15, 0x3fff, 0x7fff, 32, 64,
   floatformat_intbit_yes,
   "floatformat_i960_ext",
   floatformat_always_valid
 };
-const struct EXTRACTOR_floatformat EXTRACTOR_floatformat_m88110_ext =
-{
+const struct EXTRACTOR_floatformat EXTRACTOR_floatformat_m88110_ext = {
   floatformat_big, 80, 0, 1, 15, 0x3fff, 0x7fff, 16, 64,
   floatformat_intbit_yes,
   "floatformat_m88110_ext",
   floatformat_always_valid
 };
-const struct EXTRACTOR_floatformat EXTRACTOR_floatformat_m88110_harris_ext =
-{
+const struct EXTRACTOR_floatformat EXTRACTOR_floatformat_m88110_harris_ext = {
   /* Harris uses raw format 128 bytes long, but the number is just an ieee
      double, and the last 64 bits are wasted. */
   floatformat_big,128, 0, 1, 11,  0x3ff,  0x7ff, 12, 52,
@@ -204,45 +198,40 @@ const struct EXTRACTOR_floatformat EXTRACTOR_floatformat_m88110_harris_ext =
   "floatformat_m88110_ext_harris",
   floatformat_always_valid
 };
-const struct EXTRACTOR_floatformat EXTRACTOR_floatformat_arm_ext_big =
-{
+const struct EXTRACTOR_floatformat EXTRACTOR_floatformat_arm_ext_big = {
   /* Bits 1 to 16 are unused.  */
   floatformat_big, 96, 0, 17, 15, 0x3fff, 0x7fff, 32, 64,
   floatformat_intbit_yes,
   "floatformat_arm_ext_big",
   floatformat_always_valid
 };
-const struct EXTRACTOR_floatformat EXTRACTOR_floatformat_arm_ext_littlebyte_bigword =
-{
+const struct EXTRACTOR_floatformat
+  EXTRACTOR_floatformat_arm_ext_littlebyte_bigword = {
   /* Bits 1 to 16 are unused.  */
   floatformat_littlebyte_bigword, 96, 0, 17, 15, 0x3fff, 0x7fff, 32, 64,
   floatformat_intbit_yes,
   "floatformat_arm_ext_littlebyte_bigword",
   floatformat_always_valid
 };
-const struct EXTRACTOR_floatformat EXTRACTOR_floatformat_ia64_spill_big =
-{
+const struct EXTRACTOR_floatformat EXTRACTOR_floatformat_ia64_spill_big = {
   floatformat_big, 128, 0, 1, 17, 65535, 0x1ffff, 18, 64,
   floatformat_intbit_yes,
   "floatformat_ia64_spill_big",
   floatformat_always_valid
 };
-const struct EXTRACTOR_floatformat EXTRACTOR_floatformat_ia64_spill_little =
-{
+const struct EXTRACTOR_floatformat EXTRACTOR_floatformat_ia64_spill_little = {
   floatformat_little, 128, 0, 1, 17, 65535, 0x1ffff, 18, 64,
   floatformat_intbit_yes,
   "floatformat_ia64_spill_little",
   floatformat_always_valid
 };
-const struct EXTRACTOR_floatformat EXTRACTOR_floatformat_ia64_quad_big =
-{
+const struct EXTRACTOR_floatformat EXTRACTOR_floatformat_ia64_quad_big = {
   floatformat_big, 128, 0, 1, 15, 16383, 0x7fff, 16, 112,
   floatformat_intbit_no,
   "floatformat_ia64_quad_big",
   floatformat_always_valid
 };
-const struct EXTRACTOR_floatformat EXTRACTOR_floatformat_ia64_quad_little =
-{
+const struct EXTRACTOR_floatformat EXTRACTOR_floatformat_ia64_quad_little = {
   floatformat_little, 128, 0, 1, 15, 16383, 0x7fff, 16, 112,
   floatformat_intbit_no,
   "floatformat_ia64_quad_little",
@@ -257,7 +246,8 @@ const struct EXTRACTOR_floatformat EXTRACTOR_floatformat_ia64_quad_little =
 /* Extract a field which starts at START and is LEN bits long.  DATA and
    TOTAL_LEN are the thing we are extracting it from, in byteorder ORDER.  */
 static unsigned long
-get_field (const unsigned char *data, enum EXTRACTOR_floatformat_byteorders order,
+get_field (const unsigned char *data, enum EXTRACTOR_floatformat_byteorders
+           order,
            unsigned int total_len, unsigned int start, unsigned int len)
 {
   unsigned long result = 0;
@@ -278,29 +268,30 @@ get_field (const unsigned char *data, enum EXTRACTOR_floatformat_byteorders orde
   hi_bit = min (lo_bit + len, FLOATFORMAT_CHAR_BIT);
 
   do
-    {
-      unsigned int shifted = *(data + cur_byte) >> lo_bit;
-      unsigned int bits = hi_bit - lo_bit;
-      unsigned int mask = (1 << bits) - 1;
-      result |= (shifted & mask) << cur_bitshift;
-      len -= bits;
-      cur_bitshift += bits;
-      cur_byte += nextbyte;
-      lo_bit = 0;
-      hi_bit = min (len, FLOATFORMAT_CHAR_BIT);
-    }
+  {
+    unsigned int shifted = *(data + cur_byte) >> lo_bit;
+    unsigned int bits = hi_bit - lo_bit;
+    unsigned int mask = (1 << bits) - 1;
+    result |= (shifted & mask) << cur_bitshift;
+    len -= bits;
+    cur_bitshift += bits;
+    cur_byte += nextbyte;
+    lo_bit = 0;
+    hi_bit = min (len, FLOATFORMAT_CHAR_BIT);
+  }
   while (len != 0);
 
   return result;
 }
 
+
 /* Convert from FMT to a double.
    FROM is the address of the extended float.
    Store the double in *TO.  */
 
 void
 EXTRACTOR_common_floatformat_to_double (const struct EXTRACTOR_floatformat *fmt,
-                       const void *from, double *to)
+                                        const void *from, double *to)
 {
   const unsigned char *ufrom = (const unsigned char *) from;
   double dto;
@@ -308,65 +299,65 @@ EXTRACTOR_common_floatformat_to_double (const struct EXTRACTOR_floatformat *fmt,
   unsigned long mant;
   unsigned int mant_bits, mant_off;
   int mant_bits_left;
-  int special_exponent;         /* It's a NaN, denorm or zero */
+  int special_exponent;   /* It's a NaN, denorm or zero */
 
   exponent = get_field (ufrom, fmt->byteorder, fmt->totalsize,
-                        fmt->exp_start, fmt->exp_len);
+                        fmt->exp_start, fmt->exp_len);
 
   /* If the exponent indicates a NaN, we don't have information to
      decide what to do.  So we handle it like IEEE, except that we
      don't try to preserve the type of NaN.  FIXME.  */
   if ((unsigned long) exponent == fmt->exp_nan)
+  {
+    int nan;
+
+    mant_off = fmt->man_start;
+    mant_bits_left = fmt->man_len;
+    nan = 0;
+    while (mant_bits_left > 0)
     {
-      int nan;
-
-      mant_off = fmt->man_start;
-      mant_bits_left = fmt->man_len;
-      nan = 0;
-      while (mant_bits_left > 0)
-        {
-          mant_bits = min (mant_bits_left, 32);
-
-          if (get_field (ufrom, fmt->byteorder, fmt->totalsize,
-                         mant_off, mant_bits) != 0)
-            {
-              /* This is a NaN.  */
-              nan = 1;
-              break;
-            }
-
-          mant_off += mant_bits;
-          mant_bits_left -= mant_bits;
-        }
-
-      /* On certain systems (such as GNU/Linux), the use of the
-         INFINITY macro below may generate a warning that can not be
-         silenced due to a bug in GCC (PR preprocessor/11931).  The
-         preprocessor fails to recognise the __extension__ keyword in
-         conjunction with the GNU/C99 extension for hexadecimal
-         floating point constants and will issue a warning when
-         compiling with -pedantic.  */
-      if (nan)
-        dto = NAN;
-      else
-        dto = INFINITY;
-
-      if (get_field (ufrom, fmt->byteorder, fmt->totalsize, fmt->sign_start, 1))
-        dto = -dto;
-
-      *to = dto;
-
-      return;
+      mant_bits = min (mant_bits_left, 32);
+
+      if (get_field (ufrom, fmt->byteorder, fmt->totalsize,
+                     mant_off, mant_bits) != 0)
+      {
+        /* This is a NaN.  */
+        nan = 1;
+        break;
+      }
+
+      mant_off += mant_bits;
+      mant_bits_left -= mant_bits;
     }
 
+    /* On certain systems (such as GNU/Linux), the use of the
+ INFINITY macro below may generate a warning that can not be
+ silenced due to a bug in GCC (PR preprocessor/11931).  The
+ preprocessor fails to recognise the __extension__ keyword in
+ conjunction with the GNU/C99 extension for hexadecimal
+ floating point constants and will issue a warning when
+ compiling with -pedantic.  */if (nan)
+      dto = NAN;
+    else
+      dto = INFINITY;
+
+    if (get_field (ufrom, fmt->byteorder, fmt->totalsize, fmt->sign_start, 1))
+      dto = -dto;
+
+    *to = dto;
+
+    return;
+  }
+
   mant_bits_left = fmt->man_len;
   mant_off = fmt->man_start;
   dto = 0.0;
 
-  special_exponent = (exponent == 0) || ((unsigned long) exponent == fmt->exp_nan);
+  special_exponent = (exponent == 0) || ((unsigned long) exponent ==
+                                         fmt->exp_nan);
 
   /* Don't bias zero's, denorms or NaNs.  */
-  if (!special_exponent)
+  if (! special_exponent)
     exponent -= fmt->exp_bias;
 
   /* Build the result algebraically.  Might go infinite, underflow, etc;
@@ -375,36 +366,36 @@ EXTRACTOR_common_floatformat_to_double (const struct EXTRACTOR_floatformat *fmt,
   /* If this format uses a hidden bit, explicitly add it in now.  Otherwise,
      increment the exponent by one to account for the integer bit.  */
 
-  if (!special_exponent)
-    {
-      if (fmt->intbit == floatformat_intbit_no)
-        dto = ldexp (1.0, exponent);
-      else
-        exponent++;
-    }
+  if (! special_exponent)
+  {
+    if (fmt->intbit == floatformat_intbit_no)
+      dto = ldexp (1.0, exponent);
+    else
+      exponent++;
+  }
 
   while (mant_bits_left > 0)
-    {
-      mant_bits = min (mant_bits_left, 32);
-
-      mant = get_field (ufrom, fmt->byteorder, fmt->totalsize,
-                         mant_off, mant_bits);
-
-      /* Handle denormalized numbers.  FIXME: What should we do for
-         non-IEEE formats?  */
-      if (special_exponent && exponent == 0 && mant != 0)
-        dto += ldexp ((double)mant,
-                      (- fmt->exp_bias
-                       - mant_bits
-                       - (mant_off - fmt->man_start)
-                       + 1));
-      else
-        dto += ldexp ((double)mant, exponent - mant_bits);
-      if (exponent != 0)
-        exponent -= mant_bits;
-      mant_off += mant_bits;
-      mant_bits_left -= mant_bits;
-    }
+  {
+    mant_bits = min (mant_bits_left, 32);
+
+    mant = get_field (ufrom, fmt->byteorder, fmt->totalsize,
+                      mant_off, mant_bits);
+
+    /* Handle denormalized numbers.  FIXME: What should we do for
+ non-IEEE formats?  */
+    if (special_exponent && (exponent == 0) && (mant != 0) )
+      dto += ldexp ((double) mant,
+                    (-fmt->exp_bias
+                     - mant_bits
+                     - (mant_off - fmt->man_start)
+                     + 1));
+    else
+      dto += ldexp ((double) mant, exponent - mant_bits);
+    if (exponent != 0)
+      exponent -= mant_bits;
+    mant_off += mant_bits;
+    mant_bits_left -= mant_bits;
+  }
 
   /* Negate it if negative.  */
   if (get_field (ufrom, fmt->byteorder, fmt->totalsize, fmt->sign_start, 1))
@@ -412,6 +403,7 @@ EXTRACTOR_common_floatformat_to_double (const struct EXTRACTOR_floatformat *fmt,
   *to = dto;
 }
 
+
 static void put_field (unsigned char *, enum EXTRACTOR_floatformat_byteorders,
                        unsigned int,
                        unsigned int,
@@ -442,27 +434,29 @@ put_field (unsigned char *data, enum EXTRACTOR_floatformat_byteorders order,
   hi_bit = min (lo_bit + len, FLOATFORMAT_CHAR_BIT);
 
   do
-    {
-      unsigned char *byte_ptr = data + cur_byte;
-      unsigned int bits = hi_bit - lo_bit;
-      unsigned int mask = ((1 << bits) - 1) << lo_bit;
-      *byte_ptr = (*byte_ptr & ~mask) | ((stuff_to_put << lo_bit) & mask);
-      stuff_to_put >>= bits;
-      len -= bits;
-      cur_byte += nextbyte;
-      lo_bit = 0;
-      hi_bit = min (len, FLOATFORMAT_CHAR_BIT);
-    }
+  {
+    unsigned char *byte_ptr = data + cur_byte;
+    unsigned int bits = hi_bit - lo_bit;
+    unsigned int mask = ((1 << bits) - 1) << lo_bit;
+    *byte_ptr = (*byte_ptr & ~mask) | ((stuff_to_put << lo_bit) & mask);
+    stuff_to_put >>= bits;
+    len -= bits;
+    cur_byte += nextbyte;
+    lo_bit = 0;
+    hi_bit = min (len, FLOATFORMAT_CHAR_BIT);
+  }
   while (len != 0);
 }
 
+
 /* The converse: convert the double *FROM to an extended float
    and store where TO points.  Neither FROM nor TO have any alignment
    restrictions.  */
 
 void
-EXTRACTOR_common_floatformat_from_double (const struct EXTRACTOR_floatformat *fmt,
-                         const double *from, void *to)
+EXTRACTOR_common_floatformat_from_double (const struct
+                                          EXTRACTOR_floatformat *fmt,
+                                          const double *from, void *to)
 {
   double dfrom;
   int exponent;
@@ -476,88 +470,90 @@ EXTRACTOR_common_floatformat_from_double (const struct EXTRACTOR_floatformat *fm
 
   /* If negative, set the sign bit.  */
   if (dfrom < 0)
-    {
-      put_field (uto, fmt->byteorder, fmt->totalsize, fmt->sign_start, 1, 1);
-      dfrom = -dfrom;
-    }
+  {
+    put_field (uto, fmt->byteorder, fmt->totalsize, fmt->sign_start, 1, 1);
+    dfrom = -dfrom;
+  }
 
   if (dfrom == 0)
-    {
-      /* 0.0.  */
-      return;
-    }
+  {
+    /* 0.0.  */
+    return;
+  }
 
   if (dfrom != dfrom)
-    {
-      /* NaN.  */
-      put_field (uto, fmt->byteorder, fmt->totalsize, fmt->exp_start,
-                 fmt->exp_len, fmt->exp_nan);
-      /* Be sure it's not infinity, but NaN value is irrelevant.  */
-      put_field (uto, fmt->byteorder, fmt->totalsize, fmt->man_start,
-                 32, 1);
-      return;
-    }
+  {
+    /* NaN.  */
+    put_field (uto, fmt->byteorder, fmt->totalsize, fmt->exp_start,
+               fmt->exp_len, fmt->exp_nan);
+    /* Be sure it's not infinity, but NaN value is irrelevant.  */
+    put_field (uto, fmt->byteorder, fmt->totalsize, fmt->man_start,
+               32, 1);
+    return;
+  }
 
   if (dfrom + dfrom == dfrom)
-    {
-      /* This can only happen for an infinite value (or zero, which we
-         already handled above).  */
-      put_field (uto, fmt->byteorder, fmt->totalsize, fmt->exp_start,
-                 fmt->exp_len, fmt->exp_nan);
-      return;
-    }
+  {
+    /* This can only happen for an infinite value (or zero, which we
+ already handled above).  */
+    put_field (uto, fmt->byteorder, fmt->totalsize, fmt->exp_start,
+               fmt->exp_len, fmt->exp_nan);
+    return;
+  }
 
   mant = frexp (dfrom, &exponent);
   if (exponent + fmt->exp_bias - 1 > 0)
     put_field (uto, fmt->byteorder, fmt->totalsize, fmt->exp_start,
-               fmt->exp_len, exponent + fmt->exp_bias - 1);
+               fmt->exp_len, exponent + fmt->exp_bias - 1);
   else
-    {
-      /* Handle a denormalized number.  FIXME: What should we do for
-         non-IEEE formats?  */
-      put_field (uto, fmt->byteorder, fmt->totalsize, fmt->exp_start,
-                 fmt->exp_len, 0);
-      mant = ldexp (mant, exponent + fmt->exp_bias - 1);
-    }
+  {
+    /* Handle a denormalized number.  FIXME: What should we do for
+ non-IEEE formats?  */
+    put_field (uto, fmt->byteorder, fmt->totalsize, fmt->exp_start,
+               fmt->exp_len, 0);
+    mant = ldexp (mant, exponent + fmt->exp_bias - 1);
+  }
 
   mant_bits_left = fmt->man_len;
   mant_off = fmt->man_start;
   while (mant_bits_left > 0)
+  {
+    unsigned long mant_long;
+    mant_bits = mant_bits_left < 32 ? mant_bits_left : 32;
+
+    mant *= 4294967296.0;
+    mant_long = (unsigned long) mant;
+    mant -= mant_long;
+
+    /* If the integer bit is implicit, and we are not creating a
+ denormalized number, then we need to discard it.  */
+    if (( (unsigned int) mant_bits_left == fmt->man_len)
+        && (fmt->intbit == floatformat_intbit_no)
+        && (exponent + fmt->exp_bias - 1 > 0) )
     {
-      unsigned long mant_long;
-      mant_bits = mant_bits_left < 32 ? mant_bits_left : 32;
-
-      mant *= 4294967296.0;
-      mant_long = (unsigned long)mant;
-      mant -= mant_long;
-
-      /* If the integer bit is implicit, and we are not creating a
-         denormalized number, then we need to discard it.  */
-      if ((unsigned int) mant_bits_left == fmt->man_len
-          && fmt->intbit == floatformat_intbit_no
-          && exponent + fmt->exp_bias - 1 > 0)
-        {
-          mant_long &= 0x7fffffff;
-          mant_bits -= 1;
-        }
-      else if (mant_bits < 32)
-        {
-          /* The bits we want are in the most significant MANT_BITS bits of
-             mant_long.  Move them to the least significant.  */
-          mant_long >>= 32 - mant_bits;
-        }
-
-      put_field (uto, fmt->byteorder, fmt->totalsize,
-                 mant_off, mant_bits, mant_long);
-      mant_off += mant_bits;
-      mant_bits_left -= mant_bits;
+      mant_long &= 0x7fffffff;
+      mant_bits -= 1;
     }
+    else if (mant_bits < 32)
+    {
+      /* The bits we want are in the most significant MANT_BITS bits of
+         mant_long.  Move them to the least significant.  */
+      mant_long >>= 32 - mant_bits;
+    }
+
+    put_field (uto, fmt->byteorder, fmt->totalsize,
+               mant_off, mant_bits, mant_long);
+    mant_off += mant_bits;
+    mant_bits_left -= mant_bits;
+  }
 }
 
+
 /* Return non-zero iff the data at FROM is a valid number in format FMT.  */
 
 int
-EXTRACTOR_common_floatformat_is_valid (const struct EXTRACTOR_floatformat *fmt, const void *from)
+EXTRACTOR_common_floatformat_is_valid (const struct EXTRACTOR_floatformat *fmt,
+                                       const void *from)
 {
   return fmt->is_valid (fmt, from);
 }
@@ -575,15 +571,15 @@ ieee_test (double n)
   double result;
 
   floatformat_to_double (&floatformat_ieee_double_little, &n, &result);
-  if ((n != result && (! isnan (n) || ! isnan (result)))
-      || (n < 0 && result >= 0)
-      || (n >= 0 && result < 0))
+  if (((n != result) && (! isnan (n) || ! isnan (result)))
+      || ((n < 0) && (result >= 0))
+      || ((n >= 0) && (result < 0)))
     printf ("Differ(to): %.20g -> %.20g\n", n, result);
 
   floatformat_from_double (&floatformat_ieee_double_little, &n, &result);
-  if ((n != result && (! isnan (n) || ! isnan (result)))
-      || (n < 0 && result >= 0)
-      || (n >= 0 && result < 0))
+  if (((n != result) && (! isnan (n) || ! isnan (result)))
+      || ((n < 0) && (result >= 0))
+      || ((n >= 0) && (result < 0)))
     printf ("Differ(from): %.20g -> %.20g\n", n, result);
 
 #if 0
@@ -600,13 +596,14 @@ ieee_test (double n)
 #if IEEE_DEBUG > 1
   /* This is to be run on a host which uses 68881 format.  */
   {
-    long double ex = *(long double *)exten;
+    long double ex = *(long double *) exten;
     if (ex != n)
       printf ("Differ(from vs. extended): %.20g\n", n);
   }
 #endif
 }
 
+
 int
 main (void)
 {
@@ -620,12 +617,14 @@ main (void)
   ieee_test (1.2E-70);
   ieee_test (1.2E-316);
   ieee_test (4.9406564584124654E-324);
-  ieee_test (- 4.9406564584124654E-324);
-  ieee_test (- 0.0);
-  ieee_test (- INFINITY);
-  ieee_test (- NAN);
+  ieee_test (-4.9406564584124654E-324);
+  ieee_test (-0.0);
+  ieee_test (-INFINITY);
+  ieee_test (-NAN);
   ieee_test (INFINITY);
   ieee_test (NAN);
   return 0;
 }
+
+
 #endif