Remove extra parentheses in return statement

(refactoring)

Also, replace 0 to NULL where appropriate.

* allchblk.c (setup_header, GC_get_first_part, GC_allochblk_nth):
Remove outermost parentheses in the expression of return statement.
* alloc.c (GC_never_stop_func, GC_timeout_stop_func,
GC_adj_bytes_allocd, GC_try_to_collect_inner, GC_collect_a_little,
GC_stopped_mark, GC_try_to_collect_general, GC_expand_hp_inner,
GC_collect_or_expand, GC_allocobj): Likewise.
* blacklst.c (GC_is_black_listed, GC_number_stack_black_listed,
total_stack_black_listed): Likewise.
* checksums.c (GC_checksum): Likewise.
* cord/cordbscs.c (CORD_cat_char_star, CORD_cat, CORD_len,
CORD_index_access_fn, CORD_apply_access_fn, CORD_substr_checked,
CORD_substr, CORD_iter5, CORD_iter, CORD_riter4, CORD_riter,
CORD_concat_forest, CORD_balance, CORD__pos_fetch, CORD__prev,
CORD_prev, CORD_pos_to_cord, CORD_pos_valid): Likewise.
* cord/cordprnt.c (extract_conv_spec, CORD_vsprintf, CORD_sprintf,
CORD_fprintf, CORD_vfprintf, CORD_printf, CORD_vprintf): Likewise.
* cord/cordxtra.c (CORD_cat_char, CORD_catn, CORD_fill_proc,
CORD_batched_fill_proc, CORD_cmp, CORD_ncmp, CORD_to_char_star,
CORD_from_char_star, CORD_to_const_char_star, CORD_fetch,
CORD_put_proc, CORD_batched_put_proc, CORD_put, CORD_chr_proc,
CORD_rchr_proc, CORD_batched_chr_proc, CORD_chr, CORD_rchr, CORD_str,
CORD_from_file_eager, CORD_lf_func, CORD_from_file_lazy_inner,
CORD_from_file_lazy, CORD_from_file): Likewise.
* cord/tests/cordtest.c (test_fn, id_cord_fn, test_basics): Likewise.
* cord/tests/de.c (line_pos, add_hist, retrieve_line, beep): Likewise.
* cord/tests/de_win.c (WinMain, plain_chars, control_chars, WndProc):
Likewise.
* dbg_mlc.c (store_debug_info, GC_debug_generic_malloc,
GC_debug_generic_malloc, GC_debug_realloc, GC_make_closure): Likewise.
* dyn_load.c (GC_FirstDLOpenedLinkMap): Likewise.
* extra/real_malloc.c (real_malloc): Likewise.
* finalize.c (GC_register_disappearing_link,
GC_unregister_disappearing_link): Likewise.
* gc_dlopen.c (dlopen): Likewise.
* gcj_mlc.c (maybe_finalize, GC_debug_gcj_malloc,
GC_gcj_malloc_ignore_off_page): Likewise.
* headers.c (GC_find_header, alloc_hdr, get_index, GC_install_header,
GC_next_block, GC_prev_block): Likewise.
* malloc.c (GC_generic_malloc): Likewise.
* mallocx.c (GC_realloc, GC_generic_malloc_ignore_off_page): Likewise.
* mark.c (GC_collection_in_progress, GC_mark_some,
GC_signal_mark_stack_overflow, GC_block_was_dirty,
GC_push_next_marked, GC_push_next_marked_dirty,
GC_push_next_marked_uncollectable): Likewise.
* mark_rts.c (GC_is_static_root, rt_hash, GC_roots_present,
GC_remove_tmp_roots, GC_approx_sp): Likewise.
* misc.c (GC_default_oom_fn, GC_clear_stack_inner, GC_base,
GC_write, GC_get_warn_proc, GC_call_with_alloc_lock): Likewise.
* new_hblk.c (GC_build_fl_clear2, GC_build_fl_clear4, GC_build_fl2,
GC_build_fl4, GC_build_fl): Likewise.
* obj_map.c (GC_register_displacement_inner): Likewise.
* os_dep.c (GC_find_limit_openbsd, GC_skip_hole_openbsd,
GC_get_writable_length, GC_get_writable_length, GC_get_main_stack_base,
GC_FreeBSDGetDataStart, GC_unix_mmap_get_mem, GC_unix_sbrk_get_mem,
os2_alloc, GC_wince_get_mem, GC_win32_get_mem, GC_push_thread_stack,
GC_push_old_obj, GC_write_fault_handler, catch_exception_raise_state,
catch_exception_raise_state_identity): Likewise.
* pthread_support.c (GC_new_thread, GC_lookup_thread, GC_get_nprocs,
pthread_sigmask, pthread_create): Likewise.
* ptr_chck.c (GC_same_obj, GC_default_is_visible_print_proc,
GC_default_is_valid_displacement_print_proc, GC_is_visible,
GC_pre_incr, GC_post_incr): Likewise.
* reclaim.c (GC_block_empty, GC_reclaim_uninit, GC_n_set_marks,
GC_reclaim_all): Likewise.
* tests/cpp.cc (main): Likewise.
* tests/gctest.c (fake_gcj_mark_proc, reverse1, reverse, ints,
gcj_reverse1, gcj_reverse, gcj_ints, uncollectable_ints, mktree,
alloc8bytes, main, test): Likewise.
* tools/if_mach.c (main): Likewise.
* tools/if_not_there.c (main): Likewise.
* tools/setjmp_t.c (getpagesize, main, g): Likewise.
* typd_mlc.c (GC_add_ext_descriptor, GC_add_ext_descriptor,
GC_double_descr, GC_make_array_descriptor,
GC_make_sequence_descriptor, GC_typed_mark_proc, GC_descr_obj_size,
GC_push_complex_descriptor, GC_array_mark_proc, GC_make_descriptor,
GC_calloc_explicitly_typed): Likewise.
* win32_threads.c (GC_new_thread, GC_lookup_thread_inner,
GC_get_stack_min, GC_pthread_create, GC_pthread_start_inner): Likewise.
* allchblk.c (GC_get_first_part, GC_allochblk_nth): Replace 0 to NULL
where appropriate.
* alloc.c (GC_allocobj): Likewise.
* blacklst.c (GC_is_black_listed): Likewise.
* cord/cordbscs.c (CORD_from_fn_inner, CORD_substr_checked): Likewise.
* cord/cordxtra.c (CORD_cat_char, CORD_to_char_star,
CORD_from_char_star, CORD_lf_func, CORD_from_file_lazy_inner):
Likewise.
* dbg_mlc.c (store_debug_info, GC_debug_generic_malloc,
GC_debug_generic_malloc): Likewise.
* dyn_load.c (GC_FirstDLOpenedLinkMap): Likewise.
* gcj_mlc.c (GC_debug_gcj_malloc): Likewise.
* headers.c (GC_next_block, GC_prev_block): Likewise.
* malloc.c (GC_generic_malloc, strdup): Likewise.
* mallocx.c (GC_realloc): Likewise.
* misc.c (GC_default_oom_fn, GC_base): Likewise.
* os_dep.c (GC_get_main_stack_base, os2_alloc, GC_win32_get_mem):
Likewise.
* pthread_support.c (GC_new_thread, GC_lookup_thread): Likewise.
* ptr_chck.c (GC_same_obj, GC_is_visible,
GC_default_is_valid_displacement_print_proc): Likewise.
* tests/gctest.c (mktree): Likewise.
* typd_mlc.c (GC_make_array_descriptor, GC_push_complex_descriptor,
GC_array_mark_proc, GC_calloc_explicitly_typed): Likewise.
* win32_threads.c (GC_new_thread, GC_lookup_thread_inner): Likewise.
* alloc.c (GC_never_stop_func, GC_timeout_stop_func): Replace 0 and 1
(in return statement) to FALSE and TRUE, respectively.
* include/private/gcconfig.h: Remove outermost parentheses in the
expression of return statement in comment.

1 files changed, 34 insertions, 33 deletions

diff --git a/typd_mlc.c b/typd_mlc.c
index 4078e189..e66cdbe1 100644
--- a/typd_mlc.c
+++ b/typd_mlc.c
@@ -123,7 +123,7 @@ STATIC signed_word GC_add_ext_descriptor(const word * bm, word nbits)
         } else {
             UNLOCK();
             new_size = 2 * ed_size;
-            if (new_size > MAX_ENV) return(-1);
+            if (new_size > MAX_ENV) return -1;
         }
         newExtD = (typed_ext_descr_t*)GC_malloc_atomic(new_size
                                                 * sizeof(typed_ext_descr_t));
@@ -153,7 +153,7 @@ STATIC signed_word GC_add_ext_descriptor(const word * bm, word nbits)
     GC_ext_descriptors[result + i].ed_continued = FALSE;
     GC_avail_descr += nwords;
     UNLOCK();
-    return(result);
+    return result;
 }
 
 /* Table of bitmap descriptors for n word long all pointer objects.     */
@@ -170,7 +170,7 @@ STATIC GC_descr GC_double_descr(GC_descr descriptor, word nwords)
         descriptor = GC_bm_table[BYTES_TO_WORDS((word)descriptor)];
     }
     descriptor |= (descriptor & ~GC_DS_TAGS) >> nwords;
-    return(descriptor);
+    return descriptor;
 }
 
 STATIC complex_descriptor *
@@ -208,20 +208,20 @@ STATIC int GC_make_array_descriptor(size_t nelements, size_t size,
     if ((descriptor & GC_DS_TAGS) == GC_DS_LENGTH) {
       if (descriptor == (GC_descr)size) {
         *simple_d = nelements * descriptor;
-        return(SIMPLE);
+        return SIMPLE;
       } else if ((word)descriptor == 0) {
         *simple_d = (GC_descr)0;
-        return(SIMPLE);
+        return SIMPLE;
       }
     }
     if (nelements <= OPT_THRESHOLD) {
       if (nelements <= 1) {
         if (nelements == 1) {
             *simple_d = descriptor;
-            return(SIMPLE);
+            return SIMPLE;
         } else {
             *simple_d = (GC_descr)0;
-            return(SIMPLE);
+            return SIMPLE;
         }
       }
     } else if (size <= BITMAP_BITS/2
@@ -233,13 +233,13 @@ STATIC int GC_make_array_descriptor(size_t nelements, size_t size,
                                                    BYTES_TO_WORDS(size)),
                                    simple_d, complex_d, leaf);
       if ((nelements & 1) == 0) {
-          return(result);
+          return result;
       } else {
           struct LeafDescriptor * one_element =
               (struct LeafDescriptor *)
                 GC_malloc_atomic(sizeof(struct LeafDescriptor));
 
-          if (result == NO_MEM || one_element == 0) return(NO_MEM);
+          if (NO_MEM == result || NULL == one_element) return NO_MEM;
           one_element -> ld_tag = LEAF_TAG;
           one_element -> ld_size = size;
           one_element -> ld_nelements = 1;
@@ -250,7 +250,7 @@ STATIC int GC_make_array_descriptor(size_t nelements, size_t size,
               struct LeafDescriptor * beginning =
                 (struct LeafDescriptor *)
                   GC_malloc_atomic(sizeof(struct LeafDescriptor));
-              if (beginning == 0) return(NO_MEM);
+              if (NULL == beginning) return NO_MEM;
               beginning -> ld_tag = LEAF_TAG;
               beginning -> ld_size = size;
               beginning -> ld_nelements = 1;
@@ -265,7 +265,7 @@ STATIC int GC_make_array_descriptor(size_t nelements, size_t size,
               struct LeafDescriptor * beginning =
                 (struct LeafDescriptor *)
                   GC_malloc_atomic(sizeof(struct LeafDescriptor));
-              if (beginning == 0) return(NO_MEM);
+              if (NULL == beginning) return NO_MEM;
               beginning -> ld_tag = LEAF_TAG;
               beginning -> ld_size = leaf -> ld_size;
               beginning -> ld_nelements = leaf -> ld_nelements;
@@ -281,14 +281,14 @@ STATIC int GC_make_array_descriptor(size_t nelements, size_t size,
                                 (complex_descriptor *)one_element);
               break;
           }
-          return(COMPLEX);
+          return COMPLEX;
       }
     }
 
     leaf -> ld_size = size;
     leaf -> ld_nelements = nelements;
     leaf -> ld_descriptor = descriptor;
-    return(LEAF);
+    return LEAF;
 }
 
 STATIC complex_descriptor *
@@ -309,7 +309,7 @@ GC_make_sequence_descriptor(complex_descriptor *first,
         REACHABLE_AFTER_DIRTY(first);
         REACHABLE_AFTER_DIRTY(second);
     }
-    return((complex_descriptor *)result);
+    return (complex_descriptor *)result;
 }
 
 STATIC mse * GC_typed_mark_proc(word * addr, mse * mark_stack_ptr,
@@ -375,7 +375,7 @@ STATIC mse * GC_typed_mark_proc(word * addr, mse * mark_stack_ptr,
         mark_stack_ptr -> mse_descr.w =
                         GC_MAKE_PROC(GC_typed_mark_proc_index, env + 1);
     }
-    return(mark_stack_ptr);
+    return mark_stack_ptr;
 }
 
 /* Return the size of the object described by d.  It would be faster to */
@@ -385,13 +385,13 @@ STATIC word GC_descr_obj_size(complex_descriptor *d)
 {
     switch(d -> TAG) {
       case LEAF_TAG:
-        return(d -> ld.ld_nelements * d -> ld.ld_size);
+        return d -> ld.ld_nelements * d -> ld.ld_size;
       case ARRAY_TAG:
-        return(d -> ad.ad_nelements
-               * GC_descr_obj_size(d -> ad.ad_element_descr));
+        return d -> ad.ad_nelements
+               * GC_descr_obj_size(d -> ad.ad_element_descr);
       case SEQUENCE_TAG:
-        return(GC_descr_obj_size(d -> sd.sd_first)
-               + GC_descr_obj_size(d -> sd.sd_second));
+        return GC_descr_obj_size(d -> sd.sd_first)
+               + GC_descr_obj_size(d -> sd.sd_second);
       default:
         ABORT_RET("Bad complex descriptor");
         return 0;
@@ -414,7 +414,7 @@ STATIC mse * GC_push_complex_descriptor(word *addr, complex_descriptor *d,
           GC_descr descr = d -> ld.ld_descriptor;
 
           nelements = d -> ld.ld_nelements;
-          if (msl - msp <= (ptrdiff_t)nelements) return(0);
+          if (msl - msp <= (ptrdiff_t)nelements) return NULL;
           sz = d -> ld.ld_size;
           for (i = 0; i < nelements; i++) {
               msp++;
@@ -422,7 +422,7 @@ STATIC mse * GC_push_complex_descriptor(word *addr, complex_descriptor *d,
               msp -> mse_descr.w = descr;
               current += sz;
           }
-          return(msp);
+          return msp;
         }
       case ARRAY_TAG:
         {
@@ -433,25 +433,25 @@ STATIC mse * GC_push_complex_descriptor(word *addr, complex_descriptor *d,
           for (i = 0; i < nelements; i++) {
               msp = GC_push_complex_descriptor((word *)current, descr,
                                                 msp, msl);
-              if (msp == 0) return(0);
+              if (NULL == msp) return NULL;
               current += sz;
           }
-          return(msp);
+          return msp;
         }
       case SEQUENCE_TAG:
         {
           sz = GC_descr_obj_size(d -> sd.sd_first);
           msp = GC_push_complex_descriptor((word *)current, d -> sd.sd_first,
                                            msp, msl);
-          if (msp == 0) return(0);
+          if (NULL == msp) return NULL;
           current += sz;
           msp = GC_push_complex_descriptor((word *)current, d -> sd.sd_second,
                                            msp, msl);
-          return(msp);
+          return msp;
         }
       default:
         ABORT_RET("Bad complex descriptor");
-        return 0;
+        return NULL;
    }
 }
 
@@ -466,9 +466,9 @@ STATIC mse * GC_array_mark_proc(word * addr, mse * mark_stack_ptr,
     mse * orig_mark_stack_ptr = mark_stack_ptr;
     mse * new_mark_stack_ptr;
 
-    if (descr == 0) {
+    if (NULL == descr) {
         /* Found a reference to a free list entry.  Ignore it. */
-        return(orig_mark_stack_ptr);
+        return orig_mark_stack_ptr;
     }
     /* In use counts were already updated when array descriptor was     */
     /* pushed.  Here we only replace it by subobject descriptors, so    */
@@ -529,7 +529,7 @@ GC_API GC_descr GC_CALL GC_make_descriptor(const GC_word * bm, size_t len)
 
     while (last_set_bit >= 0 && !GC_get_bit(bm, last_set_bit))
       last_set_bit--;
-    if (last_set_bit < 0) return(0 /* no pointers */);
+    if (last_set_bit < 0) return 0; /* no pointers */
 
 #   if ALIGNMENT == CPP_WORDSZ/8
     {
@@ -542,7 +542,7 @@ GC_API GC_descr GC_CALL GC_make_descriptor(const GC_word * bm, size_t len)
       }
       if (i == last_set_bit) {
         /* An initial section contains all pointers.  Use length descriptor. */
-        return (WORDS_TO_BYTES(last_set_bit+1) | GC_DS_LENGTH);
+        return WORDS_TO_BYTES(last_set_bit + 1) | GC_DS_LENGTH;
       }
     }
 #   endif
@@ -559,7 +559,7 @@ GC_API GC_descr GC_CALL GC_make_descriptor(const GC_word * bm, size_t len)
         result |= GC_DS_BITMAP;
     } else {
         signed_word index = GC_add_ext_descriptor(bm, (word)last_set_bit + 1);
-        if (index == -1) return(WORDS_TO_BYTES(last_set_bit+1) | GC_DS_LENGTH);
+        if (index == -1) return WORDS_TO_BYTES(last_set_bit+1) | GC_DS_LENGTH;
                                 /* Out of memory: use conservative      */
                                 /* approximation.                       */
         result = GC_MAKE_PROC(GC_typed_mark_proc_index, (word)index);
@@ -650,7 +650,8 @@ GC_API GC_ATTR_MALLOC void * GC_CALL GC_calloc_explicitly_typed(size_t n,
       return (*GC_get_oom_fn())(GC_SIZE_MAX); /* n*lb overflow */
     lb *= n;
     switch(descr_type) {
-        case NO_MEM: return(0);
+        case NO_MEM:
+            return NULL;
         case SIMPLE:
             return GC_malloc_explicitly_typed(lb, simple_descr);
         case LEAF: