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, 30 insertions, 27 deletions

diff --git a/chksum.c b/chksum.c
index 1942c0b4..d4f3c4d2 100644
--- a/chksum.c
+++ b/chksum.c
@@ -47,7 +47,8 @@
 
 static val sha256_ctx_s, md5_ctx_s;
 
-static void sha256_stream_impl(val stream, val nbytes, unsigned char *hash)
+static void sha256_stream_impl(val stream, val nbytes, unsigned char *hash,
+                               val self)
 {
   SHA256_t s256;
   val buf = iobuf_get();
@@ -57,7 +58,7 @@ static void sha256_stream_impl(val stream, val nbytes, unsigned char *hash)
   if (null_or_missing_p(nbytes)) {
     for (;;) {
       val read = fill_buf(buf, zero, stream);
-      cnum rd = c_num(read);
+      cnum rd = c_num(read, self);
 
       if (!rd)
         break;
@@ -67,7 +68,7 @@ static void sha256_stream_impl(val stream, val nbytes, unsigned char *hash)
   } else {
     while (ge(nbytes, bfsz)) {
       val read = fill_buf(buf, zero, stream);
-      cnum rd = c_num(read);
+      cnum rd = c_num(read, self);
 
       if (zerop(read))
         break;
@@ -80,7 +81,7 @@ static void sha256_stream_impl(val stream, val nbytes, unsigned char *hash)
 
     {
       val read = fill_buf(buf, zero, stream);
-      cnum rd = c_num(read);
+      cnum rd = c_num(read, self);
       if (rd)
         SHA256_update(&s256, buf->b.data, rd);
     }
@@ -95,7 +96,7 @@ static val chksum_ensure_buf(val self, val buf_in,
                              val hash_name)
 {
   if (null_or_missing_p(buf_in)) {
-    *phash = chk_malloc(c_unum(len));
+    *phash = chk_malloc(c_unum(len, self));
     return make_borrowed_buf(len, *phash);
   } else {
     *phash = buf_get(buf_in, self);
@@ -112,7 +113,7 @@ val sha256_stream(val stream, val nbytes, val buf_in)
   unsigned char *hash;
   val buf = chksum_ensure_buf(self, buf_in, num_fast(SHA256_DIGEST_LENGTH),
                               &hash, lit("SHA-256"));
-  sha256_stream_impl(stream, nbytes, hash);
+  sha256_stream_impl(stream, nbytes, hash, self);
   return buf;
 }
 
@@ -128,11 +129,11 @@ static void sha256_szmax_upd(SHA256_t *ps256, mem_t *data, ucnum len)
     SHA256_update(ps256, data, len);
 }
 
-static void sha256_buf(val buf, unsigned char *hash)
+static void sha256_buf(val buf, unsigned char *hash, val self)
 {
   SHA256_t s256;
   SHA256_init(&s256);
-  sha256_szmax_upd(&s256, buf->b.data, c_unum(buf->b.len));
+  sha256_szmax_upd(&s256, buf->b.data, c_unum(buf->b.len, self));
   SHA256_final(&s256, hash);
 }
 
@@ -160,7 +161,7 @@ val sha256(val obj, val buf_in)
     sha256_str(obj, hash);
     return buf;
   case BUF:
-    sha256_buf(obj, hash);
+    sha256_buf(obj, hash, self);
     return buf;
   default:
     uw_throwf(error_s, lit("~a: cannot hash ~s, only buffer and strings"),
@@ -204,14 +205,14 @@ val sha256_hash(val ctx, val obj)
     }
     break;
   case BUF:
-    sha256_szmax_upd(ps256, obj->b.data, c_unum(obj->b.len));
+    sha256_szmax_upd(ps256, obj->b.data, c_unum(obj->b.len, self));
     break;
   case CHR:
     utf8_encode(c_chr(obj), sha256_utf8_byte_callback, coerce(mem_t *, ps256));
     break;
   case NUM:
     {
-      cnum n = c_num(obj);
+      cnum n = c_num(obj, self);
       unsigned char uc = n;
       if (n < 0 || n > 255)
         uw_throwf(error_s, lit("~a: byte value ~s out of range"),
@@ -242,6 +243,7 @@ val sha256_end(val ctx, val buf_in)
 
 val crc32_stream(val stream, val nbytes)
 {
+  val self = lit("crc32-stream");
   u32_t crc = 0;
   val buf = iobuf_get();
   val bfsz = length_buf(buf);
@@ -249,7 +251,7 @@ val crc32_stream(val stream, val nbytes)
   if (null_or_missing_p(nbytes)) {
     for (;;) {
       val read = fill_buf(buf, zero, stream);
-      cnum rd = c_num(read);
+      cnum rd = c_num(read, self);
 
       if (!rd)
         break;
@@ -259,7 +261,7 @@ val crc32_stream(val stream, val nbytes)
   } else {
     while (ge(nbytes, bfsz)) {
       val read = fill_buf(buf, zero, stream);
-      cnum rd = c_num(read);
+      cnum rd = c_num(read, self);
 
       if (zerop(read))
         break;
@@ -272,7 +274,7 @@ val crc32_stream(val stream, val nbytes)
 
     {
       val read = fill_buf(buf, zero, stream);
-      cnum rd = c_num(read);
+      cnum rd = c_num(read, self);
       if (rd)
         crc = crc32_cont(buf->b.data, rd, crc);
     }
@@ -282,9 +284,9 @@ val crc32_stream(val stream, val nbytes)
   return unum(crc);
 }
 
-static val crc32_buf(val buf)
+static val crc32_buf(val buf, val self)
 {
-  ucnum len = c_unum(buf->b.len);
+  ucnum len = c_unum(buf->b.len, self);
   mem_t *data = buf->b.data;
   const size_t szmax = convert(size_t, -1) / 4 + 1;
   u32_t crc = 0;
@@ -318,14 +320,15 @@ val crc32(val obj)
   case LIT:
     return crc32_str(obj);
   case BUF:
-    return crc32_buf(obj);
+    return crc32_buf(obj, self);
   default:
     uw_throwf(error_s, lit("~a: cannot hash ~s, only buffer and strings"),
               self, obj, nao);
   }
 }
 
-static void md5_stream_impl(val stream, val nbytes, unsigned char *hash)
+static void md5_stream_impl(val stream, val nbytes, unsigned char *hash,
+                            val self)
 {
   MD5_t md5;
   val buf = iobuf_get();
@@ -335,7 +338,7 @@ static void md5_stream_impl(val stream, val nbytes, unsigned char *hash)
   if (null_or_missing_p(nbytes)) {
     for (;;) {
       val read = fill_buf(buf, zero, stream);
-      cnum rd = c_num(read);
+      cnum rd = c_num(read, self);
 
       if (!rd)
         break;
@@ -345,7 +348,7 @@ static void md5_stream_impl(val stream, val nbytes, unsigned char *hash)
   } else {
     while (ge(nbytes, bfsz)) {
       val read = fill_buf(buf, zero, stream);
-      cnum rd = c_num(read);
+      cnum rd = c_num(read, self);
 
       if (zerop(read))
         break;
@@ -358,7 +361,7 @@ static void md5_stream_impl(val stream, val nbytes, unsigned char *hash)
 
     {
       val read = fill_buf(buf, zero, stream);
-      cnum rd = c_num(read);
+      cnum rd = c_num(read, self);
       if (rd)
         MD5_update(&md5, buf->b.data, rd);
     }
@@ -374,7 +377,7 @@ val md5_stream(val stream, val nbytes, val buf_in)
   unsigned char *hash;
   val buf = chksum_ensure_buf(self, buf_in, num_fast(MD5_DIGEST_LENGTH),
                               &hash, lit("MD5"));
-  md5_stream_impl(stream, nbytes, hash);
+  md5_stream_impl(stream, nbytes, hash, self);
   return buf;
 }
 
@@ -390,11 +393,11 @@ static void md5_szmax_upd(MD5_t *pmd5, mem_t *data, ucnum len)
     MD5_update(pmd5, data, len);
 }
 
-static void md5_buf(val buf, unsigned char *hash)
+static void md5_buf(val buf, unsigned char *hash, val self)
 {
   MD5_t md5;
   MD5_init(&md5);
-  md5_szmax_upd(&md5, buf->b.data, c_unum(buf->b.len));
+  md5_szmax_upd(&md5, buf->b.data, c_unum(buf->b.len, self));
   MD5_final(&md5, hash);
 }
 
@@ -422,7 +425,7 @@ val md5(val obj, val buf_in)
     md5_str(obj, hash);
     return buf;
   case BUF:
-    md5_buf(obj, hash);
+    md5_buf(obj, hash, self);
     return buf;
   default:
     uw_throwf(error_s, lit("~a: cannot hash ~s, only buffer and strings"),
@@ -466,14 +469,14 @@ val md5_hash(val ctx, val obj)
     }
     break;
   case BUF:
-    md5_szmax_upd(pmd5, obj->b.data, c_unum(obj->b.len));
+    md5_szmax_upd(pmd5, obj->b.data, c_unum(obj->b.len, self));
     break;
   case CHR:
     utf8_encode(c_chr(obj), md5_utf8_byte_callback, coerce(mem_t *, pmd5));
     break;
   case NUM:
     {
-      cnum n = c_num(obj);
+      cnum n = c_num(obj, self);
       unsigned char uc = n;
       if (n < 0 || n > 255)
         uw_throwf(error_s, lit("~a: byte value ~s out of range"),