Index: uspace/lib/softfloat/generic/mul.c
===================================================================
--- uspace/lib/softfloat/generic/mul.c	(revision c67aff2b73c9636ea0c229cdbf3bfc48af966545)
+++ uspace/lib/softfloat/generic/mul.c	(revision 81716eb65927790775a090098b80690cb57378b6)
@@ -39,27 +39,28 @@
 #include <common.h>
 
-/**
- * Multiply two single-precision floats.
+/** Multiply two single-precision floats.
  *
  * @param a First input operand.
  * @param b Second input operand.
+ *
  * @return Result of multiplication.
- */
-float32 mulFloat32(float32 a, float32 b)
+ *
+ */
+float32 mul_float32(float32 a, float32 b)
 {
 	float32 result;
 	uint64_t frac1, frac2;
 	int32_t exp;
-
+	
 	result.parts.sign = a.parts.sign ^ b.parts.sign;
 	
-	if (isFloat32NaN(a) || isFloat32NaN(b)) {
+	if (is_float32_nan(a) || is_float32_nan(b)) {
 		/* TODO: fix SigNaNs */
-		if (isFloat32SigNaN(a)) {
+		if (is_float32_signan(a)) {
 			result.parts.fraction = a.parts.fraction;
 			result.parts.exp = a.parts.exp;
 			return result;
 		}
-		if (isFloat32SigNaN(b)) { /* TODO: fix SigNaN */
+		if (is_float32_signan(b)) { /* TODO: fix SigNaN */
 			result.parts.fraction = b.parts.fraction;
 			result.parts.exp = b.parts.exp;
@@ -67,12 +68,12 @@
 		}
 		/* set NaN as result */
-		result.binary = FLOAT32_NAN;
-		return result;
-	}
-		
-	if (isFloat32Infinity(a)) { 
-		if (isFloat32Zero(b)) {
-			/* FIXME: zero * infinity */
-			result.binary = FLOAT32_NAN;
+		result.bin = FLOAT32_NAN;
+		return result;
+	}
+	
+	if (is_float32_infinity(a)) {
+		if (is_float32_zero(b)) {
+			/* FIXME: zero * infinity */
+			result.bin = FLOAT32_NAN;
 			return result;
 		}
@@ -81,9 +82,9 @@
 		return result;
 	}
-
-	if (isFloat32Infinity(b)) { 
-		if (isFloat32Zero(a)) {
-			/* FIXME: zero * infinity */
-			result.binary = FLOAT32_NAN;
+	
+	if (is_float32_infinity(b)) {
+		if (is_float32_zero(a)) {
+			/* FIXME: zero * infinity */
+			result.bin = FLOAT32_NAN;
 			return result;
 		}
@@ -92,5 +93,5 @@
 		return result;
 	}
-
+	
 	/* exp is signed so we can easy detect underflow */
 	exp = a.parts.exp + b.parts.exp;
@@ -100,5 +101,5 @@
 		/* FIXME: overflow */
 		/* set infinity as result */
-		result.binary = FLOAT32_INF;
+		result.bin = FLOAT32_INF;
 		result.parts.sign = a.parts.sign ^ b.parts.sign;
 		return result;
@@ -121,5 +122,5 @@
 	
 	frac2 = b.parts.fraction;
-
+	
 	if (b.parts.exp > 0) {
 		frac2 |= FLOAT32_HIDDEN_BIT_MASK;
@@ -127,26 +128,28 @@
 		++exp;
 	}
-
+	
 	frac1 <<= 1; /* one bit space for rounding */
-
+	
 	frac1 = frac1 * frac2;
-
+	
 	/* round and return */
-	while ((exp < FLOAT32_MAX_EXPONENT) && (frac1 >= (1 << (FLOAT32_FRACTION_SIZE + 2)))) { 
+	while ((exp < FLOAT32_MAX_EXPONENT) &&
+	    (frac1 >= (1 << (FLOAT32_FRACTION_SIZE + 2)))) {
 		/* 23 bits of fraction + one more for hidden bit (all shifted 1 bit left) */
 		++exp;
 		frac1 >>= 1;
 	}
-
+	
 	/* rounding */
 	/* ++frac1; FIXME: not works - without it is ok */
 	frac1 >>= 1; /* shift off rounding space */
 	
-	if ((exp < FLOAT32_MAX_EXPONENT) && (frac1 >= (1 << (FLOAT32_FRACTION_SIZE + 1)))) {
+	if ((exp < FLOAT32_MAX_EXPONENT) &&
+	    (frac1 >= (1 << (FLOAT32_FRACTION_SIZE + 1)))) {
 		++exp;
 		frac1 >>= 1;
 	}
-
-	if (exp >= FLOAT32_MAX_EXPONENT) {	
+	
+	if (exp >= FLOAT32_MAX_EXPONENT) {
 		/* TODO: fix overflow */
 		/* return infinity*/
@@ -157,6 +160,6 @@
 	
 	exp -= FLOAT32_FRACTION_SIZE;
-
-	if (exp <= FLOAT32_FRACTION_SIZE) { 
+	
+	if (exp <= FLOAT32_FRACTION_SIZE) {
 		/* denormalized number */
 		frac1 >>= 1; /* denormalize */
@@ -175,30 +178,31 @@
 	result.parts.fraction = frac1 & ((1 << FLOAT32_FRACTION_SIZE) - 1);
 	
-	return result;	
+	return result;
 }
 
-/**
- * Multiply two double-precision floats.
+/** Multiply two double-precision floats.
  *
  * @param a First input operand.
  * @param b Second input operand.
+ *
  * @return Result of multiplication.
- */
-float64 mulFloat64(float64 a, float64 b)
+ *
+ */
+float64 mul_float64(float64 a, float64 b)
 {
 	float64 result;
 	uint64_t frac1, frac2;
 	int32_t exp;
-
+	
 	result.parts.sign = a.parts.sign ^ b.parts.sign;
 	
-	if (isFloat64NaN(a) || isFloat64NaN(b)) {
+	if (is_float64_nan(a) || is_float64_nan(b)) {
 		/* TODO: fix SigNaNs */
-		if (isFloat64SigNaN(a)) {
+		if (is_float64_signan(a)) {
 			result.parts.fraction = a.parts.fraction;
 			result.parts.exp = a.parts.exp;
 			return result;
 		}
-		if (isFloat64SigNaN(b)) { /* TODO: fix SigNaN */
+		if (is_float64_signan(b)) { /* TODO: fix SigNaN */
 			result.parts.fraction = b.parts.fraction;
 			result.parts.exp = b.parts.exp;
@@ -206,12 +210,12 @@
 		}
 		/* set NaN as result */
-		result.binary = FLOAT64_NAN;
-		return result;
-	}
-		
-	if (isFloat64Infinity(a)) { 
-		if (isFloat64Zero(b)) {
-			/* FIXME: zero * infinity */
-			result.binary = FLOAT64_NAN;
+		result.bin = FLOAT64_NAN;
+		return result;
+	}
+	
+	if (is_float64_infinity(a)) {
+		if (is_float64_zero(b)) {
+			/* FIXME: zero * infinity */
+			result.bin = FLOAT64_NAN;
 			return result;
 		}
@@ -220,9 +224,9 @@
 		return result;
 	}
-
-	if (isFloat64Infinity(b)) { 
-		if (isFloat64Zero(a)) {
-			/* FIXME: zero * infinity */
-			result.binary = FLOAT64_NAN;
+	
+	if (is_float64_infinity(b)) {
+		if (is_float64_zero(a)) {
+			/* FIXME: zero * infinity */
+			result.bin = FLOAT64_NAN;
 			return result;
 		}
@@ -231,10 +235,10 @@
 		return result;
 	}
-
+	
 	/* exp is signed so we can easy detect underflow */
 	exp = a.parts.exp + b.parts.exp - FLOAT64_BIAS;
 	
 	frac1 = a.parts.fraction;
-
+	
 	if (a.parts.exp > 0) {
 		frac1 |= FLOAT64_HIDDEN_BIT_MASK;
@@ -244,5 +248,5 @@
 	
 	frac2 = b.parts.fraction;
-
+	
 	if (b.parts.exp > 0) {
 		frac2 |= FLOAT64_HIDDEN_BIT_MASK;
@@ -250,10 +254,10 @@
 		++exp;
 	}
-
+	
 	frac1 <<= (64 - FLOAT64_FRACTION_SIZE - 1);
 	frac2 <<= (64 - FLOAT64_FRACTION_SIZE - 2);
-
+	
 	mul64(frac1, frac2, &frac1, &frac2);
-
+	
 	frac1 |= (frac2 != 0);
 	if (frac1 & (0x1ll << 62)) {
@@ -261,27 +265,28 @@
 		exp--;
 	}
-
-	result = finishFloat64(exp, frac1, result.parts.sign);
+	
+	result = finish_float64(exp, frac1, result.parts.sign);
 	return result;
 }
 
-/**
- * Multiply two quadruple-precision floats.
+/** Multiply two quadruple-precision floats.
  *
  * @param a First input operand.
  * @param b Second input operand.
+ *
  * @return Result of multiplication.
- */
-float128 mulFloat128(float128 a, float128 b)
+ *
+ */
+float128 mul_float128(float128 a, float128 b)
 {
 	float128 result;
 	uint64_t frac1_hi, frac1_lo, frac2_hi, frac2_lo, tmp_hi, tmp_lo;
 	int32_t exp;
-
+	
 	result.parts.sign = a.parts.sign ^ b.parts.sign;
-
-	if (isFloat128NaN(a) || isFloat128NaN(b)) {
+	
+	if (is_float128_nan(a) || is_float128_nan(b)) {
 		/* TODO: fix SigNaNs */
-		if (isFloat128SigNaN(a)) {
+		if (is_float128_signan(a)) {
 			result.parts.frac_hi = a.parts.frac_hi;
 			result.parts.frac_lo = a.parts.frac_lo;
@@ -289,5 +294,5 @@
 			return result;
 		}
-		if (isFloat128SigNaN(b)) { /* TODO: fix SigNaN */
+		if (is_float128_signan(b)) { /* TODO: fix SigNaN */
 			result.parts.frac_hi = b.parts.frac_hi;
 			result.parts.frac_lo = b.parts.frac_lo;
@@ -296,14 +301,14 @@
 		}
 		/* set NaN as result */
-		result.binary.hi = FLOAT128_NAN_HI;
-		result.binary.lo = FLOAT128_NAN_LO;
-		return result;
-	}
-
-	if (isFloat128Infinity(a)) {
-		if (isFloat128Zero(b)) {
-			/* FIXME: zero * infinity */
-			result.binary.hi = FLOAT128_NAN_HI;
-			result.binary.lo = FLOAT128_NAN_LO;
+		result.bin.hi = FLOAT128_NAN_HI;
+		result.bin.lo = FLOAT128_NAN_LO;
+		return result;
+	}
+	
+	if (is_float128_infinity(a)) {
+		if (is_float128_zero(b)) {
+			/* FIXME: zero * infinity */
+			result.bin.hi = FLOAT128_NAN_HI;
+			result.bin.lo = FLOAT128_NAN_LO;
 			return result;
 		}
@@ -313,10 +318,10 @@
 		return result;
 	}
-
-	if (isFloat128Infinity(b)) {
-		if (isFloat128Zero(a)) {
-			/* FIXME: zero * infinity */
-			result.binary.hi = FLOAT128_NAN_HI;
-			result.binary.lo = FLOAT128_NAN_LO;
+	
+	if (is_float128_infinity(b)) {
+		if (is_float128_zero(a)) {
+			/* FIXME: zero * infinity */
+			result.bin.hi = FLOAT128_NAN_HI;
+			result.bin.lo = FLOAT128_NAN_LO;
 			return result;
 		}
@@ -326,22 +331,22 @@
 		return result;
 	}
-
+	
 	/* exp is signed so we can easy detect underflow */
 	exp = a.parts.exp + b.parts.exp - FLOAT128_BIAS - 1;
-
+	
 	frac1_hi = a.parts.frac_hi;
 	frac1_lo = a.parts.frac_lo;
-
+	
 	if (a.parts.exp > 0) {
 		or128(frac1_hi, frac1_lo,
-	        FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO,
-	        &frac1_hi, &frac1_lo);
-	} else {
-		++exp;
-	}
-
+		    FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO,
+		    &frac1_hi, &frac1_lo);
+	} else {
+		++exp;
+	}
+	
 	frac2_hi = b.parts.frac_hi;
 	frac2_lo = b.parts.frac_lo;
-
+	
 	if (b.parts.exp > 0) {
 		or128(frac2_hi, frac2_lo,
@@ -351,8 +356,8 @@
 		++exp;
 	}
-
+	
 	lshift128(frac2_hi, frac2_lo,
 	    128 - FLOAT128_FRACTION_SIZE, &frac2_hi, &frac2_lo);
-
+	
 	tmp_hi = frac1_hi;
 	tmp_lo = frac1_lo;
@@ -361,5 +366,5 @@
 	add128(frac1_hi, frac1_lo, tmp_hi, tmp_lo, &frac1_hi, &frac1_lo);
 	frac2_hi |= (frac2_lo != 0x0ll);
-
+	
 	if ((FLOAT128_HIDDEN_BIT_MASK_HI << 1) <= frac1_hi) {
 		frac2_hi >>= 1;
@@ -370,6 +375,6 @@
 		++exp;
 	}
-
-	result = finishFloat128(exp, frac1_hi, frac1_lo, result.parts.sign, frac2_hi);
+	
+	result = finish_float128(exp, frac1_hi, frac1_lo, result.parts.sign, frac2_hi);
 	return result;
 }
