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

diff --git a/eval.c b/eval.c
index 1d1b6cf0..f0a1c90d 100644
--- a/eval.c
+++ b/eval.c
@@ -1529,6 +1529,7 @@ val eval_intrinsic_noerr(val form, val env, val *error_p)
 static val do_eval(val form, val env, val ctx,
                    val (*lookup)(val env, val sym))
 {
+  val self = lit("eval");
   uw_frame_t *ev = 0;
   val ret = nil;
 
@@ -1570,7 +1571,7 @@ static val do_eval(val form, val env, val ctx,
         abort();
       } else {
         val arglist = rest(form);
-        cnum alen = if3(consp(arglist), c_num(length(arglist)), 0);
+        cnum alen = if3(consp(arglist), c_num(length(arglist), self), 0);
         cnum argc = max(alen, ARGS_MIN);
         val lfe_save = last_form_evaled;
         args_decl(args, argc);
@@ -2642,7 +2643,7 @@ static val op_dwim(val form, val env)
 {
   val argexps = rest(form);
   val objexpr = pop(&argexps);
-  cnum alen = if3(consp(argexps), c_num(length(argexps)), 0);
+  cnum alen = if3(consp(argexps), c_num(length(argexps), car(form)), 0);
   cnum argc = max(alen, ARGS_MIN);
   args_decl(args, argc);
 
@@ -3889,7 +3890,7 @@ static val me_op(val form, val menv)
                    gethash(op_table, car(body_trans)));
   uw_pop_frame(&uw_handler);
 
-  if (c_num(max) > 1024)
+  if (c_num(max, sym) > 1024)
     eval_error(form, lit("~a: @~a calls for function with too many arguments"),
                sym, max, nao);
 
@@ -5008,11 +5009,12 @@ static val no_warn_expand(val form, val menv)
 
 static val gather_free_refs(val info_cons, val exc, struct args *args)
 {
+  val self = lit("expand-with-free-refs");
   (void) exc;
 
   args_normalize_least(args, 2);
 
-  if (args_count(args) == 2) {
+  if (args_count(args, self) == 2) {
     val tag = args_at(args, 1);
     cons_bind (kind, sym, tag);
 
@@ -5285,7 +5287,7 @@ static val map_common(val self, val fun, struct args *lists,
   } else if (!args_two_more(lists, 0)) {
     return map_fn(fun, args_atz(lists, 0));
   } else {
-    cnum i, idx, argc = args_count(lists);
+    cnum i, idx, argc = args_count(lists, self);
     seq_iter_t *iter_array = coerce(seq_iter_t *,
                                     alloca(argc * sizeof *iter_array));
     args_decl(args_fun, max(argc, ARGS_MIN));
@@ -5407,7 +5409,7 @@ static val lazy_mappendv(val fun, struct args *lists)
   return lazy_appendl(lazy_mapcarv(fun, lists));
 }
 
-static val prod_common(val fun, struct args *lists,
+static val prod_common(val self, val fun, struct args *lists,
                        loc (*collect_fn)(loc ptail, val obj),
                        val (*mapv_fn)(val fun, struct args *lists))
 {
@@ -5416,7 +5418,7 @@ static val prod_common(val fun, struct args *lists,
   } else if (!args_two_more(lists, 0)) {
     return mapv_fn(fun, lists);
   } else {
-    cnum argc = args_count(lists), i;
+    cnum argc = args_count(lists, self), i;
     list_collect_decl (out, ptail);
     args_decl(args_reset, max(argc, ARGS_MIN));
     args_decl(args_work, max(argc, ARGS_MIN));
@@ -5455,12 +5457,12 @@ static val prod_common(val fun, struct args *lists,
 
 val maprodv(val fun, struct args *lists)
 {
-  return prod_common(fun, lists, list_collect, mapcarv);
+  return prod_common(lit("maprodv"), fun, lists, list_collect, mapcarv);
 }
 
 val maprendv(val fun, struct args *lists)
 {
-  return prod_common(fun, lists, list_collect_append, mappendv);
+  return prod_common(lit("maprendv"), fun, lists, list_collect_append, mappendv);
 }
 
 static loc collect_nothing(loc ptail, val obj)
@@ -5471,7 +5473,7 @@ static loc collect_nothing(loc ptail, val obj)
 
 static val maprodo(val fun, struct args *lists)
 {
-  return prod_common(fun, lists, collect_nothing, mappendv);
+  return prod_common(lit("maprodo"), fun, lists, collect_nothing, mappendv);
 }
 
 static val symbol_value(val sym)
@@ -6089,9 +6091,10 @@ static val do_apf(val fun, struct args *args)
 
 static val do_args_apf(val dargs, struct args *args)
 {
+  val self = lit("apf");
   val fun = dargs->a.car;
   struct args *da = dargs->a.args;
-  cnum da_nargs = da->fill + c_num(length(da->list));
+  cnum da_nargs = da->fill + c_num(length(da->list), self);
   args_decl(args_call, max(args->fill + da_nargs, ARGS_MIN));
   args_copy(args_call, da);
   args_normalize_exact(args_call, da_nargs);
@@ -6115,9 +6118,10 @@ static val do_ipf(val fun, struct args *args)
 
 static val do_args_ipf(val dargs, struct args *args)
 {
+  val self = lit("ipf");
   val fun = dargs->a.car;
   struct args *da = dargs->a.args;
-  cnum da_nargs = da->fill + c_num(length(da->list));
+  cnum da_nargs = da->fill + c_num(length(da->list), self);
   args_decl(args_call, max(args->fill + da_nargs, ARGS_MIN));
   args_copy(args_call, da);
   args_normalize_exact(args_call, da_nargs);