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, 16 insertions, 15 deletions

diff --git a/rand.c b/rand.c
index 3ebc6842..f8880d42 100644
--- a/rand.c
+++ b/rand.c
@@ -74,8 +74,8 @@ static struct cobj_ops random_state_ops = {
 
 static val make_state(void)
 {
-  struct rand_state *r = (struct rand_state *) chk_malloc(sizeof *r);
-  return cobj((mem_t *) r, random_state_s, &random_state_ops);
+  struct rand_state *r = coerce(struct rand_state *, chk_malloc(sizeof *r));
+  return cobj(coerce(mem_t *, r), random_state_s, &random_state_ops);
 }
 
 val random_state_p(val obj)
@@ -108,7 +108,8 @@ val make_random_state(val seed)
 {
   val rs = make_state();
   int i;
-  struct rand_state *r = (struct rand_state *) cobj_handle(rs, random_state_s);
+  struct rand_state *r = coerce(struct rand_state *,
+                                cobj_handle(rs, random_state_s));
 
   r->cur = 0;
 
@@ -147,13 +148,13 @@ val make_random_state(val seed)
 #endif
   } else if (nilp(seed)) {
     val time = time_sec_usec();
-    r->state[0] = (rand32_t) c_num(car(time));
-    r->state[1] = (rand32_t) c_num(cdr(time));
-    r->state[2] = (rand32_t) getpid();
+    r->state[0] = convert(rand32_t, c_num(car(time)));
+    r->state[1] = convert(rand32_t, c_num(cdr(time)));
+    r->state[2] = convert(rand32_t, getpid());
     memset(r->state + 3, 0xAA, sizeof r->state - 3 * sizeof r->state[0]);
   } else if (random_state_p(seed)) {
-    struct rand_state *rseed = (struct rand_state *)
-                                  cobj_handle(seed, random_state_s);
+    struct rand_state *rseed = coerce(struct rand_state *,
+                                      cobj_handle(seed, random_state_s));
     *r = *rseed;
   } else {
     uw_throwf(error_s, lit("make-random-state: seed ~s is not a number"),
@@ -168,23 +169,23 @@ val make_random_state(val seed)
 
 val random_fixnum(val state)
 {
-  struct rand_state *r = (struct rand_state *) cobj_handle(default_arg(state,
-                                                                       random_state),
-                                                           random_state_s);
+  struct rand_state *r = coerce(struct rand_state *,
+                                cobj_handle(default_arg(state, random_state),
+                                            random_state_s));
   return num(rand32(r) & NUM_MAX);
 }
 
 val random(val state, val modulus)
 {
-  struct rand_state *r = (struct rand_state *) cobj_handle(state,
-                                                           random_state_s);
+  struct rand_state *r = coerce(struct rand_state *,
+                                cobj_handle(state, random_state_s));
 
   if (bignump(modulus)) {
     mp_int *m = mp(modulus);
     int bits = mp_count_bits(m);
     int rands_needed = (bits + 32 - 1) / 32;
     int msb_rand_bits = bits % 32;
-    rand32_t msb_rand_mask = ((rand32_t) -1) >> (32 - msb_rand_bits);
+    rand32_t msb_rand_mask = convert(rand32_t, -1) >> (32 - msb_rand_bits);
     val out = make_bignum();
     mp_int *om = mp(out);
 
@@ -223,7 +224,7 @@ val random(val state, val modulus)
     int rands_needed = (bits + 32 - 1) / 32;
 #endif
     int msb_rand_bits = bits % 32;
-    rand32_t msb_rand_mask = ((rand32_t) -1) >> (32 - msb_rand_bits);
+    rand32_t msb_rand_mask = convert(rand32_t, -1) >> (32 - msb_rand_bits);
     if (m <= 0)
       goto invalid;
     for (;;) {