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, 44 insertions, 36 deletions

diff --git a/termios.c b/termios.c
index ea73365c..cce146c2 100644
--- a/termios.c
+++ b/termios.c
@@ -207,22 +207,22 @@ static val termios_unpack(struct termios *in)
   return out;
 }
 
-static void termios_pack(struct termios *out, val in)
+static void termios_pack(struct termios *out, val in, val self)
 {
   int i, cc_sz = convert(int, sizeof out->c_cc / sizeof out->c_cc[0]);
   val cc = slot(in, cc_s);
 
-  out->c_iflag = c_num(slot(in, iflag_s));
-  out->c_oflag = c_num(slot(in, oflag_s));
-  out->c_cflag = c_num(slot(in, cflag_s));
-  out->c_lflag = c_num(slot(in, lflag_s));
+  out->c_iflag = c_num(slot(in, iflag_s), self);
+  out->c_oflag = c_num(slot(in, oflag_s), self);
+  out->c_cflag = c_num(slot(in, cflag_s), self);
+  out->c_lflag = c_num(slot(in, lflag_s), self);
 
-  cfsetispeed(out, termios_baud_to_speed(c_num(slot(in, ispeed_s))));
-  cfsetospeed(out, termios_baud_to_speed(c_num(slot(in, ospeed_s))));
+  cfsetispeed(out, termios_baud_to_speed(c_num(slot(in, ispeed_s), self)));
+  cfsetospeed(out, termios_baud_to_speed(c_num(slot(in, ospeed_s), self)));
 
   for (i = 0; i < cc_sz; i++) {
     val ch = vecref(cc, num_fast(i));
-    cnum c = c_num(ch);
+    cnum c = c_num(ch, self);
 
     out->c_cc[i] = c;
 
@@ -249,39 +249,41 @@ static val get_fd(val stream)
 
 static val tcgetattr_wrap(val stream)
 {
+  val self = lit("tcgetattr");
   struct termios tio;
   int res;
   val fd = get_fd(stream);
 
-  res = tcgetattr(c_num(fd), &tio);
+  res = tcgetattr(c_num(fd, self), &tio);
 
   if (res < 0)
-    uw_throwf(system_error_s, lit("tcgetattr failed: ~d/~s"),
-              num(errno), errno_to_str(errno), nao);
+    uw_throwf(system_error_s, lit("~a: failed: ~d/~s"),
+              self, num(errno), errno_to_str(errno), nao);
 
   return termios_unpack(&tio);
 }
 
 static val tcsetattr_wrap(val termios, val actions, val stream)
 {
+  val self = lit("tcsetattr");
   struct termios tio;
   int res;
   val fd = get_fd(stream);
 
   actions = default_arg(actions, num(TCSADRAIN));
 
-  res = tcgetattr(c_num(fd), &tio);
+  res = tcgetattr(c_num(fd, self), &tio);
 
   if (res < 0)
-    uw_throwf(system_error_s, lit("tcgetattr failed: ~d/~s"),
-              num(errno), errno_to_str(errno), nao);
+    uw_throwf(system_error_s, lit("~a: failed to retrieve settings: ~d/~s"),
+              self, num(errno), errno_to_str(errno), nao);
 
-  termios_pack(&tio, termios);
+  termios_pack(&tio, termios, self);
 
-  res = tcsetattr(c_num(fd), c_num(actions), &tio);
+  res = tcsetattr(c_num(fd, self), c_num(actions, self), &tio);
 
   if (res < 0)
-    uw_throwf(system_error_s, lit("tcsetattr failed: ~d/~s"),
+    uw_throwf(system_error_s, lit("~a: failed: ~d/~s"),
               num(errno), errno_to_str(errno), nao);
 
   return termios;
@@ -289,61 +291,66 @@ static val tcsetattr_wrap(val termios, val actions, val stream)
 
 static val tcsendbreak_wrap(val duration, val stream)
 {
+  val self = lit("tcsendbreak");
   val fd = get_fd(stream);
-  int res = tcsendbreak(c_num(fd), if3(missingp(duration),
-                                       500, c_num(duration)));
+  int res = tcsendbreak(c_num(fd, self), if3(missingp(duration),
+                                       500, c_num(duration, self)));
 
   if (res < 0)
-    uw_throwf(system_error_s, lit("tcsendbreak failed: ~d/~s"),
-              num(errno), errno_to_str(errno), nao);
+    uw_throwf(system_error_s, lit("~a: failed: ~d/~s"),
+              self, num(errno), errno_to_str(errno), nao);
 
   return t;
 }
 
 static val tcdrain_wrap(val stream)
 {
+  val self = lit("tcdrain");
   val fd = get_fd(stream);
-  int res = tcdrain(c_num(fd));
+  int res = tcdrain(c_num(fd, self));
 
   if (res < 0)
-    uw_throwf(system_error_s, lit("tcdrain failed: ~d/~s"),
-              num(errno), errno_to_str(errno), nao);
+    uw_throwf(system_error_s, lit("~a: failed: ~d/~s"),
+              self, num(errno), errno_to_str(errno), nao);
 
   return t;
 }
 
 static val tcflush_wrap(val queue, val stream)
 {
+  val self = lit("tcflush");
   val fd = get_fd(stream);
-  int res = tcflush(c_num(fd), c_num(queue));
+  int res = tcflush(c_num(fd, self), c_num(queue, self));
 
   if (res < 0)
-    uw_throwf(system_error_s, lit("tcflush failed: ~d/~s"),
-              num(errno), errno_to_str(errno), nao);
+    uw_throwf(system_error_s, lit("~a: failed: ~d/~s"),
+              self, num(errno), errno_to_str(errno), nao);
 
   return t;
 }
 
 static val tcflow_wrap(val action, val stream)
 {
+  val self = lit("tcflush");
   val fd = get_fd(stream);
-  int res = tcflow(c_num(fd), c_num(action));
+  int res = tcflow(c_num(fd, self), c_num(action, self));
 
   if (res < 0)
-    uw_throwf(system_error_s, lit("tcflow failed: ~d/~s"),
-              num(errno), errno_to_str(errno), nao);
+    uw_throwf(system_error_s, lit("~a: failed: ~d/~s"),
+              self, num(errno), errno_to_str(errno), nao);
 
   return t;
 }
 
 static val encode_speeds(val termios)
 {
+  val self = lit("encode-speeds");
   struct termios tio = all_zero_init;
 
-  tio.c_iflag = c_num(slot(termios, iflag_s));
-  tio.c_cflag = c_num(slot(termios, cflag_s));
-  cfsetispeed(&tio, termios_baud_to_speed(c_num(slot(termios, ispeed_s))));
-  cfsetospeed(&tio, termios_baud_to_speed(c_num(slot(termios, ospeed_s))));
+  tio.c_iflag = c_num(slot(termios, iflag_s), self);
+  tio.c_cflag = c_num(slot(termios, cflag_s), self);
+  cfsetispeed(&tio, termios_baud_to_speed(c_num(slot(termios, ispeed_s), self)));
+  cfsetospeed(&tio, termios_baud_to_speed(c_num(slot(termios, ospeed_s), self)));
   slotset(termios, iflag_s, num(tio.c_iflag));
   slotset(termios, cflag_s, num(tio.c_cflag));
 
@@ -352,10 +359,11 @@ static val encode_speeds(val termios)
 
 static val decode_speeds(val termios)
 {
+  val self = lit("decode-speeds");
   struct termios tio = all_zero_init;
 
-  tio.c_cflag = c_num(slot(termios, cflag_s));
-  tio.c_iflag = c_num(slot(termios, iflag_s));
+  tio.c_cflag = c_num(slot(termios, cflag_s), self);
+  tio.c_iflag = c_num(slot(termios, iflag_s), self);
   slotset(termios, ispeed_s, num(termios_speed_to_baud(cfgetispeed(&tio))));
   slotset(termios, ospeed_s, num(termios_speed_to_baud(cfgetospeed(&tio))));