Index: uspace/lib/c/generic/double_to_str.c
===================================================================
--- uspace/lib/c/generic/double_to_str.c	(revision 850fd32a6ced0b28470d7b2100d44accba1dce89)
+++ uspace/lib/c/generic/double_to_str.c	(revision 8800b13065d75eefbc778f2b003bc4253f57fc29)
@@ -56,5 +56,5 @@
 static bool is_normalized(fp_num_t num)
 {
-	assert(8*sizeof(num.significand) == significand_width);
+	assert(8 * sizeof(num.significand) == significand_width);
 
 	/* Normalized == most significant bit of the significand is set. */
@@ -147,5 +147,5 @@
 /** Returns the interval [low, high] of numbers that convert to binary val. */
 static void get_normalized_bounds(ieee_double_t val, fp_num_t *high,
-	fp_num_t *low, fp_num_t *val_dist)
+    fp_num_t *low, fp_num_t *val_dist)
 {
 	/*
@@ -181,5 +181,5 @@
 
 	val_dist->significand =
-		val_dist->significand << (val_dist->exponent - high->exponent);
+	    val_dist->significand << (val_dist->exponent - high->exponent);
 	val_dist->exponent = high->exponent;
 }
@@ -198,5 +198,5 @@
  */
 static void calc_scaled_bounds(ieee_double_t val, fp_num_t *scaled_upper_bound,
-	fp_num_t *bounds_delta, fp_num_t *val_dist, int *scale)
+    fp_num_t *bounds_delta, fp_num_t *val_dist, int *scale)
 {
 	fp_num_t upper_bound, lower_bound;
@@ -251,5 +251,5 @@
 /** Rounds the last digit of buf so that it is closest to the converted number.*/
 static void round_last_digit(uint64_t rest, uint64_t w_dist, uint64_t delta,
-	uint64_t digit_val_diff, char *buf, int len)
+    uint64_t digit_val_diff, char *buf, int len)
 {
 	/*
@@ -277,6 +277,6 @@
 	bool next_in_val_rng = cur_greater_w && (rest + digit_val_diff < delta);
 	/* Rounding down by one would bring buf closer to the processed number. */
-	bool next_closer = next_in_val_rng
-		&& (rest + digit_val_diff < w_dist || rest - w_dist < w_dist - rest);
+	bool next_closer = next_in_val_rng &&
+	    (rest + digit_val_diff < w_dist || rest - w_dist < w_dist - rest);
 
 	/* Of the shortest strings pick the one that is closest to the actual
@@ -291,6 +291,6 @@
 		cur_greater_w = rest < w_dist;
 		next_in_val_rng = cur_greater_w && (rest + digit_val_diff < delta);
-		next_closer = next_in_val_rng
-			&& (rest + digit_val_diff < w_dist || rest - w_dist < w_dist - rest);
+		next_closer = next_in_val_rng &&
+		    (rest + digit_val_diff < w_dist || rest - w_dist < w_dist - rest);
 	}
 }
@@ -326,5 +326,5 @@
  */
 static int gen_dec_digits(fp_num_t scaled_upper, fp_num_t delta,
-	fp_num_t val_dist, int scale, char *buf, size_t buf_size, int *dec_exponent)
+    fp_num_t val_dist, int scale, char *buf, size_t buf_size, int *dec_exponent)
 {
 	/*
@@ -411,5 +411,5 @@
 			/* Of the shortest representations choose the numerically closest. */
 			round_last_digit(remainder, val_dist.significand, delta.significand,
-				(uint64_t)div << (-one.exponent), buf, len);
+			    (uint64_t)div << (-one.exponent), buf, len);
 			return len;
 		}
@@ -457,5 +457,5 @@
 	/* Of the shortest representations choose the numerically closest one. */
 	round_last_digit(frac_part, val_dist.significand, delta.significand,
-		one.significand, buf, len);
+	    one.significand, buf, len);
 
 	return len;
@@ -504,5 +504,5 @@
  */
 int double_to_short_str(ieee_double_t ieee_val, char *buf, size_t buf_size,
-	int *dec_exponent)
+    int *dec_exponent)
 {
 	/* The whole computation assumes 64bit significand. */
@@ -524,8 +524,8 @@
 
 	calc_scaled_bounds(ieee_val, &scaled_upper_bound,
-		&delta, &val_dist, &scale);
+	    &delta, &val_dist, &scale);
 
 	int len = gen_dec_digits(scaled_upper_bound, delta, val_dist, scale,
-		buf, buf_size, dec_exponent);
+	    buf, buf_size, dec_exponent);
 
 	assert(len <= MAX_DOUBLE_STR_LEN);
@@ -554,5 +554,5 @@
  */
 static int gen_fixed_dec_digits(fp_num_t w_scaled, int scale, int signif_d_cnt,
-	int frac_d_cnt, char *buf, size_t buf_size, int *dec_exponent)
+    int frac_d_cnt, char *buf, size_t buf_size, int *dec_exponent)
 {
 	/* We'll produce at least one digit and a null terminator. */
@@ -608,5 +608,5 @@
 	int rem_signif_d_cnt = signif_d_cnt;
 	int rem_frac_d_cnt =
-		(frac_d_cnt >= 0) ? (kappa - scale + frac_d_cnt) : INT_MAX;
+	    (frac_d_cnt >= 0) ? (kappa - scale + frac_d_cnt) : INT_MAX;
 
 	/* Produce decimal digits for the integral part of w_scaled. */
@@ -752,5 +752,5 @@
  */
 int double_to_fixed_str(ieee_double_t ieee_val, int signif_d_cnt,
-	int frac_d_cnt, char *buf, size_t buf_size, int *dec_exponent)
+    int frac_d_cnt, char *buf, size_t buf_size, int *dec_exponent)
 {
 	/* The whole computation assumes 64bit significand. */
@@ -780,5 +780,5 @@
 	/* Produce decimal digits from the scaled number. */
 	int len = gen_fixed_dec_digits(w_scaled, scale, signif_d_cnt, frac_d_cnt,
-		buf, buf_size, dec_exponent);
+	    buf, buf_size, dec_exponent);
 
 	assert(len <= MAX_DOUBLE_STR_LEN);