Index: uspace/lib/softfloat/generic/add.c
===================================================================
--- uspace/lib/softfloat/generic/add.c	(revision 9539be6c880110557328e7e518cf276b94c1b07f)
+++ uspace/lib/softfloat/generic/add.c	(revision b7ee0369ab06af3c771aa449a315cb1881f6870b)
@@ -27,5 +27,5 @@
  */
 
-/** @addtogroup softfloat	
+/** @addtogroup softfloat
  * @{
  */
@@ -33,7 +33,7 @@
  */
 
-#include<sftypes.h>
-#include<add.h>
-#include<comparison.h>
+#include <sftypes.h>
+#include <add.h>
+#include <comparison.h>
 
 /** Add two Float32 numbers with same signs
@@ -139,9 +139,8 @@
 	a.parts.exp = exp1;
 	
-	/*Clear hidden bit and shift */
+	/* Clear hidden bit and shift */
 	a.parts.fraction = ((frac1 >> 6) & (~FLOAT32_HIDDEN_BIT_MASK)) ; 
 	return a;
 }
-
 
 /** Add two Float64 numbers with same signs
@@ -250,5 +249,5 @@
 	
 	a.parts.exp = exp1;
-	/*Clear hidden bit and shift */
+	/* Clear hidden bit and shift */
 	a.parts.fraction = ( (frac1 >> 6 ) & (~FLOAT64_HIDDEN_BIT_MASK));
 	
Index: uspace/lib/softfloat/generic/common.c
===================================================================
--- uspace/lib/softfloat/generic/common.c	(revision 9539be6c880110557328e7e518cf276b94c1b07f)
+++ uspace/lib/softfloat/generic/common.c	(revision b7ee0369ab06af3c771aa449a315cb1881f6870b)
@@ -27,5 +27,5 @@
  */
 
-/** @addtogroup softfloat	
+/** @addtogroup softfloat
  * @{
  */
@@ -33,6 +33,6 @@
  */
 
-#include<sftypes.h>
-#include<common.h>
+#include <sftypes.h>
+#include <common.h>
 
 /* Table for fast leading zeroes counting */
@@ -213,3 +213,2 @@
 /** @}
  */
-
Index: uspace/lib/softfloat/generic/comparison.c
===================================================================
--- uspace/lib/softfloat/generic/comparison.c	(revision 9539be6c880110557328e7e518cf276b94c1b07f)
+++ uspace/lib/softfloat/generic/comparison.c	(revision b7ee0369ab06af3c771aa449a315cb1881f6870b)
@@ -27,5 +27,5 @@
  */
 
-/** @addtogroup softfloat	
+/** @addtogroup softfloat
  * @{
  */
@@ -33,43 +33,47 @@
  */
 
-#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,51 +81,46 @@
 
 /**
- * @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);
 }
 
Index: uspace/lib/softfloat/generic/div.c
===================================================================
--- uspace/lib/softfloat/generic/div.c	(revision 9539be6c880110557328e7e518cf276b94c1b07f)
+++ uspace/lib/softfloat/generic/div.c	(revision b7ee0369ab06af3c771aa449a315cb1881f6870b)
@@ -27,5 +27,5 @@
  */
 
-/** @addtogroup softfloat	
+/** @addtogroup softfloat
  * @{
  */
@@ -33,11 +33,10 @@
  */
 
-#include<sftypes.h>
-#include<add.h>
-#include<div.h>
-#include<comparison.h>
-#include<mul.h>
-#include<common.h>
-
+#include <sftypes.h>
+#include <add.h>
+#include <div.h>
+#include <comparison.h>
+#include <mul.h>
+#include <common.h>
 
 float32 divFloat32(float32 a, float32 b) 
Index: uspace/lib/softfloat/generic/mul.c
===================================================================
--- uspace/lib/softfloat/generic/mul.c	(revision 9539be6c880110557328e7e518cf276b94c1b07f)
+++ uspace/lib/softfloat/generic/mul.c	(revision b7ee0369ab06af3c771aa449a315cb1881f6870b)
@@ -27,5 +27,5 @@
  */
 
-/** @addtogroup softfloat	
+/** @addtogroup softfloat
  * @{
  */
@@ -33,8 +33,8 @@
  */
 
-#include<sftypes.h>
-#include<mul.h>
-#include<comparison.h>
-#include<common.h>
+#include <sftypes.h>
+#include <mul.h>
+#include <comparison.h>
+#include <common.h>
 
 /** Multiply two 32 bit float numbers
Index: uspace/lib/softfloat/generic/other.c
===================================================================
--- uspace/lib/softfloat/generic/other.c	(revision 9539be6c880110557328e7e518cf276b94c1b07f)
+++ uspace/lib/softfloat/generic/other.c	(revision b7ee0369ab06af3c771aa449a315cb1881f6870b)
@@ -27,5 +27,5 @@
  */
 
-/** @addtogroup softfloat	
+/** @addtogroup softfloat
  * @{
  */
Index: uspace/lib/softfloat/generic/softfloat.c
===================================================================
--- uspace/lib/softfloat/generic/softfloat.c	(revision 9539be6c880110557328e7e518cf276b94c1b07f)
+++ uspace/lib/softfloat/generic/softfloat.c	(revision b7ee0369ab06af3c771aa449a315cb1881f6870b)
@@ -35,17 +35,17 @@
  */
 
-#include<softfloat.h>
-#include<sftypes.h>
-
-#include<add.h>
-#include<sub.h>
-#include<mul.h>
-#include<div.h>
-
-#include<conversion.h>
-#include<comparison.h>
-#include<other.h>
-
-#include<functions.h>
+#include <softfloat.h>
+#include <sftypes.h>
+
+#include <add.h>
+#include <sub.h>
+#include <mul.h>
+#include <div.h>
+
+#include <conversion.h>
+#include <comparison.h>
+#include <other.h>
+
+#include <functions.h>
 
 /* Arithmetic functions */
@@ -494,6 +494,4 @@
 }
 
-
 /** @}
  */
-
Index: uspace/lib/softfloat/generic/sub.c
===================================================================
--- uspace/lib/softfloat/generic/sub.c	(revision 9539be6c880110557328e7e518cf276b94c1b07f)
+++ uspace/lib/softfloat/generic/sub.c	(revision b7ee0369ab06af3c771aa449a315cb1881f6870b)
@@ -27,5 +27,5 @@
  */
 
- /** @addtogroup softfloat	
+/** @addtogroup softfloat
  * @{
  */
@@ -33,7 +33,7 @@
  */
 
-#include<sftypes.h>
-#include<sub.h>
-#include<comparison.h>
+#include <sftypes.h>
+#include <sub.h>
+#include <comparison.h>
 
 /** Subtract two float32 numbers with same signs
@@ -260,6 +260,4 @@
 }
 
-
- /** @}
- */
-
+/** @}
+ */