Changes in uspace/lib/softfloat/generic/comparison.c [750636a:00acd66] in mainline

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>
 
-/* NaN : exp = 0xff and nonzero fraction */
-int isFloat32NaN(float32 f)
-{
-        return ((f.parts.exp == 0xFF) && (f.parts.fraction));
+inline int isFloat32NaN(float32 f)
+{       /* NaN : exp = 0xff and nonzero fraction */
+        return ((f.parts.exp==0xFF)&&(f.parts.fraction));
 }
 
-/* NaN : exp = 0x7ff and nonzero fraction */
-int isFloat64NaN(float64 d)
-{
-        return ((d.parts.exp == 0x7FF) && (d.parts.fraction));
+inline int isFloat64NaN(float64 d)
+{       /* NaN : exp = 0x7ff and nonzero fraction */
+        return ((d.parts.exp==0x7FF)&&(d.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 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 = 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 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));
 }
 
-int isFloat32Infinity(float32 f)
+inline int isFloat32Infinity(float32 f) 
 {
-        return ((f.parts.exp == 0xFF) && (f.parts.fraction == 0x0));
+        return ((f.parts.exp==0xFF)&&(f.parts.fraction==0x0));
 }
 
-int isFloat64Infinity(float64 d) 
+inline int isFloat64Infinity(float64 d) 
 {
-        return ((d.parts.exp == 0x7FF) && (d.parts.fraction == 0x0));
+        return ((d.parts.exp==0x7FF)&&(d.parts.fraction==0x0));
 }
 
-int isFloat32Zero(float32 f)
+inline int isFloat32Zero(float32 f)
 {
         return (((f.binary) & 0x7FFFFFFF) == 0);
 }
 
-int isFloat64Zero(float64 d)
+inline int isFloat64Zero(float64 d)
 {
         return (((d.binary) & 0x7FFFFFFFFFFFFFFFll) == 0);
@@ -81 +77 @@
 
 /**
- * @return 1 if both floats are equal - but NaNs are not recognized
+ * @return 1, if both floats are equal - but NaNs are not recognized 
  */
-int isFloat32eq(float32 a, float32 b)
+inline int isFloat32eq(float32 a, float32 b)
 {
-        /* a equals to b or both are zeros (with any sign) */
-        return ((a.binary==b.binary) || (((a.binary | b.binary) & 0x7FFFFFFF) == 0));
+        return ((a.binary==b.binary)||(((a.binary| b.binary)&0x7FFFFFFF)==0)); /* a equals to b or both are zeros (with any sign) */
 }
 
 /**
- * @return 1 if a < b - but NaNs are not recognized 
+ * @return 1, if a<b - but NaNs are not recognized 
  */
-int isFloat32lt(float32 a, float32 b) 
+inline 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 
  */
-int isFloat32gt(float32 a, float32 b) 
+inline 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);
+                        
 }