Better identify functions that misuse COBJ-s and hashes.

In this patch, the cobj_handle, cobj_ops and variants of
gethash get an additional argument to identify the caller.
Many functions are updated to pass this down.

* buf.c (buf_strm): Pass self name to cobj_handle.

* eval.c (env_fbind, env_vbind, rt_defvarl, me_case): Pass
self name to gethash_c or gethash_e.
(load): Pass self name to read_eval_stream and
read_compiled_file.
(reg_symacro): Pass situation-identifying string to gethash_c.

* ffi.c (ffi_type_struct_checked, ffi_closure_struct_checked,
ffi_call_desc_checked, uni_struct_checked):
Take self name parameter, and pass down to cobj_handle.
(ffi_get_type, ffi_get_lisp_type): Take self name and pass
down to ffi_type_struct_checked.
(union_get_ptr): Take self name and pass to
uni_struct_checked.
(ffi_union_in, ffi_union_put): Pass self name to union_get_ptr.
(ffi_type_compile): Pass self name to ffi_get_lisp_type.
(ffi_make_call_desc): Pass self name to
ffi_type_struct_checked, ffi_get_type and
ffi_call_desc_checked.
(ffi_make_closure): Pass self name to ffi_call_desc_checked.
(ffi_closure_get_fptr): Take self name, pass to
ffi_closure_struct_checked.
(ffi_typedef, ffi_size, ffi_alignof, ffi_offsetof,
ffi_arraysize, ffi_elemsize, ffi_elemtype, ffi_put_into,
ffi_put, ffi_in, ffi_get, ffi_out, make_carray): Pass self
name to ffi_closure_struct_checked.
(carray_struct_checked): Take self name, pass to cobj_handle.
(carray_set_length, carray_dup, carray_own, carray_free,
carray_type, length_carray, copy_carray, carray_ptr,
buf_carray, vec_carray, list_carray, carray_ref,
carray_refset, carray_sub, carray_replace, carray_get_common,
carray_put_common, unum_carray, num_carray, put_carray,
fill_carray): Pass self name to carray_struct_checked.
(carray_blank, carray_buf, carray_cptr): Pass self name
ffi_type_struct_checked.
(carray_pun): Pass self name to carray_struct_checked and
ffi_type_struct_checked.
(make_union): Pass self name to ffi_type_struct_checked.
(union_members, union_get, union_put, union_in, union_out):
Pass self name to uni_struct_checked.
(make_zstruct, zero_fill, put_obj, get_obj, fill_obj): Pass
self-name to ffi_type_struct_checked.

* ffi.h (ffi_closure_get_fptr, union_get_ptr): Declarations
updated.

* filter.c (trie_add): Pass self-name to gethash_l.

* hash.c (make_similar_hash, copy_hash, hash_count,
get_hash_userdata, set_hash_userdata, hash_begin, hash_next,
hash_uni, hash_diff, hash_isec): Pass self name
to cobj_handle.
(gethash_c, gethash_e): Take self name parameter and pass down
to cobj_handle.
(gethash_f): Take self parameter and pass down to gethash_e.
(gethash, inhash, gethash_n, sethash, pushhash, remhash,
clearhash, hash_update_1): Pass self name to gethash_e or gethash_c.

* hash.h (gethash_c, gethash_e, gethash_f): Declarations
updated.
(gethash_l): Take self name, and pass down to gethash_c.

* lib.c (class_check): Take self name parameter and use in
type mismatch diagnostic.
(use_sym, unuse_sym, symbol_needs_prefix, find_symbol,
intern, unintern, intern_fallback, unique, in, sel,
obj_print_impl, populate_obj_hash, obj_hash_merge): Pass self
name to gethash_f or gethash_l.
(symbol_visible, obj_init): Pass situation-identifying string
to gethash_e.
(cobj_handle, cobj_ops): Take self name parameter and pass
down to class_check.

* lib.h (class_check, cobj_handle, cobj_ops): Declarations
updated.

* match.c (v_load): Pass self name to read_compiled_file and
read_eval_stream.

* parser.c (get_parser_impl): Take self name and pass to
cobj_handle.
(ensure_parser): Pass situation-identifying string to
gethash_c.
(parser_circ_def): Pass self-name to gethash_c.
(lisp_parser_impl): Pass self name to get_parser_impl and
class_check.
(lisp_parse, nread, iread): Pass self-name to lisp_parser_impl.
(read_file_common): Take self name parameter and pass down to
get_parser_impl.
(read_eval_stream, read_compiled_file): Take self name and
pass down to read_file_common.
(load_rcfile): Pass situation-identifying string to
read_eval_streem.
(get_visible_syms): Pass situation-identifying string to
gethash_c.
(parser_errors, parser_eof): Pass self name to cobj_handle.

* parser.h (read_eval_stream, read_compiled_file):
Declarations updated.

* parser.y (rlset): Pass self name to gethash_c.

* rand.c (make_random_state, random_state_get_vec,l
random_fixnum, random_float): Pass self name to cobj_handle.

* regex.c (regex_source, regex_print, regex_run): Pass
self-name to cobj_handle.
(regex_machine_init): Take self name param and pass to
cobj_handle.
(search_regex, match_regex, match_regex_right,
regex_prefix_match, read_until_match): Pass self-name to
regex_machine_init.

* stream.c (stdio_get_fd): Pass self name to cobj_handle.
(generic_get_line): Get COBJ operations via unsafe, diret
object access rather than cobj_ops.
(set_mode_props): Get object handle via unsafe, direct object
access.
(stream_fd, sock_family, sock_type, sock_peer, set_sock_peer,
get_string_from_stream, get_list_from_stream, stream_set_prop,
stream_get_prop, close_stream, get_error, get_error_str,
clear_error, get_line, get_char, get_byte, unget_char,
unget_byte, put_buf, fill_buf, put_string, put_char, put_byte,
flush_stream, seek_stream, truncate_stream, get_indent_mode,
test_set_indent_mode, set_indent_mode, get_indent, set_indent,
inc_indent, width_check, force_break, get_set_ctx, get_ctx):
Pass self name to cobj_ops.
(make_delegate_stream): Take self name parameter, pass down to
cobj_ops.
(record_adapter): Pass self name down to make_delegate_stream.
(format): Pass self name to class_check.

* struct.c (stype_handle): Pass self name to cobj_handle.
(make_struct_type): Pass self name to class_check.

* txr.c (read_eval_stream_noerr): Take self name parameter,
pass to read_eval_stream.
(txr_main): Pass istuation-identifying string to
read_compiled_file and read_eval_stream_noerr.

* unwind.c (revive_cont): Pass self-name to cobj_handle.

* vm.c (vm_desc_struct): Take self name parameter, pass to
cobj_handle.
(vm_desc_nlevels, vm_desc_nregs, vm_desc_bytecode,
vm_desc_datavec, vm_desc_symvec, vm_execute_toplevel,
vm_execute_closure, vm_closure_entry): Pass self name to
vm_desc_struct.
(vm_closure_struct): Take self name parameter, pass to
cobj_handle.

1 files changed, 20 insertions, 14 deletions

diff --git a/eval.c b/eval.c
index c07ea8d4..32e26b53 100644
--- a/eval.c
+++ b/eval.c
@@ -152,13 +152,15 @@ static val make_env_intrinsic(val vbindings, val fbindings, val up_env)
 
 val env_fbind(val env, val sym, val fun)
 {
+  val self = lit("env-fbind");
+
   if (env) {
     val cell;
-    type_check(lit("env-fbind"), env, ENV);
+    type_check(self, env, ENV);
     cell = acons_new_c(sym, nulloc, mkloc(env->e.fbindings, env));
     return rplacd(cell, fun);
   } else {
-    val hcell = gethash_c(top_fb, sym, nulloc);
+    val hcell = gethash_c(self, top_fb, sym, nulloc);
     val cell = cdr(hcell);
     if (cell)
       return rplacd(cell, fun);
@@ -168,13 +170,15 @@ val env_fbind(val env, val sym, val fun)
 
 val env_vbind(val env, val sym, val obj)
 {
+  val self = lit("env-vbind");
+
   if (env) {
     val cell;
-    type_check(lit("env-vbind"), env, ENV);
+    type_check(self, env, ENV);
     cell = acons_new_c(sym, nulloc, mkloc(env->e.vbindings, env));
     return rplacd(cell, obj);
   } else {
-    val hcell = gethash_c(top_vb, sym, nulloc);
+    val hcell = gethash_c(self, top_vb, sym, nulloc);
     val cell = cdr(hcell);
     if (cell)
       return rplacd(cell, obj);
@@ -1851,8 +1855,9 @@ static val op_or(val form, val env)
 
 static val rt_defvarl(val sym)
 {
+  val self = lit("defvar");
   val new_p;
-  val cell = gethash_c(top_vb, sym, mkcloc(new_p));
+  val cell = gethash_c(self, top_vb, sym, mkcloc(new_p));
 
   if (new_p) {
     uw_purge_deferred_warning(cons(var_s, sym));
@@ -3973,7 +3978,7 @@ static val me_case(val form, val menv)
       list_collect_decl (indexed_clauses, rtail);
 
       for (i = minkey; i <= maxkey; i = succ(i)) {
-        val lookup = gethash_e(hash, i);
+        val lookup = gethash_e(casesym, hash, i);
         rtail = list_collect(rtail, if3(lookup,
                                         ref(hashforms, cdr(lookup)),
                                         uniqf));
@@ -4227,6 +4232,7 @@ static val me_load_time(val form, val menv)
 
 val load(val target)
 {
+  val self = lit("load");
   uses_or2;
   val parent = or2(load_path, null_string);
   val path = if3(!pure_rel_path_p(target),
@@ -4252,15 +4258,15 @@ val load(val target)
   env_vbind(dyn_env, package_s, cur_package);
 
   if (txr_lisp_p == t) {
-    if (!read_eval_stream(stream, std_error)) {
+    if (!read_eval_stream(self, stream, std_error)) {
       close_stream(stream, nil);
-      uw_throwf(error_s, lit("load: ~a contains errors"), path, nao);
+      uw_throwf(error_s, lit("~a: ~a contains errors"), self, path, nao);
     }
   } else if (txr_lisp_p == chr('o')) {
-    if (!read_compiled_file(stream, std_error)) {
+    if (!read_compiled_file(self, stream, std_error)) {
       close_stream(stream, nil);
-      uw_throwf(error_s, lit("load: unable to load compiled file ~a"),
-                path, nao);
+      uw_throwf(error_s, lit("~a: unable to load compiled file ~a"),
+                self, path, nao);
     }
   } else {
     int gc = gc_state(0);
@@ -4273,8 +4279,8 @@ val load(val target)
     uw_release_deferred_warnings();
 
     if (parser.errors)
-      uw_throwf(query_error_s, lit("load: parser errors in ~a"),
-                path, nao);
+      uw_throwf(query_error_s, lit("~a: parser errors in ~a"),
+                self, path, nao);
     {
       val match_ctx = uw_get_match_context();
       val bindings = cdr(match_ctx);
@@ -5775,7 +5781,7 @@ void reg_var(val sym, val val)
 
 static void reg_symacro(val sym, val form)
 {
-  val cell = gethash_c(top_smb, sym, nulloc);
+  val cell = gethash_c(lit("internal initialization"), top_smb, sym, nulloc);
   val binding = cdr(cell);
 
   if (binding)