11210 libm should be cstyle(1ONBLD) clean

@@ -20,19 +20,21 @@
  */
 
 /*
  * Copyright 2011 Nexenta Systems, Inc.  All rights reserved.
  */
+
 /*
  * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
  * Use is subject to license terms.
  */
 
 #pragma weak __sinl = sinl
 
-/* INDENT OFF */
-/* sinl(x)
+/* BEGIN CSTYLED */
+/*
+ * sinl(x)
  * Table look-up algorithm by K.C. Ng, November, 1989.
  *
  * kernel function:
  *      __k_sinl                ... sin function on [-pi/4,pi/4]
  *      __k_cosl                ... cos function on [-pi/4,pi/4]

@@ -58,52 +60,57 @@
  *      trig(NaN)    is that NaN;
  *
  * Accuracy:
  *      computer TRIG(x) returns trig(x) nearly rounded.
  */
-/* INDENT ON */
+/* END CSTYLED */
 
 #include "libm.h"
 #include "longdouble.h"
 
 #include <sys/isa_defs.h>
 
 long double
-sinl(long double x) {
+sinl(long double x)
+{
         long double y[2], z = 0.0L;
         int n, ix;
+
 #if defined(__i386) || defined(__amd64)
-        int *px = (int *) &x;
+        int *px = (int *)&x;
 #endif
 
         /* sin(Inf or NaN) is NaN */
         if (!finitel(x))
-                return x - x;
+                return (x - x);
 
         /* High word of x. */
 #if defined(__i386) || defined(__amd64)
         XTOI(px, ix);
 #else
-        ix = *(int *) &x;
+        ix = *(int *)&x;
 #endif
         /* |x| ~< pi/4 */
         ix &= 0x7fffffff;
-        if (ix <= 0x3ffe9220)
-                return __k_sinl(x, z);
 
+        if (ix <= 0x3ffe9220) {
+                return (__k_sinl(x, z));
+        }
         /* argument reduction needed */
         else {
                 n = __rem_pio2l(x, y);
+
                 switch (n & 3) {
                 case 0:
-                        return __k_sinl(y[0], y[1]);
+                        return (__k_sinl(y[0], y[1]));
                 case 1:
-                        return __k_cosl(y[0], y[1]);
+                        return (__k_cosl(y[0], y[1]));
                 case 2:
-                        return -__k_sinl(y[0], y[1]);
+                        return (-__k_sinl(y[0], y[1]));
                 case 3:
-                        return -__k_cosl(y[0], y[1]);
+                        return (-__k_cosl(y[0], y[1]));
                 /* NOTREACHED */
                 }
         }
-        return 0.0L;
+
+        return (0.0L);
 }