c_num: now takes self argument.

The c_num and c_unum functions now take a self argument for
identifying the calling function. This requires changes in a
large number of places.

In a few places, additional functions acquire a self
argument. The ffi module has the most extensive example of
this.

Some functions mention their name in a larger string, or have
scattered literals giving their name; with the introduction of
the self local variable, these are replaced by references to
self.

In the following changelog, the notation TS stands for "take
self argument", meaning that the functions acquires a new "val
self" argument. The notation DS means "define self": the functions
in question defines a self variable, which they pass down.
The notation PS means that the functions pass down an existing
self variable to functions that now require it.

* args.h (args_count): TS.

* arith.c (c_unum, c_num): TS.
(toint, exptv): DS.

* buf.c (buf_check_len, buf_check_alloc_size, buf_check_index,
buf_do_set_len, replace_buf, buf_put_buf, buf_put_i8,
buf_put_u8, buf_put_char, buf_put_uchar, buf_get_bytes,
buf_get_i8, buf_get_u8, buf_get_cptr,
buf_strm_get_byte_callback, buf_strm_unget_byte, buf_swap32,
str_buf, buf_int, buf_uint, int_buf, uint_buf): PS.
(make_duplicate_buf, buf_shrink, sub_buf, buf_print,
buf_pprint): DS.

* chskum.c (sha256_stream_impl, sha256_buf, crc32_buf,
md5_stream_impl, md5_buf): TS.
(chksum_ensure_buf, sha256_stream, sha256, sha256_hash,
md5_stream, md5, md5_hash): PS.
(crc32_stream): DS.

* combi.c (perm_while_fun, perm_gen_fun_common,
perm_str_gen_fun, rperm_gen_fun, comb_vec_gen_fun,
comb_str_gen_fun, rcomb_vec_gen_fun, rcomb_str_gen_fun): DS.

* diff.c (dbg_clear, dbg_set, dbg_restore): DS.

* eval.c (do_eval, gather_free_refs, maprodv, maprendv,
maprodo, do_args_apf, do_args_ipf): DS.
(op_dwim, me_op, map_common): PS.
(prod_common): TS.

* ffi.c (struct txr_ffi_type): release member TS.
(make_ffi_type_pointer): PS and release argument TS.
(ffi_varray_dynsize, ffi_array_in, ffi_array_put_common,
ffi_array_get_common, ffi_varray_in, ffi_varray_null_term): PS.
(ffi_simple_release, ffi_ptr_in_release, ffi_struct_release,
ffi_wchar_array_get, ffi_array_release_common,
ffi_array_release, ffi_varray_release): TS.
(ffi_float_put, double_put, ffi_be_i16_put, ffi_be_u16_put,
ffi_le_i16_put, ffi_le_u16_put, ffi_be_i32_put, ffi_be_u32_put,
ffi_le_i32_put, ffi_sbit_put, ffi_ubit_put, ffi_buf_d_put,
make_ffi_type_array, make_ffi_type_enum, ffi_type_compile,
make_ffi_type_desc, ffi_make_call_desc, ffi_call_wrap,
ffi_closure_dispatch_save, ffi_put_into, ffi_in, ffi_get,
ffi_put, carray_set_length, carray_blank, carray_buf,
carray_buf_sync, carray_cptr, carray_refset, carray_sub,
carray_replace, carray_uint, carray_int): PS.
(carray_vec, carray_list): DS.

* filter.c (url_encode, url_decode, base64_stream_enc_impl): DS.

* ftw.c (ftw_callback, ftw_wrap): DS.

* gc.c (mark_obj, gc_set_delta): DS.

* glob.c (glob_wrap): DS.

* hash.c (equal_hash, eql_hash, eq_hash, do_make_hash,
hash_equal, set_hash_traversal_limit, gen_hash_seed): DS.

* itypes.c (c_i8, c_u8, c_i16, c_u16, c_i32, c_u32, c_i64,
c_u64, c_short, c_ushort, c_int, c_uint, c_long, c_ulong): PS.

* lib.c (seq_iter_rewind): TS and becomes internal.
(seq_iter_init_with_info, seq_setpos, replace_str, less,
replace_vec, diff, isec, obj_print_impl): PS.
(nthcdr, equal, mkstring, mkustring, upcase_str, downcase_str,
search_str, sub_str, cat_str, scat2, scat3, fmt_join,
split_str_keep, split_str_set, trim_str, int_str, chr_int,
chr_str, chr_str_set, vector, vecref, vecref_l, list_vec,
copy_vec, sub_vec, cat_vec, lazy_str_put, lazy_str_gt,
length_str_ge, length_str_lt, length_str_le, cptr_size_hint,
cptr_int, out_lazy_str, out_quasi_str, time_string_local_time,
time_string_utc, time_fields_local_time, time_fields_utc,
time_struct_local, time_struct_utc, make_time, time_meth,
time_parse_meth): DS.
(init_str, cat_str_init, cat_str_measure, cat_str_append,
vscat, time_fields_to_tm, time_struct_to_tm, make_time_impl): TS.

* lib.h (seq_iter_rewind): Declaration removed.
(c_num, c_unum, init_str): Declarations updated.

* match.c (LOG_MISMATCH, LOG_MATCH): PS.
(h_skip, h_coll, do_output_line, do_output, v_skip, v_fuzz,
v_collect): DS.

* parser.c (parser, circ_backpatch, report_security_problem,
hist_save, repl, lino_fileno, lino_getch, lineno_getl,
lineno_gets, lineno_open): DS.
(parser_set_lineno, lisp_parse_impl): PS.

* parser.l (YY_INPUT): PS.

* rand.c (make_random_state): PS.

* regex.c (print_rec): DS.
(search_regex): PS.

* signal.c (kill_wrap, raise_wrap, get_sig_handler,
getitimer_wrap, setitimer_wrap): DS.

* socket.c (addrinfo_in, sockaddr_pack, fd_timeout,
to_connect, open_sockfd, sock_mark_connected,
sock_timeout): TS.
(getaddrinfo_wrap, dgram_set_sock_peer, sock_bind,
sock_connect, sock_listen, sock_accept, sock_shutdown,
sock_send_timeout, sock_recv_timeout, socketpair_wrap): DS.

* stream.c (generic_fill_buf, errno_to_string, stdio_truncate,
string_out_put_string, open_fileno, open_command, base_name,
dir-name): DS.
(unget_byte, put_buf, fill_buf, fill_buf_adjust,
get_line_as_buf, formatv, put_byte, test_set_indent_mode,
test_neq_set_indent_mode, set_indent_mode, set_indent,
inc_indent, set_max_length, set_max_depth, open_subprocess, run ): PS.
(fds_subst, fds_swizzle): TS.

* struct.c (make_struct_type, super, umethod_args_fun): PS.
(method_args_fun): DS.

* strudel.c (strudel_put_buf, strudel_fill_buf): DS.

* sysif.c (errno_wrap, exit_wrap, usleep_wrap, mkdir_wrap,
ensure_dir, makedev_wrap, minor_wrap, major_wrap, mknod_wrap,
mkfifo_wrap, wait_wrap, wifexited, wexitstatus, wifsignaled,
wtermsig, wcoredump, wifstopped, wstopsig, wifcontinued,
dup_wrap, close_wrap, exit_star_wrap, umask_wrap, setuid_wrap,
seteuid_wrap, setgid_wrap, setegid_wrap,
simulate_setuid_setgid, getpwuid_wrap, fnmatch_wrap,
dlopen_wrap): DS.
(chmod_wrap, do_chown, flock_pack, do_utimes, poll_wrap,
setgroups_wrap, setresuid_wrap, setresgid_wrap, getgrgid_wrap): PS.
(c_time): TS.

* sysif.h (c_time): Declaration updated.

* syslog.c (openlog_wrap, syslog_wrap): DS.

* termios.c (termios_pack): TS.
(tcgetattr_wrap, tcsetattr_wrap, tcsendbreak_wrap,
tcdrain_wrap, tcflush_wrap, tcflow_rap, encode_speeds,
decode_speeds): DS.

* txr.c (compato, array_dim, gc_delta): DS.

* unwind.c (uw_find_frames_by_mask): DS.

* vm.c (vm_make_desc): PS.
(vm_make_closure, vm_swtch): DS.

1 files changed, 29 insertions, 17 deletions

diff --git a/hash.c b/hash.c
index 3c76e68a..90727284 100644
--- a/hash.c
+++ b/hash.c
@@ -200,6 +200,8 @@ static ucnum hash_double(double n)
 
 ucnum equal_hash(val obj, int *count, ucnum seed)
 {
+  val self = lit("hash-equal");
+
   if ((*count)-- <= 0)
     return 0;
 
@@ -216,7 +218,7 @@ ucnum equal_hash(val obj, int *count, ucnum seed)
   case CHR:
     return c_chr(obj);
   case NUM:
-    return c_num(obj);
+    return c_num(obj, self);
   case SYM:
   case PKG:
   case ENV:
@@ -235,7 +237,7 @@ ucnum equal_hash(val obj, int *count, ucnum seed)
     {
       val length = obj->v.vec[vec_length];
       ucnum h = equal_hash(obj->v.vec[vec_length], count, seed);
-      cnum i, len = c_num(length);
+      cnum i, len = c_num(length, self);
       ucnum lseed;
 
       for (i = 0, lseed = seed; i < len; i++, lseed += seed) {
@@ -269,7 +271,7 @@ ucnum equal_hash(val obj, int *count, ucnum seed)
     return equal_hash(obj->rn.from, count, seed)
             + equal_hash(obj->rn.to, count, seed + (RNG << 8));
   case BUF:
-    return hash_buf(obj->b.data, c_unum(obj->b.len), seed, count);
+    return hash_buf(obj->b.data, c_unum(obj->b.len, self), seed, count);
   case TNOD:
     return equal_hash(obj->tn.left, count, (seed + TNOD))
             + equal_hash(obj->tn.right, count, seed + (TNOD << 8))
@@ -281,6 +283,8 @@ ucnum equal_hash(val obj, int *count, ucnum seed)
 
 static ucnum eql_hash(val obj, int *count)
 {
+  val self = lit("hash-eql");
+
   if ((*count)-- <= 0)
     return 0;
 
@@ -306,7 +310,7 @@ static ucnum eql_hash(val obj, int *count)
   case TAG_CHR:
     return c_chr(obj);
   case TAG_NUM:
-    return c_num(obj);
+    return c_num(obj, self);
   case TAG_LIT:
     switch (CHAR_BIT * sizeof (mem_t *)) {
     case 32:
@@ -321,6 +325,8 @@ static ucnum eql_hash(val obj, int *count)
 
 static ucnum eq_hash(val obj)
 {
+  val self = lit("hash");
+
   switch (tag(obj)) {
   case TAG_PTR:
     switch (CHAR_BIT * sizeof (mem_t *)) {
@@ -332,7 +338,7 @@ static ucnum eq_hash(val obj)
   case TAG_CHR:
     return c_chr(obj);
   case TAG_NUM:
-    return c_num(obj);
+    return c_num(obj, self);
   case TAG_LIT:
     switch (CHAR_BIT * sizeof (mem_t *)) {
     case 32:
@@ -761,6 +767,8 @@ static_def(struct hash_ops hash_equal_ops = hash_ops_init(equal_hash, equal,
 static val do_make_hash(val weak_keys, val weak_vals,
                         hash_type_t type, val seed)
 {
+  val self = lit("make-hash");
+
   if (weak_keys && type == hash_type_equal) {
     uw_throwf(error_s,
               lit("make-hash: bad combination :weak-keys with :equal-based"),
@@ -774,9 +782,9 @@ static val do_make_hash(val weak_keys, val weak_vals,
 
     h->seed = convert(u32_t, c_unum(default_arg(seed,
                                                 if3(hash_seed_s,
-                                                    hash_seed, zero))));
+                                                    hash_seed, zero)), self));
     h->flags = convert(hash_flags_t, flags);
-    h->modulus = c_num(mod);
+    h->modulus = c_num(mod, self);
     h->count = 0;
     h->table = table;
     h->userdata = nil;
@@ -826,7 +834,7 @@ val make_similar_hash(val existing)
   val table = vector(mod, nil);
   val hash = cobj(coerce(mem_t *, h), hash_s, &hash_ops);
 
-  h->modulus = c_num(mod);
+  h->modulus = c_num(mod, self);
   h->count = 0;
   h->table = table;
   h->userdata = ex->userdata;
@@ -977,7 +985,7 @@ val clearhash(val hash)
   val mod = num_fast(256);
   val table = vector(mod, nil);
   cnum oldcount = h->count;
-  h->modulus = c_num(mod);
+  h->modulus = c_num(mod, self);
   h->count = 0;
   h->table = table;
   setcheck(hash, table);
@@ -1171,8 +1179,10 @@ val hash_eql(val obj)
 
 val hash_equal(val obj, val seed)
 {
+  val self = lit("hash-equal");
   int lim = hash_traversal_limit;
-  return num_fast(equal_hash(obj, &lim, if3(missingp(seed), 0, c_unum(seed))));
+  return num_fast(equal_hash(obj, &lim,
+                             if3(missingp(seed), 0, c_unum(seed, self))));
 }
 
 /*
@@ -1831,22 +1841,24 @@ val hash_invert(val hash, val joinfun, val unitfun, struct args *hashv_args)
 
 static val set_hash_traversal_limit(val lim)
 {
+  val self = lit("set-hash-traversal-limit");
   val old = num(hash_traversal_limit);
-  hash_traversal_limit = c_num(lim);
+  hash_traversal_limit = c_num(lim, self);
   return old;
 }
 
 static val gen_hash_seed(void)
 {
-    val time = time_sec_usec();
-    ucnum sec = convert(ucnum, c_time(car(time)));
-    ucnum usec = c_unum(cdr(time));
+  val self = lit("gen-hash-seed");
+  val time = time_sec_usec();
+  ucnum sec = convert(ucnum, c_time(car(time), self));
+  ucnum usec = c_unum(cdr(time), self);
 #if HAVE_UNISTD_H
-    ucnum pid = convert(ucnum, getpid());
+  ucnum pid = convert(ucnum, getpid());
 #else
-    ucnum pid = 0;
+  ucnum pid = 0;
 #endif
-    return unum(sec ^ (usec << 12) ^ pid);
+  return unum(sec ^ (usec << 12) ^ pid);
 }
 
 void hash_init(void)