Changeset 3bacee1 in mainline for uspace/lib/c/generic/double_to_str.c

Timestamp:

2018-04-12T16:27:17Z (7 years ago)

Author:

Jiri Svoboda <jiri@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

3cf22f9

Parents:

76d0981d

git-author:

Jiri Svoboda <jiri@…> (2018-04-11 19:25:33)

git-committer:

Jiri Svoboda <jiri@…> (2018-04-12 16:27:17)

Message:

Make ccheck-fix again and commit more good files.

File:

• uspace/lib/c/generic/double_to_str.c (modified) (16 diffs)

uspace/lib/c/generic/double_to_str.c

@@ -56 +56 @@
 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 +147 @@
 /** 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 +181 @@
 
         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 +198 @@
  */
 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 +251 @@
 /** 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 +277 @@
         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 +291 @@
                 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 +326 @@
  */
 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 +411 @@
                         /* 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 +457 @@
         /* 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 +504 @@
  */
 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 +524 @@
 
         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 +554 @@
  */
 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 +608 @@
         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 +752 @@
  */
 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 +780 @@
         /* 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);