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

Timestamp:

2018-04-12T16:27:17Z (8 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.

Location:

uspace/lib/c/generic

Files:

• async.c (modified) (2 diffs)
• double_to_str.c (modified) (16 diffs)
• elf/elf_mod.c (modified) (5 diffs)
• getopt.c (modified) (8 diffs)
• io/io.c (modified) (1 diff)
• io/output.c (modified) (1 diff)
• tls.c (modified) (1 diff)

uspace/lib/c/generic/async.c

@@ -943 +943 @@
         link_t *tmp = timeout_list.head.next;
         while (tmp != &timeout_list.head) {
-                awaiter_t *cur
-                    = list_get_instance(tmp, awaiter_t, to_event.link);
+                awaiter_t *cur =
+                    list_get_instance(tmp, awaiter_t, to_event.link);
 
                 if (tv_gteq(&cur->to_event.expires, &wd->to_event.expires))
@@ -1255 +1255 @@
                  */
                 futex_down(&async_futex);
-                if ((usecs) && (conn->wdata.to_event.occurred)
-                    && (list_empty(&conn->msg_queue))) {
+                if ((usecs) && (conn->wdata.to_event.occurred) &&
+                    (list_empty(&conn->msg_queue))) {
                         /* If we timed out -> exit */
                         futex_up(&async_futex);

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);

uspace/lib/c/generic/elf/elf_mod.c

@@ -273 +273 @@
                 // FIXME: This actually won't work, because the text segment is
                 // not loaded yet.
-                #if 0
+#if 0
                 if (elf->info->interp[entry->p_filesz - 1] != '\0') {
                         DPRINTF("Unterminated ELF interp string.\n");
@@ -279 +279 @@
                 }
                 DPRINTF("interpreter: \"%s\"\n", elf->info->interp);
-                #endif
+#endif
                 break;
         case PT_DYNAMIC:
@@ -286 +286 @@
                     (void *)((uint8_t *)entry->p_vaddr + elf->bias);
                 DPRINTF("dynamic section found at %p\n",
-                        (void *)elf->info->dynamic);
+                    (void *)elf->info->dynamic);
                 break;
         case 0x70000000:
@@ -334 +334 @@
 
         DPRINTF("Load segment at addr %p, size 0x%zx\n", (void *) seg_addr,
-                entry->p_memsz);
+            entry->p_memsz);
 
         if (entry->p_align > 1) {
@@ -394 +394 @@
          * need to set the right access mode and ensure SMC coherence.
          */
-        if ((elf->flags & ELDF_RW) != 0) return EE_OK;
+        if ((elf->flags & ELDF_RW) != 0)
+                return EE_OK;
 
 //      printf("set area flags to %d\n", flags);

uspace/lib/c/generic/getopt.c

@@ -132 +132 @@
 
         for (i = 0; i < ncycle; i++) {
-                cstart = panonopt_end+i;
+                cstart = panonopt_end + i;
                 pos = cstart;
                 for (j = 0; j < cyclelen; j++) {
@@ -181 +181 @@
                                     optind, nargv);
                                 optind -= nonopt_end - nonopt_start;
-                        }
-                        else if (nonopt_start != -1) {
+                        } else if (nonopt_start != -1) {
                                 /*
                                  * If we skipped non-options, set optind
@@ -192 +191 @@
                         return -1;
                 }
-                if ((*(place = nargv[optind]) != '-')
-                    || (place[1] == '\0')) {    /* found non-option */
+                if ((*(place = nargv[optind]) != '-') ||
+                    (place[1] == '\0')) {    /* found non-option */
                         place = EMSG;
                         if (IN_ORDER) {
@@ -289 +288 @@
  *      Parse argc/argv argument vector.
  */
-int getopt(int nargc, char * const *nargv, const char *options)
+int getopt(int nargc, char *const *nargv, const char *options)
 {
         int retval;
@@ -305 +304 @@
                 if (nonopt_end != -1) {
                         permute_args(nonopt_start, nonopt_end, optind,
-                                       (char **)nargv);
+                            (char **)nargv);
                         optind -= nonopt_end - nonopt_start;
                 }
@@ -318 +317 @@
  *      Parse argc/argv argument vector.
  */
-int getopt_long(int nargc, char * const *nargv, const char *options,
+int getopt_long(int nargc, char *const *nargv, const char *options,
     const struct option *long_options, int *idx)
 {
@@ -389 +388 @@
                         if (PRINT_ERROR)
                                 printf(ambig, (int)current_argv_len,
-                                     current_argv);
+                                    current_argv);
                         optopt = 0;
                         return BADCH;
                 }
                 if (match != -1) {                      /* option found */
-                        if (long_options[match].has_arg == no_argument
-                            && has_equal) {
+                        if (long_options[match].has_arg == no_argument &&
+                            has_equal) {
                                 if (PRINT_ERROR)
                                         printf(noarg, (int)current_argv_len,
-                                             current_argv);
+                                            current_argv);
                                 /*
                                  * XXX: GNU sets optopt to val regardless of
@@ -422 +421 @@
                                 }
                         }
-                        if ((long_options[match].has_arg == required_argument)
-                            && (optarg == NULL)) {
+                        if ((long_options[match].has_arg == required_argument) &&
+                            (optarg == NULL)) {
                                 /*
                                  * Missing argument; leading ':'

uspace/lib/c/generic/io/io.c

@@ -388 +388 @@
         int rc = _fclose_nofree(stream);
 
-        if ((stream != &stdin_null)
-            && (stream != &stdout_kio)
-            && (stream != &stderr_kio))
+        if ((stream != &stdin_null) &&
+            (stream != &stdout_kio) &&
+            (stream != &stderr_kio))
                 free(stream);
 

uspace/lib/c/generic/io/output.c

@@ -89 +89 @@
         ipc_call_t answer;
         aid_t req = async_send_0(exch, OUTPUT_FRONTBUF_CREATE, &answer);
-        errno_t rc = async_share_out_start(exch, frontbuf, AS_AREA_READ
-            | AS_AREA_WRITE | AS_AREA_CACHEABLE);
+        errno_t rc = async_share_out_start(exch, frontbuf, AS_AREA_READ |
+            AS_AREA_WRITE | AS_AREA_CACHEABLE);
 
         async_exchange_end(exch);

uspace/lib/c/generic/tls.c

@@ -154 +154 @@
  * @return              Pointer to TCB structure.
  */
-tcb_t * tls_alloc_variant_2(void **data, size_t size)
+tcb_t *tls_alloc_variant_2(void **data, size_t size)
 {
         tcb_t *tcb;