Index: softfloat/generic/add.c
===================================================================
--- softfloat/generic/add.c	(revision b7e65d4a00b31b5bc17e54551c9d99653b2999f9)
+++ softfloat/generic/add.c	(revision 12665431deed59bc8d76f61f17368d17c55d2bcb)
@@ -36,10 +36,10 @@
 {
 	int expdiff;
-	__u32 exp1, exp2,mant1, mant2;
+	__u32 exp1, exp2,frac1, frac2;
 	
 	expdiff = a.parts.exp - b.parts.exp;
 	if (expdiff < 0) {
 		if (isFloat32NaN(b)) {
-			//TODO: fix SigNaN
+			/* TODO: fix SigNaN */
 			if (isFloat32SigNaN(b)) {
 			};
@@ -52,15 +52,15 @@
 		}
 		
-		mant1 = b.parts.mantisa;
+		frac1 = b.parts.fraction;
 		exp1 = b.parts.exp;
-		mant2 = a.parts.mantisa;
+		frac2 = a.parts.fraction;
 		exp2 = a.parts.exp;
 		expdiff *= -1;
 	} else {
-		if (isFloat32NaN(a)) {
-			//TODO: fix SigNaN
+		if ((isFloat32NaN(a)) || (isFloat32NaN(b))) {
+			/* TODO: fix SigNaN */
 			if (isFloat32SigNaN(a) || isFloat32SigNaN(b)) {
 			};
-			return a;
+			return (isFloat32NaN(a)?a:b);
 		};
 		
@@ -69,7 +69,7 @@
 		}
 		
-		mant1 = a.parts.mantisa;
+		frac1 = a.parts.fraction;
 		exp1 = a.parts.exp;
-		mant2 = b.parts.mantisa;
+		frac2 = b.parts.fraction;
 		exp2 = b.parts.exp;
 	};
@@ -77,14 +77,14 @@
 	if (exp1 == 0) {
 		/* both are denormalized */
-		mant1 += mant2;
-		if (mant1 & FLOAT32_HIDDEN_BIT_MASK ) {
+		frac1 += frac2;
+		if (frac1 & FLOAT32_HIDDEN_BIT_MASK ) {
 			/* result is not denormalized */
 			a.parts.exp = 1;
 		};
-		a.parts.mantisa = mant1;
+		a.parts.fraction = frac1;
 		return a;
 	};
 	
-	mant1 |= FLOAT32_HIDDEN_BIT_MASK; //add hidden bit
+	frac1 |= FLOAT32_HIDDEN_BIT_MASK; /* add hidden bit */
 
 	if (exp2 == 0) {
@@ -93,35 +93,41 @@
 	} else {
 		/* add hidden bit to second operand */
-		mant2 |= FLOAT32_HIDDEN_BIT_MASK; 
+		frac2 |= FLOAT32_HIDDEN_BIT_MASK; 
 	};
 	
 	/* create some space for rounding */
-	mant1 <<= 6;
-	mant2 <<= 6;
-	
-	if (expdiff > (FLOAT32_MANTISA_SIZE + 1) ) {
-	     goto done;	
-	     };
-	
-	mant2 >>= expdiff;
-	mant1 += mant2;
-done:
-	if (mant1 & (FLOAT32_HIDDEN_BIT_MASK << 7) ) {
-		++exp1;
-		mant1 >>= 1;
-	};
-	
-	/* rounding - if first bit after mantisa is set then round up */
-	mant1 += (0x1 << 5);
-	
-	if (mant1 & (FLOAT32_HIDDEN_BIT_MASK << 7)) { 
-		++exp1;
-		mant1 >>= 1;
-	};
+	frac1 <<= 6;
+	frac2 <<= 6;
+	
+	if (expdiff < (FLOAT32_FRACTION_SIZE + 2) ) {
+		frac2 >>= expdiff;
+		frac1 += frac2;
+		};
+	
+	if (frac1 & (FLOAT32_HIDDEN_BIT_MASK << 7) ) {
+		++exp1;
+		frac1 >>= 1;
+	};
+	
+	/* rounding - if first bit after fraction is set then round up */
+	frac1 += (0x1 << 5);
+	
+	if (frac1 & (FLOAT32_HIDDEN_BIT_MASK << 7)) { 
+		/* rounding overflow */
+		++exp1;
+		frac1 >>= 1;
+	};
+	
+	if ((a.parts.exp == FLOAT32_MAX_EXPONENT ) || (a.parts.exp < exp1)) {
+			/* overflow - set infinity as result */
+			a.parts.exp = FLOAT32_MAX_EXPONENT;
+			a.parts.fraction = 0;
+			return a;
+			}
 	
 	a.parts.exp = exp1;
 	
 	/*Clear hidden bit and shift */
-	a.parts.mantisa = ((mant1 >> 6) & (~FLOAT32_HIDDEN_BIT_MASK)) ; 
+	a.parts.fraction = ((frac1 >> 6) & (~FLOAT32_HIDDEN_BIT_MASK)) ; 
 	return a;
 }
@@ -134,10 +140,10 @@
 	int expdiff;
 	__u32 exp1, exp2;
-	__u64 mant1, mant2;
+	__u64 frac1, frac2;
 	
 	expdiff = a.parts.exp - b.parts.exp;
 	if (expdiff < 0) {
 		if (isFloat64NaN(b)) {
-			//TODO: fix SigNaN
+			/* TODO: fix SigNaN */
 			if (isFloat64SigNaN(b)) {
 			};
@@ -151,12 +157,12 @@
 		}
 		
-		mant1 = b.parts.mantisa;
+		frac1 = b.parts.fraction;
 		exp1 = b.parts.exp;
-		mant2 = a.parts.mantisa;
+		frac2 = a.parts.fraction;
 		exp2 = a.parts.exp;
 		expdiff *= -1;
 	} else {
 		if (isFloat64NaN(a)) {
-			//TODO: fix SigNaN
+			/* TODO: fix SigNaN */
 			if (isFloat64SigNaN(a) || isFloat64SigNaN(b)) {
 			};
@@ -169,7 +175,7 @@
 		}
 		
-		mant1 = a.parts.mantisa;
+		frac1 = a.parts.fraction;
 		exp1 = a.parts.exp;
-		mant2 = b.parts.mantisa;
+		frac2 = b.parts.fraction;
 		exp2 = b.parts.exp;
 	};
@@ -177,15 +183,15 @@
 	if (exp1 == 0) {
 		/* both are denormalized */
-		mant1 += mant2;
-		if (mant1 & FLOAT64_HIDDEN_BIT_MASK) { 
+		frac1 += frac2;
+		if (frac1 & FLOAT64_HIDDEN_BIT_MASK) { 
 			/* result is not denormalized */
 			a.parts.exp = 1;
 		};
-		a.parts.mantisa = mant1;
+		a.parts.fraction = frac1;
 		return a;
 	};
 	
-	/* add hidden bit - mant1 is sure not denormalized */
-	mant1 |= FLOAT64_HIDDEN_BIT_MASK;
+	/* add hidden bit - frac1 is sure not denormalized */
+	frac1 |= FLOAT64_HIDDEN_BIT_MASK;
 
 	/* second operand ... */
@@ -195,34 +201,40 @@
 	} else {
 		/* is not denormalized */
-		mant2 |= FLOAT64_HIDDEN_BIT_MASK;
+		frac2 |= FLOAT64_HIDDEN_BIT_MASK;
 	};
 	
 	/* create some space for rounding */
-	mant1 <<= 6;
-	mant2 <<= 6;
-	
-	if (expdiff > (FLOAT64_MANTISA_SIZE + 1) ) {
-	     goto done;	
-	     };
-	
-	mant2 >>= expdiff;
-	mant1 += mant2;
-done:
-	if (mant1 & (FLOAT64_HIDDEN_BIT_MASK << 7) ) {
-		++exp1;
-		mant1 >>= 1;
-	};
-	
-	/* rounding - if first bit after mantisa is set then round up */
-	mant1 += (0x1 << 5); 
-	
-	if (mant1 & (FLOAT64_HIDDEN_BIT_MASK << 7)) { 
-		++exp1;
-		mant1 >>= 1;
-	};
+	frac1 <<= 6;
+	frac2 <<= 6;
+	
+	if (expdiff < (FLOAT64_FRACTION_SIZE + 2) ) {
+		frac2 >>= expdiff;
+		frac1 += frac2;
+		};
+	
+	if (frac1 & (FLOAT64_HIDDEN_BIT_MASK << 7) ) {
+		++exp1;
+		frac1 >>= 1;
+	};
+	
+	/* rounding - if first bit after fraction is set then round up */
+	frac1 += (0x1 << 5); 
+	
+	if (frac1 & (FLOAT64_HIDDEN_BIT_MASK << 7)) { 
+		/* rounding overflow */
+		++exp1;
+		frac1 >>= 1;
+	};
+	
+	if ((a.parts.exp == FLOAT64_MAX_EXPONENT ) || (a.parts.exp < exp1)) {
+			/* overflow - set infinity as result */
+			a.parts.exp = FLOAT64_MAX_EXPONENT;
+			a.parts.fraction = 0;
+			return a;
+			}
 	
 	a.parts.exp = exp1;
 	/*Clear hidden bit and shift */
-	a.parts.mantisa = ( (mant1 >> 6 ) & (~FLOAT64_HIDDEN_BIT_MASK));
+	a.parts.fraction = ( (frac1 >> 6 ) & (~FLOAT64_HIDDEN_BIT_MASK));
 	return a;
 }
Index: softfloat/generic/comparison.c
===================================================================
--- softfloat/generic/comparison.c	(revision b7e65d4a00b31b5bc17e54551c9d99653b2999f9)
+++ softfloat/generic/comparison.c	(revision 12665431deed59bc8d76f61f17368d17c55d2bcb)
@@ -31,31 +31,31 @@
 
 inline int isFloat32NaN(float32 f)
-{	/* NaN : exp = 0xff and nonzero mantisa */
-	return ((f.parts.exp==0xFF)&&(f.parts.mantisa));
+{	/* NaN : exp = 0xff and nonzero fraction */
+	return ((f.parts.exp==0xFF)&&(f.parts.fraction));
 };
 
 inline int isFloat64NaN(float64 d)
-{	/* NaN : exp = 0x7ff and nonzero mantisa */
-	return ((d.parts.exp==0x7FF)&&(d.parts.mantisa));
+{	/* NaN : exp = 0x7ff and nonzero fraction */
+	return ((d.parts.exp==0x7FF)&&(d.parts.fraction));
 };
 
 inline int isFloat32SigNaN(float32 f)
-{	/* SigNaN : exp = 0xff mantisa = 0xxxxx..x (binary), where at least one x is nonzero */
-	return ((f.parts.exp==0xFF)&&(f.parts.mantisa<0x400000)&&(f.parts.mantisa));
+{	/* 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));
 };
 
 inline int isFloat64SigNaN(float64 d)
-{	/* SigNaN : exp = 0x7ff mantisa = 0xxxxx..x (binary), where at least one x is nonzero */
-	return ((d.parts.exp==0x7FF)&&(d.parts.mantisa)&&(d.parts.mantisa<0x8000000000000ll));
+{	/* 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));
 };
 
 inline int isFloat32Infinity(float32 f) 
 {
-	return ((f.parts.exp==0xFF)&&(f.parts.mantisa==0x0));
+	return ((f.parts.exp==0xFF)&&(f.parts.fraction==0x0));
 };
 
 inline int isFloat64Infinity(float64 d) 
 {
-	return ((d.parts.exp==0x7FF)&&(d.parts.mantisa==0x0));
+	return ((d.parts.exp==0x7FF)&&(d.parts.fraction==0x0));
 };
 
Index: softfloat/generic/conversion.c
===================================================================
--- softfloat/generic/conversion.c	(revision b7e65d4a00b31b5bc17e54551c9d99653b2999f9)
+++ softfloat/generic/conversion.c	(revision 12665431deed59bc8d76f61f17368d17c55d2bcb)
@@ -33,9 +33,9 @@
 {
 	float64 result;
-	__u64 mant;
+	__u64 frac;
 	
 	result.parts.sign = a.parts.sign;
-	result.parts.mantisa = a.parts.mantisa;
-	result.parts.mantisa <<= (FLOAT64_MANTISA_SIZE - FLOAT32_MANTISA_SIZE );
+	result.parts.fraction = a.parts.fraction;
+	result.parts.fraction <<= (FLOAT64_FRACTION_SIZE - FLOAT32_FRACTION_SIZE );
 	
 	if ((isFloat32Infinity(a))||(isFloat32NaN(a))) {
@@ -49,18 +49,18 @@
 		/* normalize denormalized numbers */
 
-		if (result.parts.mantisa == 0ll) { /* fix zero */
+		if (result.parts.fraction == 0ll) { /* fix zero */
 			result.parts.exp = 0ll;
 			return result;
 		}
 			
-		mant = result.parts.mantisa;
+		frac = result.parts.fraction;
 		
-		while (!(mant & (0x10000000000000ll))) {
-			mant <<= 1;
+		while (!(frac & (0x10000000000000ll))) {
+			frac <<= 1;
 			--result.parts.exp;
 		};
 		
 		++result.parts.exp;
-		result.parts.mantisa = mant;
+		result.parts.fraction = frac;
 	};
 	
@@ -73,5 +73,5 @@
 	float32 result;
 	__s32 exp;
-	__u64 mant;
+	__u64 frac;
 	
 	result.parts.sign = a.parts.sign;
@@ -82,14 +82,14 @@
 		
 		if (isFloat64SigNaN(a)) {
-			result.parts.mantisa = 0x800000; /* set first bit of mantisa nonzero */
+			result.parts.fraction = 0x800000; /* set first bit of fraction nonzero */
 			return result;
 		}
 	
-		result.parts.mantisa = 0x1; /* mantisa nonzero but its first bit is zero */
+		result.parts.fraction = 0x1; /* fraction nonzero but its first bit is zero */
 		return result;
 	};
 
 	if (isFloat64Infinity(a)) {
-		result.parts.mantisa = 0;
+		result.parts.fraction = 0;
 		result.parts.exp = 0xFF;
 		return result;
@@ -100,5 +100,5 @@
 	if (exp >= 0xFF) {
 		/*FIXME: overflow*/
-		result.parts.mantisa = 0;
+		result.parts.fraction = 0;
 		result.parts.exp = 0xFF;
 		return result;
@@ -111,7 +111,7 @@
 		
 		exp *= -1;	
-		if (exp > FLOAT32_MANTISA_SIZE ) {
+		if (exp > FLOAT32_FRACTION_SIZE ) {
 			/* FIXME: underflow */
-			result.parts.mantisa = 0;
+			result.parts.fraction = 0;
 			return result;
 		};
@@ -119,14 +119,14 @@
 		/* denormalized */
 		
-		mant = a.parts.mantisa; 
-		mant |= 0x10000000000000ll; /* denormalize and set hidden bit */
+		frac = a.parts.fraction; 
+		frac |= 0x10000000000000ll; /* denormalize and set hidden bit */
 		
-		mant >>= (FLOAT64_MANTISA_SIZE - FLOAT32_MANTISA_SIZE + 1);
+		frac >>= (FLOAT64_FRACTION_SIZE - FLOAT32_FRACTION_SIZE + 1);
 		
 		while (exp > 0) {
 			--exp;
-			mant >>= 1;
+			frac >>= 1;
 		};
-		result.parts.mantisa = mant;
+		result.parts.fraction = frac;
 		
 		return result;
@@ -134,5 +134,5 @@
 
 	result.parts.exp = exp;
-	result.parts.mantisa = a.parts.mantisa >> (FLOAT64_MANTISA_SIZE - FLOAT32_MANTISA_SIZE);
+	result.parts.fraction = a.parts.fraction >> (FLOAT64_FRACTION_SIZE - FLOAT32_FRACTION_SIZE);
 	return result;
 };
Index: softfloat/generic/div.c
===================================================================
--- softfloat/generic/div.c	(revision b7e65d4a00b31b5bc17e54551c9d99653b2999f9)
+++ softfloat/generic/div.c	(revision 12665431deed59bc8d76f61f17368d17c55d2bcb)
@@ -33,6 +33,155 @@
 float32 divFloat32(float32 a, float32 b) 
 {
-/* TODO: */
+	float32 result;
+	__s32 aexp, bexp, cexp;
+	__u64 afrac, bfrac, cfrac;
 	
+	result.parts.sign = a.parts.sign ^ b.parts.sign;
+	
+	if (isFloat32NaN(a)) {
+		if (isFloat32SigNaN(a)) {
+			/*FIXME: SigNaN*/
+		}
+		/*NaN*/
+		return a;
+	}
+	
+	if (isFloat32NaN(b)) {
+		if (isFloat32SigNaN(b)) {
+			/*FIXME: SigNaN*/
+		}
+		/*NaN*/
+		return b;
+	}
+	
+	if (isFloat32Infinity(a)) {
+		if (isFloat32Infinity(b)) {
+			/*FIXME: inf / inf */
+			result.binary = FLOAT32_NAN;
+			return result;
+		}
+		/* inf / num */
+		result.parts.exp = a.parts.exp;
+		result.parts.fraction = a.parts.fraction;
+		return result;
+	}
+
+	if (isFloat32Infinity(b)) {
+		if (isFloat32Zero(a)) {
+			/* FIXME 0 / inf */
+			result.parts.exp = 0;
+			result.parts.fraction = 0;
+			return result;
+		}
+		/* FIXME: num / inf*/
+		result.parts.exp = 0;
+		result.parts.fraction = 0;
+		return result;
+	}
+	
+	if (isFloat32Zero(b)) {
+		if (isFloat32Zero(a)) {
+			/*FIXME: 0 / 0*/
+			result.binary = FLOAT32_NAN;
+			return result;
+		}
+		/* FIXME: division by zero */
+		result.parts.exp = 0;
+		result.parts.fraction = 0;
+		return result;
+	}
+
+	
+	afrac = a.parts.fraction;
+	aexp = a.parts.exp;
+	bfrac = b.parts.fraction;
+	bexp = b.parts.exp;
+	
+	/* denormalized numbers */
+	if (aexp == 0) {
+		if (afrac == 0) {
+		result.parts.exp = 0;
+		result.parts.fraction = 0;
+		return result;
+		}
+		/* normalize it*/
+		
+		afrac <<= 1;
+			/* afrac is nonzero => it must stop */	
+		while (! (afrac & FLOAT32_HIDDEN_BIT_MASK) ) {
+			afrac <<= 1;
+			aexp--;
+		}
+	}
+
+	if (bexp == 0) {
+		bfrac <<= 1;
+			/* bfrac is nonzero => it must stop */	
+		while (! (bfrac & FLOAT32_HIDDEN_BIT_MASK) ) {
+			bfrac <<= 1;
+			bexp--;
+		}
+	}
+
+	afrac =	(afrac | FLOAT32_HIDDEN_BIT_MASK ) << (32 - FLOAT32_FRACTION_SIZE - 1 );
+	bfrac =	(bfrac | FLOAT32_HIDDEN_BIT_MASK ) << (32 - FLOAT32_FRACTION_SIZE );
+
+	if ( bfrac <= (afrac << 1) ) {
+		afrac >>= 1;
+		aexp++;
+	}
+	
+	cexp = aexp - bexp + FLOAT32_BIAS - 2;
+	
+	cfrac = (afrac << 32) / bfrac;
+	if ((  cfrac & 0x3F ) == 0) { 
+		cfrac |= ( bfrac * cfrac != afrac << 32 );
+	}
+	
+	/* pack and round */
+	
+	/* TODO: find first nonzero digit and shift result and detect possibly underflow */
+	while ((cexp > 0) && (cfrac) && (!(cfrac & (FLOAT32_HIDDEN_BIT_MASK << 7 )))) {
+		cexp--;
+		cfrac <<= 1;
+			/* TODO: fix underflow */
+	};
+	
+	
+	cfrac += (0x1 << 6); /* FIXME: 7 is not sure*/
+	
+	if (cfrac & (FLOAT32_HIDDEN_BIT_MASK << 7)) {
+		++cexp;
+		cfrac >>= 1;
+		}	
+
+	/* check overflow */
+	if (cexp >= FLOAT32_MAX_EXPONENT ) {
+		/* FIXME: overflow, return infinity */
+		result.parts.exp = FLOAT32_MAX_EXPONENT;
+		result.parts.fraction = 0;
+		return result;
+	}
+
+	if (cexp < 0) {
+		/* FIXME: underflow */
+		result.parts.exp = 0;
+		if ((cexp + FLOAT32_FRACTION_SIZE) < 0) {
+			result.parts.fraction = 0;
+			return result;
+		}
+		cfrac >>= 1;
+		while (cexp < 0) {
+			cexp ++;
+			cfrac >>= 1;
+		}
+		
+	} else {
+		result.parts.exp = (__u32)cexp;
+	}
+	
+	result.parts.fraction = ((cfrac >> 6) & (~FLOAT32_HIDDEN_BIT_MASK)); 
+	
+	return result;	
 }
 
Index: softfloat/generic/mul.c
===================================================================
--- softfloat/generic/mul.c	(revision b7e65d4a00b31b5bc17e54551c9d99653b2999f9)
+++ softfloat/generic/mul.c	(revision 12665431deed59bc8d76f61f17368d17c55d2bcb)
@@ -37,5 +37,5 @@
 {
 	float32 result;
-	__u64 mant1, mant2;
+	__u64 frac1, frac2;
 	__s32 exp;
 
@@ -45,10 +45,10 @@
 		/* TODO: fix SigNaNs */
 		if (isFloat32SigNaN(a)) {
-			result.parts.mantisa = a.parts.mantisa;
+			result.parts.fraction = a.parts.fraction;
 			result.parts.exp = a.parts.exp;
 			return result;
 		};
 		if (isFloat32SigNaN(b)) { /* TODO: fix SigNaN */
-			result.parts.mantisa = b.parts.mantisa;
+			result.parts.fraction = b.parts.fraction;
 			result.parts.exp = b.parts.exp;
 			return result;
@@ -65,5 +65,5 @@
 			return result;
 		}
-		result.parts.mantisa = a.parts.mantisa;
+		result.parts.fraction = a.parts.fraction;
 		result.parts.exp = a.parts.exp;
 		return result;
@@ -76,5 +76,5 @@
 			return result;
 		}
-		result.parts.mantisa = b.parts.mantisa;
+		result.parts.fraction = b.parts.fraction;
 		result.parts.exp = b.parts.exp;
 		return result;
@@ -96,42 +96,42 @@
 		/* FIXME: underflow */
 		/* return signed zero */
-		result.parts.mantisa = 0x0;
+		result.parts.fraction = 0x0;
 		result.parts.exp = 0x0;
 		return result;
 	};
 	
-	mant1 = a.parts.mantisa;
+	frac1 = a.parts.fraction;
 	if (a.parts.exp > 0) {
-		mant1 |= FLOAT32_HIDDEN_BIT_MASK;
+		frac1 |= FLOAT32_HIDDEN_BIT_MASK;
 	} else {
 		++exp;
 	};
 	
-	mant2 = b.parts.mantisa;
+	frac2 = b.parts.fraction;
 
 	if (b.parts.exp > 0) {
-		mant2 |= FLOAT32_HIDDEN_BIT_MASK;
+		frac2 |= FLOAT32_HIDDEN_BIT_MASK;
 	} else {
 		++exp;
 	};
 
-	mant1 <<= 1; /* one bit space for rounding */
-
-	mant1 = mant1 * mant2;
+	frac1 <<= 1; /* one bit space for rounding */
+
+	frac1 = frac1 * frac2;
 /* round and return */
 	
-	while ((exp < FLOAT32_MAX_EXPONENT) && (mant1 >= ( 1 << (FLOAT32_MANTISA_SIZE + 2)))) { 
-		/* 23 bits of mantisa + one more for hidden bit (all shifted 1 bit left)*/
-		++exp;
-		mant1 >>= 1;
+	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 */
-	//++mant1; /* FIXME: not works - without it is ok */
-	mant1 >>= 1; /* shift off rounding space */
-	
-	if ((exp < FLOAT32_MAX_EXPONENT) && (mant1 >= (1 << (FLOAT32_MANTISA_SIZE + 1)))) {
-		++exp;
-		mant1 >>= 1;
+	/* ++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)))) {
+		++exp;
+		frac1 >>= 1;
 	};
 
@@ -140,26 +140,26 @@
 		/* return infinity*/
 		result.parts.exp = FLOAT32_MAX_EXPONENT;
-		result.parts.mantisa = 0x0;
-		return result;
-	}
-	
-	exp -= FLOAT32_MANTISA_SIZE;
-
-	if (exp <= FLOAT32_MANTISA_SIZE) { 
+		result.parts.fraction = 0x0;
+		return result;
+	}
+	
+	exp -= FLOAT32_FRACTION_SIZE;
+
+	if (exp <= FLOAT32_FRACTION_SIZE) { 
 		/* denormalized number */
-		mant1 >>= 1; /* denormalize */
-		while ((mant1 > 0) && (exp < 0)) {
-			mant1 >>= 1;
+		frac1 >>= 1; /* denormalize */
+		while ((frac1 > 0) && (exp < 0)) {
+			frac1 >>= 1;
 			++exp;
 		};
-		if (mant1 == 0) {
+		if (frac1 == 0) {
 			/* FIXME : underflow */
 		result.parts.exp = 0;
-		result.parts.mantisa = 0;
+		result.parts.fraction = 0;
 		return result;
 		};
 	};
 	result.parts.exp = exp; 
-	result.parts.mantisa = mant1 & ( (1 << FLOAT32_MANTISA_SIZE) - 1);
+	result.parts.fraction = frac1 & ( (1 << FLOAT32_FRACTION_SIZE) - 1);
 	
 	return result;	
@@ -173,5 +173,5 @@
 {
 	float64 result;
-	__u64 mant1, mant2;
+	__u64 frac1, frac2;
 	__s32 exp;
 
@@ -181,10 +181,10 @@
 		/* TODO: fix SigNaNs */
 		if (isFloat64SigNaN(a)) {
-			result.parts.mantisa = a.parts.mantisa;
+			result.parts.fraction = a.parts.fraction;
 			result.parts.exp = a.parts.exp;
 			return result;
 		};
 		if (isFloat64SigNaN(b)) { /* TODO: fix SigNaN */
-			result.parts.mantisa = b.parts.mantisa;
+			result.parts.fraction = b.parts.fraction;
 			result.parts.exp = b.parts.exp;
 			return result;
@@ -201,5 +201,5 @@
 			return result;
 		}
-		result.parts.mantisa = a.parts.mantisa;
+		result.parts.fraction = a.parts.fraction;
 		result.parts.exp = a.parts.exp;
 		return result;
@@ -212,5 +212,5 @@
 			return result;
 		}
-		result.parts.mantisa = b.parts.mantisa;
+		result.parts.fraction = b.parts.fraction;
 		result.parts.exp = b.parts.exp;
 		return result;
@@ -232,30 +232,30 @@
 		/* FIXME: underflow */
 		/* return signed zero */
-		result.parts.mantisa = 0x0;
+		result.parts.fraction = 0x0;
 		result.parts.exp = 0x0;
 		return result;
 	};
 	
-	mant1 = a.parts.mantisa;
+	frac1 = a.parts.fraction;
 	if (a.parts.exp > 0) {
-		mant1 |= FLOAT64_HIDDEN_BIT_MASK;
+		frac1 |= FLOAT64_HIDDEN_BIT_MASK;
 	} else {
 		++exp;
 	};
 	
-	mant2 = b.parts.mantisa;
+	frac2 = b.parts.fraction;
 
 	if (b.parts.exp > 0) {
-		mant2 |= FLOAT64_HIDDEN_BIT_MASK;
+		frac2 |= FLOAT64_HIDDEN_BIT_MASK;
 	} else {
 		++exp;
 	};
 
-	mant1 <<= 1; /* one bit space for rounding */
-
-	mul64integers(mant1, mant2, &mant1, &mant2);
+	frac1 <<= 1; /* one bit space for rounding */
+
+	mul64integers(frac1, frac2, &frac1, &frac2);
 
 /* round and return */
-	/* FIXME: ugly soulution is to shift whole mant2 >> as in 32bit version
+	/* FIXME: ugly soulution is to shift whole frac2 >> as in 32bit version
 	 * Here is is more slower because we have to shift two numbers with carry
 	 * Better is find first nonzero bit and make only one shift
@@ -264,23 +264,23 @@
 	 */
 	
-	while ((exp < FLOAT64_MAX_EXPONENT) && (mant2 > 0 )) { 
-		mant1 >>= 1;
-		mant1 &= ((mant2 & 0x1) << 63);
-		mant2 >>= 1;
-		++exp;
-	}
-	
-	while ((exp < FLOAT64_MAX_EXPONENT) && (mant1 >= ( (__u64)1 << (FLOAT64_MANTISA_SIZE + 2)))) { 
-		++exp;
-		mant1 >>= 1;
+	while ((exp < FLOAT64_MAX_EXPONENT) && (frac2 > 0 )) { 
+		frac1 >>= 1;
+		frac1 &= ((frac2 & 0x1) << 63);
+		frac2 >>= 1;
+		++exp;
+	}
+	
+	while ((exp < FLOAT64_MAX_EXPONENT) && (frac1 >= ( (__u64)1 << (FLOAT64_FRACTION_SIZE + 2)))) { 
+		++exp;
+		frac1 >>= 1;
 	};
 
 	/* rounding */
-	//++mant1; /* FIXME: not works - without it is ok */
-	mant1 >>= 1; /* shift off rounding space */
-	
-	if ((exp < FLOAT64_MAX_EXPONENT) && (mant1 >= ((__u64)1 << (FLOAT64_MANTISA_SIZE + 1)))) {
-		++exp;
-		mant1 >>= 1;
+	/* ++frac1;  FIXME: not works - without it is ok */
+	frac1 >>= 1; /* shift off rounding space */
+	
+	if ((exp < FLOAT64_MAX_EXPONENT) && (frac1 >= ((__u64)1 << (FLOAT64_FRACTION_SIZE + 1)))) {
+		++exp;
+		frac1 >>= 1;
 	};
 
@@ -289,26 +289,26 @@
 		/* return infinity*/
 		result.parts.exp = FLOAT64_MAX_EXPONENT;
-		result.parts.mantisa = 0x0;
-		return result;
-	}
-	
-	exp -= FLOAT64_MANTISA_SIZE;
-
-	if (exp <= FLOAT64_MANTISA_SIZE) { 
+		result.parts.fraction = 0x0;
+		return result;
+	}
+	
+	exp -= FLOAT64_FRACTION_SIZE;
+
+	if (exp <= FLOAT64_FRACTION_SIZE) { 
 		/* denormalized number */
-		mant1 >>= 1; /* denormalize */
-		while ((mant1 > 0) && (exp < 0)) {
-			mant1 >>= 1;
+		frac1 >>= 1; /* denormalize */
+		while ((frac1 > 0) && (exp < 0)) {
+			frac1 >>= 1;
 			++exp;
 		};
-		if (mant1 == 0) {
+		if (frac1 == 0) {
 			/* FIXME : underflow */
 		result.parts.exp = 0;
-		result.parts.mantisa = 0;
+		result.parts.fraction = 0;
 		return result;
 		};
 	};
 	result.parts.exp = exp; 
-	result.parts.mantisa = mant1 & ( ((__u64)1 << FLOAT64_MANTISA_SIZE) - 1);
+	result.parts.fraction = frac1 & ( ((__u64)1 << FLOAT64_FRACTION_SIZE) - 1);
 	
 	return result;	
@@ -339,6 +339,6 @@
 
 	middle1 += middle2;
-	high += ((__u64)(middle1 < middle2) << 32) + middle1>>32;
-	middle1 << 32;
+	high += ((__u64)(middle1 < middle2) << 32) + (middle1 >> 32);
+	middle1 <<= 32;
 	low += middle1;
 	high += (low < middle1);
Index: softfloat/generic/softfloat.c
===================================================================
--- softfloat/generic/softfloat.c	(revision b7e65d4a00b31b5bc17e54551c9d99653b2999f9)
+++ softfloat/generic/softfloat.c	(revision 12665431deed59bc8d76f61f17368d17c55d2bcb)
@@ -44,15 +44,15 @@
 {
 	float32 fa, fb;
-	fa.f=a;
-	fb.f=b;
-	if (fa.parts.sign!=fb.parts.sign) {
+	fa.f = a;
+	fb.f = b;
+	if (fa.parts.sign != fb.parts.sign) {
 		if (fa.parts.sign) {
-			fa.parts.sign=0;
-			return subFloat32(fb,fa).f;
-		};
-		fb.parts.sign=0;
-		return subFloat32(fa,fb).f;
+			fa.parts.sign = 0;
+			return subFloat32(fb, fa).f;
+		};
+		fb.parts.sign = 0;
+		return subFloat32(fa, fb).f;
 	}
-	return addFloat32(fa,fb).f;
+	return addFloat32(fa, fb).f;
 }
 
@@ -60,15 +60,15 @@
 {
 	float64 da, db;
-	da.d=a;
-	db.d=b;
-	if (da.parts.sign!=db.parts.sign) {
+	da.d = a;
+	db.d = b;
+	if (da.parts.sign != db.parts.sign) {
 		if (da.parts.sign) {
-			da.parts.sign=0;
-			return subFloat64(db,da).d;
-		};
-		db.parts.sign=0;
-		return subFloat64(da,db).d;
+			da.parts.sign = 0;
+			return subFloat64(db, da).d;
+		};
+		db.parts.sign = 0;
+		return subFloat64(da, db).d;
 	}
-	return addFloat64(da,db).d;
+	return addFloat64(da, db).d;
 }
 
@@ -76,11 +76,11 @@
 {
 	float32 fa, fb;
-	fa.f=a;
-	fb.f=b;
-	if (fa.parts.sign!=fb.parts.sign) {
-		fb.parts.sign=!fb.parts.sign;
-		return addFloat32(fa,fb).f;
+	fa.f = a;
+	fb.f = b;
+	if (fa.parts.sign != fb.parts.sign) {
+		fb.parts.sign = !fb.parts.sign;
+		return addFloat32(fa, fb).f;
 	}
-	return subFloat32(fa,fb).f;
+	return subFloat32(fa, fb).f;
 }
 
@@ -100,6 +100,6 @@
 {
 	float32 fa, fb;
-	fa.f=a;
-	fb.f=b;
+	fa.f = a;
+	fb.f = b;
 	return 	mulFloat32(fa, fb).f;
 }
@@ -116,7 +116,7 @@
 {
 	float32 fa, fb;
-	fa.f=a;
-	fb.f=b;
-	//return 	divFloat32(fa, fb).f;
+	fa.f = a;
+	fb.f = b;
+	return 	divFloat32(fa, fb).f;
 }
 
@@ -124,6 +124,6 @@
 {
 	float32 fa;
-	fa.f=a;
-	fa.parts.sign=!fa.parts.sign;
+	fa.f = a;
+	fa.parts.sign = !fa.parts.sign;
 	return fa.f;
 }
@@ -132,6 +132,6 @@
 {
 	float64 fa;
-	fa.d=a;
-	fa.parts.sign=!fa.parts.sign;
+	fa.d = a;
+	fa.parts.sign = !fa.parts.sign;
 	return fa.d;
 }
@@ -162,17 +162,17 @@
 int __cmpsf2(float a, float b) 
 {
-	float32 fa,fb;
-	fa.f=a;
-	fb.f=b;
-	if ((isFloat32NaN(fa))||(isFloat32NaN(fb))) {
+	float32 fa, fb;
+	fa.f = a;
+	fb.f = b;
+	if ( (isFloat32NaN(fa)) || (isFloat32NaN(fb)) ) {
 		return 1; /* no special constant for unordered - maybe signaled? */
 	};
 
 	
-	if (isFloat32eq(fa,fb)) {
+	if (isFloat32eq(fa, fb)) {
 		return 0;
 	};
 	
-	if (isFloat32lt(fa,fb)) {
+	if (isFloat32lt(fa, fb)) {
 		return -1;
 		};
@@ -182,8 +182,8 @@
 int __unordsf2(float a, float b) 
 {
-	float32 fa,fb;
-	fa.f=a;
-	fb.f=b;
-	return ((isFloat32NaN(fa))||(isFloat32NaN(fb)));
+	float32 fa, fb;
+	fa.f = a;
+	fb.f = b;
+	return ( (isFloat32NaN(fa)) || (isFloat32NaN(fb)) );
 }
 
@@ -193,12 +193,12 @@
 int __eqsf2(float a, float b) 
 {
-	float32 fa,fb;
-	fa.f=a;
-	fb.f=b;
-	if ((isFloat32NaN(fa))||(isFloat32NaN(fb))) {
-		/* TODO: sigNaNs*/
-		return 1;
-		};
-	return isFloat32eq(fa,fb)-1;
+	float32 fa, fb;
+	fa.f = a;
+	fb.f = b;
+	if ( (isFloat32NaN(fa)) || (isFloat32NaN(fb)) ) {
+		/* TODO: sigNaNs*/
+		return 1;
+		};
+	return isFloat32eq(fa, fb) - 1;
 }
 
@@ -206,5 +206,5 @@
 int __nesf2(float a, float b) 
 {
-	return __eqsf2(a,b);
+	return __eqsf2(a, b);
 }
 
@@ -212,17 +212,17 @@
 int __gesf2(float a, float b)
 {
-	float32 fa,fb;
-	fa.f=a;
-	fb.f=b;
-	if ((isFloat32NaN(fa))||(isFloat32NaN(fb))) {
-		/* TODO: sigNaNs*/
-		return -1;
-		};
-	
-	if (isFloat32eq(fa,fb)) {
+	float32 fa, fb;
+	fa.f = a;
+	fb.f = b;
+	if ( (isFloat32NaN(fa)) || (isFloat32NaN(fb)) ) {
+		/* TODO: sigNaNs*/
+		return -1;
+		};
+	
+	if (isFloat32eq(fa, fb)) {
 		return 0;
 	};
 	
-	if (isFloat32gt(fa,fb)) {
+	if (isFloat32gt(fa, fb)) {
 		return 1;
 		};
@@ -234,8 +234,8 @@
 int __ltsf2(float a, float b)
 {
-	float32 fa,fb;
-	fa.f=a;
-	fb.f=b;
-	if ((isFloat32NaN(fa))||(isFloat32NaN(fb))) {
+	float32 fa, fb;
+	fa.f = a;
+	fb.f = b;
+	if ( (isFloat32NaN(fa)) || (isFloat32NaN(fb)) ) {
 		/* TODO: sigNaNs*/
 		return 1;
@@ -250,17 +250,17 @@
 int __lesf2(float a, float b)
 {
-	float32 fa,fb;
-	fa.f=a;
-	fb.f=b;
-	if ((isFloat32NaN(fa))||(isFloat32NaN(fb))) {
-		/* TODO: sigNaNs*/
-		return 1;
-		};
-	
-	if (isFloat32eq(fa,fb)) {
+	float32 fa, fb;
+	fa.f = a;
+	fb.f = b;
+	if ( (isFloat32NaN(fa)) || (isFloat32NaN(fb)) ) {
+		/* TODO: sigNaNs*/
+		return 1;
+		};
+	
+	if (isFloat32eq(fa, fb)) {
 		return 0;
 	};
 	
-	if (isFloat32lt(fa,fb)) {
+	if (isFloat32lt(fa, fb)) {
 		return -1;
 		};
@@ -272,8 +272,8 @@
 int __gtsf2(float a, float b)
 {
-	float32 fa,fb;
-	fa.f=a;
-	fb.f=b;
-	if ((isFloat32NaN(fa))||(isFloat32NaN(fb))) {
+	float32 fa, fb;
+	fa.f = a;
+	fb.f = b;
+	if ( (isFloat32NaN(fa)) || (isFloat32NaN(fb)) ) {
 		/* TODO: sigNaNs*/
 		return -1;
@@ -289,15 +289,15 @@
 float __powisf2(float a, int b)
 {
-//TODO:	
+/* TODO: */
 }
 
 float __mulsc3(float a, float b, float c, float d)
 {
-//TODO:
+/* TODO: */
 }
 
 float __divsc3(float a, float b, float c, float d)
 {
-//TODO:
-}
-
+/* TODO: */
+}
+
Index: softfloat/generic/sub.c
===================================================================
--- softfloat/generic/sub.c	(revision b7e65d4a00b31b5bc17e54551c9d99653b2999f9)
+++ softfloat/generic/sub.c	(revision 12665431deed59bc8d76f61f17368d17c55d2bcb)
@@ -36,5 +36,5 @@
 {
 	int expdiff;
-	__u32 exp1, exp2, mant1, mant2;
+	__u32 exp1, exp2, frac1, frac2;
 	float32 result;
 
@@ -42,7 +42,7 @@
 	
 	expdiff = a.parts.exp - b.parts.exp;
-	if ((expdiff < 0 ) || ((expdiff == 0) && (a.parts.mantisa < b.parts.mantisa))) {
+	if ((expdiff < 0 ) || ((expdiff == 0) && (a.parts.fraction < b.parts.fraction))) {
 		if (isFloat32NaN(b)) {
-			//TODO: fix SigNaN
+			/* TODO: fix SigNaN */
 			if (isFloat32SigNaN(b)) {
 			};
@@ -57,12 +57,12 @@
 		result.parts.sign = !a.parts.sign; 
 		
-		mant1 = b.parts.mantisa;
+		frac1 = b.parts.fraction;
 		exp1 = b.parts.exp;
-		mant2 = a.parts.mantisa;
+		frac2 = a.parts.fraction;
 		exp2 = a.parts.exp;
 		expdiff *= -1;
 	} else {
 		if (isFloat32NaN(a)) {
-			//TODO: fix SigNaN
+			/* TODO: fix SigNaN */
 			if (isFloat32SigNaN(a) || isFloat32SigNaN(b)) {
 			};
@@ -73,5 +73,5 @@
 			if (b.parts.exp == FLOAT32_MAX_EXPONENT) {
 				/* inf - inf => nan */
-				//TODO: fix exception
+				/* TODO: fix exception */
 				result.binary = FLOAT32_NAN;
 				return result;
@@ -82,15 +82,15 @@
 		result.parts.sign = a.parts.sign;
 		
-		mant1 = a.parts.mantisa;
+		frac1 = a.parts.fraction;
 		exp1 = a.parts.exp;
-		mant2 = b.parts.mantisa;
+		frac2 = b.parts.fraction;
 		exp2 = b.parts.exp;	
 	};
 	
 	if (exp1 == 0) {
-		//both are denormalized
-		result.parts.mantisa = mant1-mant2;
-		if (result.parts.mantisa > mant1) {
-			//TODO: underflow exception
+		/* both are denormalized */
+		result.parts.fraction = frac1-frac2;
+		if (result.parts.fraction > frac1) {
+			/* TODO: underflow exception */
 			return result;
 		};
@@ -100,5 +100,5 @@
 
 	/* add hidden bit */
-	mant1 |= FLOAT32_HIDDEN_BIT_MASK; 
+	frac1 |= FLOAT32_HIDDEN_BIT_MASK; 
 	
 	if (exp2 == 0) {
@@ -107,34 +107,34 @@
 	} else {
 		/* normalized */
-		mant2 |= FLOAT32_HIDDEN_BIT_MASK;
+		frac2 |= FLOAT32_HIDDEN_BIT_MASK;
 	};
 	
 	/* create some space for rounding */
-	mant1 <<= 6;
-	mant2 <<= 6;
-	
-	if (expdiff > FLOAT32_MANTISA_SIZE + 1) {
+	frac1 <<= 6;
+	frac2 <<= 6;
+	
+	if (expdiff > FLOAT32_FRACTION_SIZE + 1) {
 	     goto done;	
 	     };
 	
-	mant1 = mant1 - (mant2 >> expdiff);
+	frac1 = frac1 - (frac2 >> expdiff);
 done:
-	//TODO: find first nonzero digit and shift result and detect possibly underflow
-	while ((exp1 > 0) && (!(mant1 & (FLOAT32_HIDDEN_BIT_MASK << 6 )))) {
+	/* TODO: find first nonzero digit and shift result and detect possibly underflow */
+	while ((exp1 > 0) && (!(frac1 & (FLOAT32_HIDDEN_BIT_MASK << 6 )))) {
 		--exp1;
-		mant1 <<= 1;
-			/* TODO: fix underflow - mant1 == 0 does not necessary means underflow... */
-	};
-	
-	/* rounding - if first bit after mantisa is set then round up */
-	mant1 += 0x20;
-
-	if (mant1 & (FLOAT32_HIDDEN_BIT_MASK << 7)) {
+		frac1 <<= 1;
+			/* TODO: fix underflow - frac1 == 0 does not necessary means underflow... */
+	};
+	
+	/* rounding - if first bit after fraction is set then round up */
+	frac1 += 0x20;
+
+	if (frac1 & (FLOAT32_HIDDEN_BIT_MASK << 7)) {
 		++exp1;
-		mant1 >>= 1;
+		frac1 >>= 1;
 	};
 	
 	/*Clear hidden bit and shift */
-	result.parts.mantisa = ((mant1 >> 6) & (~FLOAT32_HIDDEN_BIT_MASK)); 
+	result.parts.fraction = ((frac1 >> 6) & (~FLOAT32_HIDDEN_BIT_MASK)); 
 	result.parts.exp = exp1;
 	
@@ -148,5 +148,5 @@
 	int expdiff;
 	__u32 exp1, exp2;
-	__u64 mant1, mant2;
+	__u64 frac1, frac2;
 	float64 result;
 
@@ -154,7 +154,7 @@
 	
 	expdiff = a.parts.exp - b.parts.exp;
-	if ((expdiff < 0 ) || ((expdiff == 0) && (a.parts.mantisa < b.parts.mantisa))) {
+	if ((expdiff < 0 ) || ((expdiff == 0) && (a.parts.fraction < b.parts.fraction))) {
 		if (isFloat64NaN(b)) {
-			//TODO: fix SigNaN
+			/* TODO: fix SigNaN */
 			if (isFloat64SigNaN(b)) {
 			};
@@ -169,12 +169,12 @@
 		result.parts.sign = !a.parts.sign; 
 		
-		mant1 = b.parts.mantisa;
+		frac1 = b.parts.fraction;
 		exp1 = b.parts.exp;
-		mant2 = a.parts.mantisa;
+		frac2 = a.parts.fraction;
 		exp2 = a.parts.exp;
 		expdiff *= -1;
 	} else {
 		if (isFloat64NaN(a)) {
-			//TODO: fix SigNaN
+			/* TODO: fix SigNaN */
 			if (isFloat64SigNaN(a) || isFloat64SigNaN(b)) {
 			};
@@ -185,5 +185,5 @@
 			if (b.parts.exp == FLOAT64_MAX_EXPONENT) {
 				/* inf - inf => nan */
-				//TODO: fix exception
+				/* TODO: fix exception */
 				result.binary = FLOAT64_NAN;
 				return result;
@@ -194,15 +194,15 @@
 		result.parts.sign = a.parts.sign;
 		
-		mant1 = a.parts.mantisa;
+		frac1 = a.parts.fraction;
 		exp1 = a.parts.exp;
-		mant2 = b.parts.mantisa;
+		frac2 = b.parts.fraction;
 		exp2 = b.parts.exp;	
 	};
 	
 	if (exp1 == 0) {
-		//both are denormalized
-		result.parts.mantisa = mant1 - mant2;
-		if (result.parts.mantisa > mant1) {
-			//TODO: underflow exception
+		/* both are denormalized */
+		result.parts.fraction = frac1 - frac2;
+		if (result.parts.fraction > frac1) {
+			/* TODO: underflow exception */
 			return result;
 		};
@@ -212,5 +212,5 @@
 
 	/* add hidden bit */
-	mant1 |= FLOAT64_HIDDEN_BIT_MASK; 
+	frac1 |= FLOAT64_HIDDEN_BIT_MASK; 
 	
 	if (exp2 == 0) {
@@ -219,34 +219,34 @@
 	} else {
 		/* normalized */
-		mant2 |= FLOAT64_HIDDEN_BIT_MASK;
+		frac2 |= FLOAT64_HIDDEN_BIT_MASK;
 	};
 	
 	/* create some space for rounding */
-	mant1 <<= 6;
-	mant2 <<= 6;
-	
-	if (expdiff > FLOAT64_MANTISA_SIZE + 1) {
+	frac1 <<= 6;
+	frac2 <<= 6;
+	
+	if (expdiff > FLOAT64_FRACTION_SIZE + 1) {
 	     goto done;	
 	     };
 	
-	mant1 = mant1 - (mant2 >> expdiff);
+	frac1 = frac1 - (frac2 >> expdiff);
 done:
-	//TODO: find first nonzero digit and shift result and detect possibly underflow
-	while ((exp1 > 0) && (!(mant1 & (FLOAT64_HIDDEN_BIT_MASK << 6 )))) {
+	/* TODO: find first nonzero digit and shift result and detect possibly underflow */
+	while ((exp1 > 0) && (!(frac1 & (FLOAT64_HIDDEN_BIT_MASK << 6 )))) {
 		--exp1;
-		mant1 <<= 1;
-			/* TODO: fix underflow - mant1 == 0 does not necessary means underflow... */
-	};
-	
-	/* rounding - if first bit after mantisa is set then round up */
-	mant1 += 0x20;
-
-	if (mant1 & (FLOAT64_HIDDEN_BIT_MASK << 7)) {
+		frac1 <<= 1;
+			/* TODO: fix underflow - frac1 == 0 does not necessary means underflow... */
+	};
+	
+	/* rounding - if first bit after fraction is set then round up */
+	frac1 += 0x20;
+
+	if (frac1 & (FLOAT64_HIDDEN_BIT_MASK << 7)) {
 		++exp1;
-		mant1 >>= 1;
+		frac1 >>= 1;
 	};
 	
 	/*Clear hidden bit and shift */
-	result.parts.mantisa = ((mant1 >> 6) & (~FLOAT64_HIDDEN_BIT_MASK)); 
+	result.parts.fraction = ((frac1 >> 6) & (~FLOAT64_HIDDEN_BIT_MASK)); 
 	result.parts.exp = exp1;
 	
Index: softfloat/include/sftypes.h
===================================================================
--- softfloat/include/sftypes.h	(revision b7e65d4a00b31b5bc17e54551c9d99653b2999f9)
+++ softfloat/include/sftypes.h	(revision 12665431deed59bc8d76f61f17368d17c55d2bcb)
@@ -38,7 +38,7 @@
 		__u32 sign:1;
 		__u32 exp:8;
-		__u32 mantisa:23;
+		__u32 fraction:23;
 		#elif defined __LITTLE_ENDIAN__
-		__u32 mantisa:23;
+		__u32 fraction:23;
 		__u32 exp:8;
 		__u32 sign:1;
@@ -57,7 +57,7 @@
 		__u64 sign:1;
 		__u64 exp:11;
-		__u64 mantisa:52;
+		__u64 fraction:52;
 		#elif defined __LITTLE_ENDIAN__
-		__u64 mantisa:52;
+		__u64 fraction:52;
 		__u64 exp:11;
 		__u64 sign:1;
@@ -82,6 +82,6 @@
 #define FLOAT64_INF 0x7FF0000000000000ll
 
-#define FLOAT32_MANTISA_SIZE 23
-#define FLOAT64_MANTISA_SIZE 52
+#define FLOAT32_FRACTION_SIZE 23
+#define FLOAT64_FRACTION_SIZE 52
 
 #define FLOAT32_HIDDEN_BIT_MASK 0x800000