11210 libm should be cstyle(1ONBLD) clean

@@ -20,10 +20,11 @@
  */
 
 /*
  * Copyright 2011 Nexenta Systems, Inc.  All rights reserved.
  */
+
 /*
  * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
  * Use is subject to license terms.
  */
 

@@ -41,47 +42,43 @@
  */
 
 #include "libm.h"
 
 #if defined(__sparc)
-
 static union {
         unsigned i[2];
         double d;
 } C[] = {
-        0x00100000, 0,
-        0x7fe00000, 0,
-        0x7fffffff, 0xffffffff
+        0x00100000, 0, 0x7fe00000, 0, 0x7fffffff, 0xffffffff
 };
 
 #define tiny    C[0].d
 #define huge    C[1].d
 #define qnan    C[2].d
 
 enum fcc_type {
-        fcc_equal = 0,
-        fcc_less = 1,
-        fcc_greater = 2,
-        fcc_unordered = 3
+        fcc_equal = 0, fcc_less = 1, fcc_greater = 2, fcc_unordered = 3
 };
 
 #ifdef __sparcv9
 #define _Q_cmp  _Qp_cmp
 #endif
 
 extern enum fcc_type _Q_cmp(const long double *, const long double *);
 
 double
-__nexttoward(double x, long double y) {
+__nexttoward(double x, long double y)
+{
         union {
                 unsigned i[2];
                 double d;
         } xx;
         union {
                 unsigned i[4];
                 long double q;
         } yy;
+
         long double lx;
         unsigned hx;
         volatile double dummy;
         enum fcc_type rel;
 

@@ -95,19 +92,21 @@
         lx = xx.d = x;
         hx = (xx.i[0] & ~0x80000000) | xx.i[1];
 
         /* check for each of four possible orderings */
         rel = _Q_cmp(&lx, &y);
+
         if (rel == fcc_unordered)
                 return (qnan);
 
         if (rel == fcc_equal) {
                 if (hx == 0) {  /* x is zero; return zero with y's sign */
                         yy.q = y;
                         xx.i[0] = yy.i[0];
                         return (xx.d);
                 }
+
                 return (x);
         }
 
         if (rel == fcc_less) {
                 if (hx == 0) {  /* x is zero */

@@ -133,53 +132,52 @@
                 }
         }
 
         /* raise exceptions as needed */
         hx = xx.i[0] & ~0x80000000;
+
         if (hx == 0x7ff00000) {
                 dummy = huge;
                 dummy *= huge;
         } else if (hx < 0x00100000) {
                 dummy = tiny;
                 dummy *= tiny;
         }
 
         return (xx.d);
 }
-
 #elif defined(__x86)
-
 static union {
         unsigned i[2];
         double d;
 } C[] = {
-        0, 0x00100000,
-        0, 0x7fe00000,
-};
+        0, 0x00100000, 0, 0x7fe00000, };
 
 #define tiny    C[0].d
 #define huge    C[1].d
 
 double
-__nexttoward(double x, long double y) {
+__nexttoward(double x, long double y)
+{
         union {
                 unsigned i[2];
                 double d;
         } xx;
+
         unsigned hx;
         long double lx;
         volatile double dummy;
 
         lx = xx.d = x;
         hx = (xx.i[1] & ~0x80000000) | xx.i[0];
 
         /* check for each of four possible orderings */
         if (isunordered(lx, y))
-                return ((double) (lx + y));
+                return ((double)(lx + y));
 
         if (lx == y)
-                return ((double) y);
+                return ((double)y);
 
         if (lx < y) {
                 if (hx == 0) {  /* x is zero */
                         xx.i[0] = 0x00000001;
                         xx.i[1] = 0;

@@ -203,19 +201,19 @@
                 }
         }
 
         /* raise exceptions as needed */
         hx = xx.i[1] & ~0x80000000;
+
         if (hx == 0x7ff00000) {
                 dummy = huge;
                 dummy *= huge;
         } else if (hx < 0x00100000) {
                 dummy = tiny;
                 dummy *= tiny;
         }
 
         return (xx.d);
 }
-
 #else
 #error Unknown architecture
 #endif