Converting cast expressions to macros that are retargetted

to C++ style casts when compiling as C++.

* lib.h (strip_qual, convert, coerce): New casting macros.
(TAG_MASK, tag, type, wli_noex, auto_str, static_str,
litptr, num_fast, chr, lit_noex, nil, nao): Use cast macros.

* arith.c (mul, isqrt_fixnum, bit): Use cast macros.

* configure (INT_PTR_MAX): Define using cast macro.

* debug.c (debug_init): Use cast macro.

* eval.c (do_eval, expand_macro, reg_op, reg_mac, eval_init):
Use cast macros.

* filter.c (filter_init): Use cast macro.

* gc.c (more, mark_obj, in_heap, mark, sweep_one, unmark): Use
cast macros.

* hash.c (hash_double, equal_hash, eql_hash, hash_equal_op,
hash_hash_op, hash_print_op, hash_mark, make_hash, make_similar_hash,
copy_hash, gethash_c, gethash, gethash_f, gethash_n, remhash,
hash_count, get_hash_userdata, set_hash_userdata, hash_iter_destroy,
hash_iter_mark, hash_begin, hash_uni, hash_diff, hash_isec): Use
cast macros.

* lib.c (code2type, chk_malloc, chk_malloc_gc_more, chk_calloc,
chk_realloc, chk_strdup, num, c_num, string, mkstring, mkustring,
upcase_str, downcase_str, string_extend, sub_str, cat_str, trim_str,
c_chr, vector, vec_set_length, copy_vec, sub_vec, cat_vec,
cobj_print_op, obj_init): Likewise.

* match.c (do_match_line, hv_trampoline, match_files, dir_tables_init):
Likewise.

* parser.l (grammar): Likewise.

* parser.y (parse): Likewise.

* rand.c (make_state, make_random_state, random_fixnum, random):
Likewise.

* regex.c (CHAR_SET_L2_LO, CHAR_SET_L2_HI, CHAR_SET_L1_LO,
CHAR_SET_L1_HI, CHAR_SET_L0_LO, CHAR_SET_L0_HI, L0_full, L0_fill_range,
L1_full, L1_fill_range, L1_contains, L1_free, L2_full, L2_fill_range,
L2_contains, L2_free, L3_fill_range, L3_contains, L3_free,
char_set_create, char_set_cobj_destroy, nfa_state_accept,
nfa_state_empty, nfa_state_single, nfa_state_wild, nfa_state_set,

1 files changed, 8 insertions, 8 deletions

diff --git a/gc.c b/gc.c
index 516ba6d6..850605c5 100644
--- a/gc.c
+++ b/gc.c
@@ -128,7 +128,7 @@ void protect(val *first, ...)
 
 static void more(void)
 {
-  heap_t *heap = (heap_t *) chk_malloc_gc_more(sizeof *heap);
+  heap_t *heap = coerce(heap_t *, chk_malloc_gc_more(sizeof *heap));
   obj_t *block = heap->block, *end = heap->block + HEAP_SIZE;
 
   if (end > heap_max_bound)
@@ -139,7 +139,7 @@ static void more(void)
 
   while (block < end) {
     block->t.next = free_list;
-    block->t.type = (type_t) FREE;
+    block->t.type = convert(type_t, FREE);
     free_list = block++;
   }
 
@@ -282,7 +282,7 @@ tail_call:
   if ((t & FREE) != 0)
     abort();
 
-  obj->t.type = (type_t) (t | REACHABLE);
+  obj->t.type = convert(type_t, t | REACHABLE);
 
 #if EXTRA_DEBUGGING
   if (obj == break_obj)
@@ -364,7 +364,7 @@ static int in_heap(val ptr)
 
   for (heap = heap_list; heap != 0; heap = heap->next) {
     if (ptr >= heap->block && ptr < heap->block + HEAP_SIZE)
-      if (((char *) ptr - (char *) heap->block) % sizeof (obj_t) == 0)
+      if ((coerce(char *, ptr) - coerce(char *, heap->block)) % sizeof (obj_t) == 0)
         return 1;
   }
 
@@ -430,7 +430,7 @@ static void mark(mach_context_t *pmc, val *gc_stack_top)
   /*
    * Then the machine context
    */
-  mark_mem_region((val *) pmc, (val *) (pmc + 1));
+  mark_mem_region(coerce(val *, pmc), coerce(val *, (pmc + 1)));
 
   /*
    * Finally, the stack.
@@ -455,7 +455,7 @@ static int sweep_one(obj_t *block)
     abort();
 
   if (block->t.type & REACHABLE) {
-    block->t.type = (type_t) (block->t.type & ~REACHABLE);
+    block->t.type = convert(type_t, block->t.type & ~REACHABLE);
 #if CONFIG_GEN_GC
     block->t.gen = 1;
 #endif
@@ -471,7 +471,7 @@ static int sweep_one(obj_t *block)
   }
 
   finalize(block);
-  block->t.type = (type_t) (block->t.type | FREE);
+  block->t.type = convert(type_t, block->t.type | FREE);
 
   /* If debugging is turned on, we want to catch instances
      where a reachable object is wrongly freed. This is difficult
@@ -703,7 +703,7 @@ void unmark(void)
          block < end;
          block++)
     {
-      block->t.type = (type_t) (block->t.type & ~(FREE | REACHABLE));
+      block->t.type = convert(type_t, block->t.type & ~(FREE | REACHABLE));
     }
   }
 }