Index: uspace/lib/softfloat/add.c
===================================================================
--- uspace/lib/softfloat/add.c	(revision 9d8b12da8c497c2a0001860cd8545439328c6071)
+++ uspace/lib/softfloat/add.c	(revision 3061bc129a855122d429fbba1e623a521aaa164c)
@@ -60,5 +60,5 @@
 		}
 		
-		if (b.parts.exp == FLOAT32_MAX_EXPONENT) { 
+		if (b.parts.exp == FLOAT32_MAX_EXPONENT) {
 			return b;
 		}
@@ -77,5 +77,5 @@
 		}
 		
-		if (a.parts.exp == FLOAT32_MAX_EXPONENT) { 
+		if (a.parts.exp == FLOAT32_MAX_EXPONENT) {
 			return a;
 		}
@@ -105,5 +105,5 @@
 	} else {
 		/* add hidden bit to second operand */
-		frac2 |= FLOAT32_HIDDEN_BIT_MASK; 
+		frac2 |= FLOAT32_HIDDEN_BIT_MASK;
 	}
 	
@@ -129,5 +129,5 @@
 	frac1 += (0x1 << 5);
 	
-	if (frac1 & (FLOAT32_HIDDEN_BIT_MASK << 7)) { 
+	if (frac1 & (FLOAT32_HIDDEN_BIT_MASK << 7)) {
 		/* rounding overflow */
 		++exp1;
@@ -145,5 +145,5 @@
 	
 	/* Clear hidden bit and shift */
-	a.parts.fraction = ((frac1 >> 6) & (~FLOAT32_HIDDEN_BIT_MASK)); 
+	a.parts.fraction = ((frac1 >> 6) & (~FLOAT32_HIDDEN_BIT_MASK));
 	return a;
 }
@@ -190,5 +190,5 @@
 		
 		/* a is infinity and b not */
-		if (a.parts.exp == FLOAT64_MAX_EXPONENT) { 
+		if (a.parts.exp == FLOAT64_MAX_EXPONENT) {
 			return a;
 		}
@@ -203,5 +203,5 @@
 		/* both are denormalized */
 		frac1 += frac2;
-		if (frac1 & FLOAT64_HIDDEN_BIT_MASK) { 
+		if (frac1 & FLOAT64_HIDDEN_BIT_MASK) {
 			/* result is not denormalized */
 			a.parts.exp = 1;
@@ -217,5 +217,5 @@
 	if (exp2 == 0) {
 		/* ... is denormalized */
-		--expdiff;	
+		--expdiff;
 	} else {
 		/* is not denormalized */
@@ -242,7 +242,7 @@
 	
 	/* rounding - if first bit after fraction is set then round up */
-	frac1 += (0x1 << 5); 
-	
-	if (frac1 & (FLOAT64_HIDDEN_BIT_MASK << 7)) { 
+	frac1 += (0x1 << 5);
+	
+	if (frac1 & (FLOAT64_HIDDEN_BIT_MASK << 7)) {
 		/* rounding overflow */
 		++exp1;
Index: uspace/lib/softfloat/common.c
===================================================================
--- uspace/lib/softfloat/common.c	(revision 9d8b12da8c497c2a0001860cd8545439328c6071)
+++ uspace/lib/softfloat/common.c	(revision 3061bc129a855122d429fbba1e623a521aaa164c)
@@ -59,5 +59,5 @@
  * Take fraction shifted by 10 bits to the left, round it, normalize it
  * and detect exceptions
- * 
+ *
  * @param cexp Exponent with bias.
  * @param cfrac Fraction shifted 10 bits to the left with added hidden bit.
@@ -93,5 +93,5 @@
 		}
 	
-		cfrac += (0x1 << (64 - FLOAT64_FRACTION_SIZE - 3)); 
+		cfrac += (0x1 << (64 - FLOAT64_FRACTION_SIZE - 3));
 		
 		if (!(cfrac & (FLOAT64_HIDDEN_BIT_MASK << (64 - FLOAT64_FRACTION_SIZE - 1)))) {
@@ -99,7 +99,7 @@
 			    ((cfrac >> (64 - FLOAT64_FRACTION_SIZE - 2)) & (~FLOAT64_HIDDEN_BIT_MASK));
 			return result;
-		}	
+		}
 	} else {
-		cfrac += (0x1 << (64 - FLOAT64_FRACTION_SIZE - 3)); 
+		cfrac += (0x1 << (64 - FLOAT64_FRACTION_SIZE - 3));
 	}
 	
@@ -121,13 +121,13 @@
 	result.parts.exp = (uint32_t) cexp;
 	
-	result.parts.fraction = 
+	result.parts.fraction =
 	    ((cfrac >> (64 - FLOAT64_FRACTION_SIZE - 2)) & (~FLOAT64_HIDDEN_BIT_MASK));
 	
-	return result;	
+	return result;
 }
 
 /**
  * Take fraction, round it, normalize it and detect exceptions
- * 
+ *
  * @param cexp Exponent with bias.
  * @param cfrac_hi High part of the fraction shifted 14 bits to the left
@@ -139,5 +139,5 @@
  * @return Finished quadruple-precision float.
  */
-float128 finish_float128(int32_t cexp, uint64_t cfrac_hi, uint64_t cfrac_lo, 
+float128 finish_float128(int32_t cexp, uint64_t cfrac_hi, uint64_t cfrac_lo,
     char sign, uint64_t shift_out)
 {
@@ -228,5 +228,5 @@
 	result.parts.frac_lo = tmp_lo;
 
-	return result;	
+	return result;
 }
 
@@ -242,5 +242,5 @@
 }
 
-/** 
+/**
  * Counts leading zeroes in 32bit unsigned integer.
  *
@@ -290,5 +290,5 @@
 	(*fraction) += (0x1 << (32 - FLOAT32_FRACTION_SIZE - 3));
 	
-	if ((*fraction) & 
+	if ((*fraction) &
 	    (FLOAT32_HIDDEN_BIT_MASK << (32 - FLOAT32_FRACTION_SIZE - 1))) {
 		/* rounding overflow */
@@ -324,5 +324,5 @@
 	
 	/* See if there was a carry to bit 63. */
-	if ((*fraction) & 
+	if ((*fraction) &
 	    (FLOAT64_HIDDEN_BIT_MASK << (64 - FLOAT64_FRACTION_SIZE - 1))) {
 		/* rounding overflow */
@@ -589,5 +589,5 @@
 /**
  * Multiplication of two 64-bit unsigned integers.
- * 
+ *
  * @param a First input operand.
  * @param b Second input operand.
@@ -622,5 +622,5 @@
 /**
  * Multiplication of two 128-bit unsigned integers.
- * 
+ *
  * @param a_hi High part of the first input operand.
  * @param a_lo Low part of the first input operand.
@@ -656,5 +656,5 @@
  * Estimate the quotient of 128-bit unsigned divident and 64-bit unsigned
  * divisor.
- * 
+ *
  * @param a_hi High part of the divident.
  * @param a_lo Low part of the divident.
Index: uspace/lib/softfloat/comparison.c
===================================================================
--- uspace/lib/softfloat/comparison.c	(revision 9d8b12da8c497c2a0001860cd8545439328c6071)
+++ uspace/lib/softfloat/comparison.c	(revision 3061bc129a855122d429fbba1e623a521aaa164c)
@@ -257,5 +257,5 @@
  * @return 1 if a is lower than b, 0 otherwise.
  */
-int is_float32_lt(float32 a, float32 b) 
+int is_float32_lt(float32 a, float32 b)
 {
 	if (((a.bin | b.bin) & 0x7FFFFFFF) == 0) {
@@ -351,5 +351,5 @@
  * @return 1 if a is greater than b, 0 otherwise.
  */
-int is_float32_gt(float32 a, float32 b) 
+int is_float32_gt(float32 a, float32 b)
 {
 	if (((a.bin | b.bin) & 0x7FFFFFFF) == 0) {
Index: uspace/lib/softfloat/conversion.c
===================================================================
--- uspace/lib/softfloat/conversion.c	(revision 9d8b12da8c497c2a0001860cd8545439328c6071)
+++ uspace/lib/softfloat/conversion.c	(revision 3061bc129a855122d429fbba1e623a521aaa164c)
@@ -225,5 +225,5 @@
 		/* denormalized */
 		
-		frac = a.parts.fraction; 
+		frac = a.parts.fraction;
 		frac |= FLOAT64_HIDDEN_BIT_MASK; /* denormalize and set hidden bit */
 		
@@ -420,5 +420,5 @@
 	frac |= FLOAT32_HIDDEN_BIT_MASK;
 	/* shift fraction to left so hidden bit will be the most significant bit */
-	frac <<= 32 - FLOAT32_FRACTION_SIZE - 1; 
+	frac <<= 32 - FLOAT32_FRACTION_SIZE - 1;
 	
 	frac >>= 32 - (a.parts.exp - FLOAT32_BIAS) - 1;
@@ -606,5 +606,5 @@
 
 /*
- * FIXME: Im not sure what to return if overflow/underflow happens 
+ * FIXME: Im not sure what to return if overflow/underflow happens
  *  - now its the biggest or the smallest int
  */
@@ -625,5 +625,5 @@
 
 /*
- * FIXME: Im not sure what to return if overflow/underflow happens 
+ * FIXME: Im not sure what to return if overflow/underflow happens
  *  - now its the biggest or the smallest int
  */
Index: uspace/lib/softfloat/div.c
===================================================================
--- uspace/lib/softfloat/div.c	(revision 9d8b12da8c497c2a0001860cd8545439328c6071)
+++ uspace/lib/softfloat/div.c	(revision 3061bc129a855122d429fbba1e623a521aaa164c)
@@ -151,5 +151,5 @@
 	
 	cfrac = (afrac << 32) / bfrac;
-	if ((cfrac & 0x3F) == 0) { 
+	if ((cfrac & 0x3F) == 0) {
 		cfrac |= (bfrac * cfrac != afrac << 32);
 	}
@@ -195,5 +195,5 @@
 	}
 	
-	result.parts.fraction = ((cfrac >> 6) & (~FLOAT32_HIDDEN_BIT_MASK)); 
+	result.parts.fraction = ((cfrac >> 6) & (~FLOAT32_HIDDEN_BIT_MASK));
 	
 	return result;
@@ -208,9 +208,9 @@
  *
  */
-float64 div_float64(float64 a, float64 b) 
+float64 div_float64(float64 a, float64 b)
 {
 	float64 result;
 	int64_t aexp, bexp, cexp;
-	uint64_t afrac, bfrac, cfrac; 
+	uint64_t afrac, bfrac, cfrac;
 	uint64_t remlo, remhi;
 	uint64_t tmplo, tmphi;
@@ -291,5 +291,5 @@
 		/* normalize it*/
 		aexp++;
-		/* afrac is nonzero => it must stop */	
+		/* afrac is nonzero => it must stop */
 		while (!(afrac & FLOAT64_HIDDEN_BIT_MASK)) {
 			afrac <<= 1;
@@ -300,5 +300,5 @@
 	if (bexp == 0) {
 		bexp++;
-		/* bfrac is nonzero => it must stop */	
+		/* bfrac is nonzero => it must stop */
 		while (!(bfrac & FLOAT64_HIDDEN_BIT_MASK)) {
 			bfrac <<= 1;
@@ -315,5 +315,5 @@
 	}
 	
-	cexp = aexp - bexp + FLOAT64_BIAS - 2; 
+	cexp = aexp - bexp + FLOAT64_BIAS - 2;
 	
 	cfrac = div128est(afrac, 0x0ll, bfrac);
Index: uspace/lib/softfloat/mul.c
===================================================================
--- uspace/lib/softfloat/mul.c	(revision 9d8b12da8c497c2a0001860cd8545439328c6071)
+++ uspace/lib/softfloat/mul.c	(revision 3061bc129a855122d429fbba1e623a521aaa164c)
@@ -181,5 +181,5 @@
 	}
 	
-	result.parts.exp = exp; 
+	result.parts.exp = exp;
 	result.parts.fraction = frac1 & ((1 << FLOAT32_FRACTION_SIZE) - 1);
 	
