Changeset 750636a in mainline for uspace/lib/softfloat/generic/comparison.c

Timestamp:

2011-05-06T14:21:25Z (13 years ago)

Author:

Martin Decky <martin@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

7b90778d, b5e68c8

Parents:

042fbe0

Message:

softfloat: slightly improve coding style (no change in functionality)

File:

• uspace/lib/softfloat/generic/comparison.c (modified) (3 diffs)

uspace/lib/softfloat/generic/comparison.c

@@ -27 +27 @@
  */
 
-/** @addtogroup softfloat       
+/** @addtogroup softfloat
  * @{
  */
@@ -33 +33 @@
  */
 
-#include<sftypes.h>
-#include<comparison.h>
+#include <sftypes.h>
+#include <comparison.h>
 
-inline int isFloat32NaN(float32 f)
-{       /* NaN : exp = 0xff and nonzero fraction */
-        return ((f.parts.exp==0xFF)&&(f.parts.fraction));
+/* NaN : exp = 0xff and nonzero fraction */
+int isFloat32NaN(float32 f)
+{
+        return ((f.parts.exp == 0xFF) && (f.parts.fraction));
 }
 
-inline int isFloat64NaN(float64 d)
-{       /* NaN : exp = 0x7ff and nonzero fraction */
-        return ((d.parts.exp==0x7FF)&&(d.parts.fraction));
+/* NaN : exp = 0x7ff and nonzero fraction */
+int isFloat64NaN(float64 d)
+{
+        return ((d.parts.exp == 0x7FF) && (d.parts.fraction));
 }
 
-inline int isFloat32SigNaN(float32 f)
-{       /* SigNaN : exp = 0xff fraction = 0xxxxx..x (binary), where at least one x is nonzero */
-        return ((f.parts.exp==0xFF)&&(f.parts.fraction<0x400000)&&(f.parts.fraction));
+/* SigNaN : exp = 0xff fraction = 0xxxxx..x (binary), where at least one x is nonzero */
+int isFloat32SigNaN(float32 f)
+{
+        return ((f.parts.exp == 0xFF) && (f.parts.fraction < 0x400000) && (f.parts.fraction));
 }
 
-inline int isFloat64SigNaN(float64 d)
-{       /* SigNaN : exp = 0x7ff fraction = 0xxxxx..x (binary), where at least one x is nonzero */
-        return ((d.parts.exp==0x7FF)&&(d.parts.fraction)&&(d.parts.fraction<0x8000000000000ll));
+/* SigNaN : exp = 0x7ff fraction = 0xxxxx..x (binary), where at least one x is nonzero */
+int isFloat64SigNaN(float64 d)
+{
+        return ((d.parts.exp == 0x7FF) && (d.parts.fraction) && (d.parts.fraction < 0x8000000000000ll));
 }
 
-inline int isFloat32Infinity(float32 f) 
+int isFloat32Infinity(float32 f)
 {
-        return ((f.parts.exp==0xFF)&&(f.parts.fraction==0x0));
+        return ((f.parts.exp == 0xFF) && (f.parts.fraction == 0x0));
 }
 
-inline int isFloat64Infinity(float64 d) 
+int isFloat64Infinity(float64 d) 
 {
-        return ((d.parts.exp==0x7FF)&&(d.parts.fraction==0x0));
+        return ((d.parts.exp == 0x7FF) && (d.parts.fraction == 0x0));
 }
 
-inline int isFloat32Zero(float32 f)
+int isFloat32Zero(float32 f)
 {
         return (((f.binary) & 0x7FFFFFFF) == 0);
 }
 
-inline int isFloat64Zero(float64 d)
+int isFloat64Zero(float64 d)
 {
         return (((d.binary) & 0x7FFFFFFFFFFFFFFFll) == 0);
@@ -77 +81 @@
 
 /**
- * @return 1, if both floats are equal - but NaNs are not recognized 
+ * @return 1 if both floats are equal - but NaNs are not recognized
  */
-inline int isFloat32eq(float32 a, float32 b)
+int isFloat32eq(float32 a, float32 b)
 {
-        return ((a.binary==b.binary)||(((a.binary| b.binary)&0x7FFFFFFF)==0)); /* a equals to b or both are zeros (with any sign) */
+        /* a equals to b or both are zeros (with any sign) */
+        return ((a.binary==b.binary) || (((a.binary | b.binary) & 0x7FFFFFFF) == 0));
 }
 
 /**
- * @return 1, if a<b - but NaNs are not recognized 
+ * @return 1 if a < b - but NaNs are not recognized 
  */
-inline int isFloat32lt(float32 a, float32 b) 
+int isFloat32lt(float32 a, float32 b) 
 {
-        if (((a.binary| b.binary)&0x7FFFFFFF)==0) {
+        if (((a.binary | b.binary) & 0x7FFFFFFF) == 0)
                 return 0; /* +- zeroes */
-        };
         
-        if ((a.parts.sign)&&(b.parts.sign)) {
-                /*if both are negative, smaller is that with greater binary value*/
-                return (a.binary>b.binary);
-                };
+        if ((a.parts.sign) && (b.parts.sign))
+                /* if both are negative, smaller is that with greater binary value */
+                return (a.binary > b.binary);
         
-        /* lets negate signs - now will be positive numbers allways bigger than negative (first bit will be set for unsigned integer comparison)*/
-        a.parts.sign=!a.parts.sign;
-        b.parts.sign=!b.parts.sign;
-        return (a.binary<b.binary);
-                        
+        /* lets negate signs - now will be positive numbers allways bigger than negative (first bit will be set for unsigned integer comparison) */
+        a.parts.sign = !a.parts.sign;
+        b.parts.sign = !b.parts.sign;
+        return (a.binary < b.binary);
 }
 
 /**
- * @return 1, if a>b - but NaNs are not recognized 
+ * @return 1 if a > b - but NaNs are not recognized 
  */
-inline int isFloat32gt(float32 a, float32 b) 
+int isFloat32gt(float32 a, float32 b) 
 {
-        if (((a.binary| b.binary)&0x7FFFFFFF)==0) {
+        if (((a.binary | b.binary) & 0x7FFFFFFF) == 0)
                 return 0; /* zeroes are equal with any sign */
-        };
         
-        if ((a.parts.sign)&&(b.parts.sign)) {
-                /*if both are negative, greater is that with smaller binary value*/
-                return (a.binary<b.binary);
-                };
+        if ((a.parts.sign) && (b.parts.sign))
+                /* if both are negative, greater is that with smaller binary value */
+                return (a.binary < b.binary);
         
-        /* lets negate signs - now will be positive numbers allways bigger than negative (first bit will be set for unsigned integer comparison)*/
-        a.parts.sign=!a.parts.sign;
-        b.parts.sign=!b.parts.sign;
-        return (a.binary>b.binary);
-                        
+        /* lets negate signs - now will be positive numbers allways bigger than negative (first bit will be set for unsigned integer comparison) */
+        a.parts.sign = !a.parts.sign;
+        b.parts.sign = !b.parts.sign;
+        return (a.binary > b.binary);
 }