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

diff --git a/parser.c b/parser.c
index c1984a07..08174154 100644
--- a/parser.c
+++ b/parser.c
@@ -161,12 +161,13 @@ void parser_reset(parser_t *p)
 
 val parser(val stream, val name, val lineno)
 {
+  val self = lit("parser");
   parser_t *p = coerce(parser_t *, chk_malloc(sizeof *p));
   val parser;
   parser_common_init(p);
   parser = cobj(coerce(mem_t *, p), parser_s, &parser_ops);
   p->parser = parser;
-  p->lineno = c_num(default_arg(lineno, one));
+  p->lineno = c_num(default_arg(lineno, one), self);
   p->name = name;
   p->stream = stream;
 
@@ -199,7 +200,7 @@ val parser_set_lineno(val self, val stream, val lineno)
 {
   val parser = ensure_parser(stream, nil);
   parser_t *pi = parser_get_impl(self, parser);
-  pi->lineno = c_num(lineno);
+  pi->lineno = c_num(lineno, self);
   return stream;
 }
 
@@ -264,6 +265,7 @@ static val patch_ref(parser_t *p, val obj)
 
 static void circ_backpatch(parser_t *p, struct circ_stack *up, val obj)
 {
+  val self = lit("parser");
   struct circ_stack cs = { up, obj };
 
   if (!parser_callgraph_circ_check(up, obj))
@@ -297,7 +299,7 @@ tail:
   case VEC:
     {
       cnum i;
-      cnum l = c_num(length_vec(obj));
+      cnum l = c_num(length_vec(obj), self);
 
       for (i = 0; i < l; i++) {
         val v = obj->v.vec[i];
@@ -647,7 +649,7 @@ static val lisp_parse_impl(val self, val interactive, val rlcp_p, val source_in,
   class_check (self, error_stream, stream_s);
 
   if (lineno && !missingp(lineno))
-    pi->lineno = c_num(lineno);
+    pi->lineno = c_num(lineno, self);
 
   env_vbind(dyn_env, stderr_s, error_stream);
 
@@ -834,6 +836,7 @@ val txr_parse(val source_in, val error_stream,
 
 static void report_security_problem(val name)
 {
+  val self = lit("listener");
   static int umask_warned;
 
   format(std_output,
@@ -843,7 +846,7 @@ static void report_security_problem(val name)
   if (!umask_warned++)
   {
     val um = umask_wrap(colon_k);
-    if ((c_num(um) & 022) != 022) {
+    if ((c_num(um, self) & 022) != 022) {
       format(std_output,
              lit("** possible reason: your umask has an insecure value: ~,03o\n"),
              um, nao);
@@ -1405,12 +1408,13 @@ static void hist_save(lino_t *ls, val in_stream, val out_stream,
                       val histfile, const wchar_t *histfile_w,
                       val hist_len_var)
 {
+  val self = lit("listener");
   if (histfile_w && lino_have_new_lines(ls)) {
     val histfile_tmp = scat2(histfile, lit(".tmp"));
     const wchar_t *histfile_tmp_w = c_str(histfile_tmp);
     lino_t *ltmp = lino_make(coerce(mem_t *, in_stream),
                              coerce(mem_t *, out_stream));
-    lino_hist_set_max_len(ltmp, c_num(cdr(hist_len_var)));
+    lino_hist_set_max_len(ltmp, c_num(cdr(hist_len_var), self));
     lino_hist_load(ltmp, histfile_w);
     lino_hist_save(ltmp, histfile_tmp_w, 0);
     if (lino_hist_save(ls, histfile_tmp_w, 1) == 0)
@@ -1424,6 +1428,7 @@ static void hist_save(lino_t *ls, val in_stream, val out_stream,
 
 val repl(val bindings, val in_stream, val out_stream, val env)
 {
+  val self = lit("listener");
   lino_t *ls = if3(repl_level++,
                    lino_ctx,
                    lino_ctx = lino_make(coerce(mem_t *, in_stream),
@@ -1472,7 +1477,7 @@ val repl(val bindings, val in_stream, val out_stream, val env)
   if (rcfile)
     load_rcfile(rcfile);
 
-  lino_hist_set_max_len(ls, c_num(cdr(hist_len_var)));
+  lino_hist_set_max_len(ls, c_num(cdr(hist_len_var), self));
 
   if (histfile_w) {
     if (lino_hist_load(ls, histfile_w) == 0 &&
@@ -1492,7 +1497,7 @@ val repl(val bindings, val in_stream, val out_stream, val env)
     val var_sym = intern(var_name, user_package);
     uw_frame_t uw_handler;
 
-    lino_hist_set_max_len(ls, c_num(cdr(hist_len_var)));
+    lino_hist_set_max_len(ls, c_num(cdr(hist_len_var), self));
     lino_set_multiline(ls, cdr(multi_line_var) != nil);
     lino_set_selinclusive(ls, cdr(sel_inclusive_var) != nil);
     reg_varl(counter_sym, counter);
@@ -1650,8 +1655,9 @@ static val circref(val n)
 
 static int lino_fileno(mem_t *stream_in)
 {
+  val self = lit("listener");
   val stream = coerce(val, stream_in);
-  return c_num(stream_fd(stream));
+  return c_num(stream_fd(stream), self);
 }
 
 static int lino_puts(mem_t *stream_in, const wchar_t *str_in)
@@ -1678,6 +1684,7 @@ static int lino_puts_file(mem_t *stream_in, const wchar_t *str_in)
 
 static wint_t lino_getch(mem_t *stream_in)
 {
+  val self = lit("listener");
   wint_t ret = WEOF;
 
   val stream, ch;
@@ -1687,7 +1694,7 @@ static wint_t lino_getch(mem_t *stream_in)
   stream = coerce(val, stream_in);
   ch = get_char(stream);
 
-  ret = if3(ch, (wint_t) c_num(ch), WEOF);
+  ret = if3(ch, (wint_t) c_num(ch, self), WEOF);
 
   uw_catch (sy, va) {
     (void) sy;
@@ -1703,6 +1710,7 @@ static wint_t lino_getch(mem_t *stream_in)
 
 static wchar_t *lino_getl(mem_t *stream_in, wchar_t *buf, size_t nchar)
 {
+  val self = lit("listener");
   wchar_t *ptr = buf;
   val stream = coerce(val, stream_in);
 
@@ -1713,7 +1721,7 @@ static wchar_t *lino_getl(mem_t *stream_in, wchar_t *buf, size_t nchar)
     val ch = get_char(stream);
     if (!ch)
       break;
-    if ((*ptr++ = c_num(ch)) == '\n')
+    if ((*ptr++ = c_num(ch, self)) == '\n')
       break;
   }
 
@@ -1723,6 +1731,7 @@ static wchar_t *lino_getl(mem_t *stream_in, wchar_t *buf, size_t nchar)
 
 static wchar_t *lino_gets(mem_t *stream_in, wchar_t *buf, size_t nchar)
 {
+  val self = lit("listener");
   wchar_t *ptr = buf;
   val stream = coerce(val, stream_in);
 
@@ -1733,7 +1742,7 @@ static wchar_t *lino_gets(mem_t *stream_in, wchar_t *buf, size_t nchar)
     val ch = get_char(stream);
     if (!ch)
       break;
-    *ptr++ = c_num(ch);
+    *ptr++ = c_num(ch, self);
   }
 
   *ptr++ = 0;
@@ -1753,6 +1762,7 @@ static const wchli_t *lino_mode_str[] = {
 
 static mem_t *lino_open(const wchar_t *name_in, lino_file_mode_t mode_in)
 {
+  val self = lit("listener");
   val name = string(name_in);
   val mode = static_str(lino_mode_str[mode_in]);
   val ret = 0;
@@ -1760,7 +1770,7 @@ static mem_t *lino_open(const wchar_t *name_in, lino_file_mode_t mode_in)
   ret = open_file(name, mode);
 #if HAVE_CHMOD
   if (mode_in == lino_overwrite || mode_in == lino_append)
-    (void) fchmod(c_num(stream_fd(ret)), S_IRUSR | S_IWUSR);
+    (void) fchmod(c_num(stream_fd(ret), self), S_IRUSR | S_IWUSR);
 #endif
   ignerr_end;
   return coerce(mem_t *, ret);