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, 32 insertions, 23 deletions

diff --git a/match.c b/match.c
index 710a56ef..fee391bc 100644
--- a/match.c
+++ b/match.c
@@ -516,14 +516,14 @@ typedef val (*h_match_func)(match_line_ctx *c);
   debuglf(elem, lit(KIND " mismatch, position ~a (~a:~d)"),             \
           plus(c->pos, c->base), c->file, c->data_lineno, nao);         \
   debuglf(elem, lit("  ~a"), c->dataline, nao);                         \
-  if (c_num(c->pos) < 77)                                               \
+  if (c_num(c->pos, lit("txr")) < 77)                                   \
     debuglf(elem, lit("  ~*a^"), c->pos, lit(""), nao)
 
 #define LOG_MATCH(KIND, EXTENT)                                         \
   debuglf(elem, lit(KIND " matched, position ~a-~a (~a:~d)"),           \
           plus(c->pos, c->base), EXTENT, c->file, c->data_lineno, nao); \
   debuglf(elem, lit("  ~a"), c->dataline, nao);                         \
-  if (c_num(EXTENT) < 77)                                               \
+  if (c_num(EXTENT, lit("txr")) < 77)                                   \
     debuglf(elem, lit("  ~*a~<*a^"), c->pos, lit(""),                   \
               minus(EXTENT, c->pos), lit("^"), nao)
 
@@ -821,11 +821,12 @@ static val h_var(match_line_ctx *c)
 
 static val h_skip(match_line_ctx *c)
 {
+  val self = lit("skip");
   val elem = first(c->specline);
   val max = tleval_144(elem, second(elem), c->bindings);
   val min = tleval_144(elem, third(elem), c->bindings);
-  cnum cmax = integerp(max) ? c_num(max) : 0;
-  cnum cmin = integerp(min) ? c_num(min) : 0;
+  cnum cmax = integerp(max) ? c_num(max, self) : 0;
+  cnum cmin = integerp(min) ? c_num(min, self) : 0;
   val greedy = eq(max, greedy_k);
   val last_good_result = nil, last_good_pos = nil;
 
@@ -951,6 +952,7 @@ static val h_accept_fail(match_line_ctx *c)
 
 static val h_coll(match_line_ctx *c)
 {
+  val self = lit("coll");
   val elem = first(c->specline);
   val op_sym = first(elem);
   val coll_specline = second(elem);
@@ -980,12 +982,12 @@ static val h_coll(match_line_ctx *c)
   val have_vars, have_lists;
   val vars = getplist_f(args, vars_k, mkcloc(have_vars));
   val lists = getplist_f(args, lists_k, mkcloc(have_lists));
-  cnum cmax = if3(gap, c_num(gap), if3(max, c_num(max), 0));
-  cnum cmin = if3(gap, c_num(gap), if3(min, c_num(min), 0));
+  cnum cmax = if3(gap, c_num(gap, self), if3(max, c_num(max, self), 0));
+  cnum cmin = if3(gap, c_num(gap, self), if3(min, c_num(min, self), 0));
   cnum mincounter = cmin, maxcounter = 0;
-  cnum ctimax = if3(times, c_num(times), if3(maxtimes, c_num(maxtimes), 0));
-  cnum ctimin = if3(times, c_num(times), if3(mintimes, c_num(mintimes), 0));
-  cnum cchars = if3(chars, c_num(chars), 0);
+  cnum ctimax = if3(times, c_num(times, self), if3(maxtimes, c_num(maxtimes, self), 0));
+  cnum ctimin = if3(times, c_num(times, self), if3(mintimes, c_num(mintimes, self), 0));
+  cnum cchars = if3(chars, c_num(chars, self), 0);
   cnum timescounter = 0, charscounter = 0;
   int compat_222 = opt_compat && opt_compat <= 222;
   val iter;
@@ -1977,6 +1979,8 @@ static val extract_bindings(val bindings, val output_spec, val vars)
 
 static void do_output_line(val bindings, val specline, val filter, val out)
 {
+  val self = lit("output");
+
   if (specline == t)
     return;
 
@@ -2034,7 +2038,7 @@ static void do_output_line(val bindings, val specline, val filter, val out)
             val counter_bind = if2(counter, cons(counter_var, nil));
             cnum i;
 
-            for (i = 0; i < c_num(max_depth); i++) {
+            for (i = 0; i < c_num(max_depth, self); i++) {
               val bind_a = nappend2(mapcar(func_n1(bind_car), bind_cp), bindings);
               val bind_d = mapcar(func_n1(bind_cdr), bind_cp);
 
@@ -2046,7 +2050,7 @@ static void do_output_line(val bindings, val specline, val filter, val out)
 
               if (i == 0 && first_clauses) {
                 do_output_line(bind_a, first_clauses, filter, out);
-              } else if (i == c_num(max_depth) - 1 &&
+              } else if (i == c_num(max_depth, self) - 1 &&
                          (last_clauses || modlast_clauses)) {
                 if (modlast_clauses) {
                   val iter;
@@ -2128,6 +2132,8 @@ static void do_output_line(val bindings, val specline, val filter, val out)
 
 static void do_output(val bindings, val specs, val filter, val out)
 {
+  val self = lit("output");
+
   if (specs == t)
     return;
 
@@ -2173,7 +2179,7 @@ static void do_output(val bindings, val specs, val filter, val out)
           val counter_bind = if2(counter, cons(counter_var, nil));
           cnum i;
 
-          for (i = 0; i < c_num(max_depth); i++) {
+          for (i = 0; i < c_num(max_depth, self); i++) {
             val bind_a = nappend2(mapcar(func_n1(bind_car), bind_cp), bindings);
             val bind_d = mapcar(func_n1(bind_cdr), bind_cp);
 
@@ -2185,7 +2191,7 @@ static void do_output(val bindings, val specs, val filter, val out)
 
             if (i == 0 && first_clauses) {
               do_output(bind_a, first_clauses, filter, out);
-            } else if (i == c_num(max_depth) - 1 &&
+            } else if (i == c_num(max_depth, self) - 1 &&
                        (last_clauses || modlast_clauses))
             {
               if (modlast_clauses) {
@@ -2341,6 +2347,7 @@ typedef val (*v_match_func)(match_files_ctx *cout);
 
 static val v_skip(match_files_ctx *c)
 {
+  val self = lit("skip");
   spec_bind (specline, first_spec, c->spec);
 
   if (rest(specline))
@@ -2356,8 +2363,8 @@ static val v_skip(match_files_ctx *c)
     val args = rest(first_spec);
     val max = tleval_144(skipspec, first(args), c->bindings);
     val min = tleval_144(skipspec, second(args), c->bindings);
-    cnum cmax = integerp(max) ? c_num(max) : 0;
-    cnum cmin = integerp(min) ? c_num(min) : 0;
+    cnum cmax = integerp(max) ? c_num(max, self) : 0;
+    cnum cmin = integerp(min) ? c_num(min, self) : 0;
     val greedy = eq(max, greedy_k);
     volatile val last_good_result = nil;
     volatile val last_good_line = zero;
@@ -2430,6 +2437,7 @@ static val v_skip(match_files_ctx *c)
 
 static val v_fuzz(match_files_ctx *c)
 {
+  val self = lit("fuzz");
   spec_bind (specline, first_spec, c->spec);
 
   if (rest(specline))
@@ -2445,8 +2453,8 @@ static val v_fuzz(match_files_ctx *c)
     val args = rest(first_spec);
     val m = tleval_144(fuzz_spec, first(args), c->bindings);
     val n = tleval_144(fuzz_spec, second(args), c->bindings);
-    cnum cm = if3(m, c_num(m), 0);
-    cnum cn = if3(n, c_num(n), 0);
+    cnum cm = if3(m, c_num(m, self), 0);
+    cnum cn = if3(n, c_num(n, self), 0);
 
     {
       cnum reps, good;
@@ -3328,6 +3336,7 @@ out:
 
 static val v_collect(match_files_ctx *c)
 {
+  val self = lit("collect");
   spec_bind (specline, first_spec, c->spec);
   val op_sym = first(first_spec);
   val coll_spec = second(first_spec);
@@ -3357,14 +3366,14 @@ static val v_collect(match_files_ctx *c)
   val have_vars, have_lists;
   volatile val vars = getplist_f(args, vars_k, mkcloc(have_vars));
   val lists = getplist_f(args, lists_k, mkcloc(have_lists));
-  cnum cmax = if3(gap, c_num(gap), if3(max, c_num(max), 0));
-  cnum cmin = if3(gap, c_num(gap), if3(min, c_num(min), 0));
+  cnum cmax = if3(gap, c_num(gap, self), if3(max, c_num(max, self), 0));
+  cnum cmin = if3(gap, c_num(gap, self), if3(min, c_num(min, self), 0));
   cnum mincounter = cmin, maxcounter = 0;
-  cnum ctimax = if3(times, c_num(times), if3(maxtimes, c_num(maxtimes), 0));
-  cnum ctimin = if3(times, c_num(times), if3(mintimes, c_num(mintimes), 0));
+  cnum ctimax = if3(times, c_num(times, self), if3(maxtimes, c_num(maxtimes, self), 0));
+  cnum ctimin = if3(times, c_num(times, self), if3(mintimes, c_num(mintimes, self), 0));
   volatile cnum timescounter = 0, linescounter = 0;
-  cnum ctimes = if3(times, c_num(times), 0);
-  cnum clines = if3(lines, c_num(lines), 0);
+  cnum ctimes = if3(times, c_num(times, self), 0);
+  cnum clines = if3(lines, c_num(lines, self), 0);
   int compat_222 = opt_compat && opt_compat <= 222;
   val iter;
   uw_mark_frame;