cobj: rename poorly named default operation.

Renaming cobj_hash_op to cobj_eq_hash_op. This function is
only appropriate to use with COBJ objects which use
eq as their equal funtion. I've spotted one instance of an
inappropriate use which have to be addressed by a different
commit: the equal function is other than eq, but cobj_hash_op
is used for the equal hash.

* lib.h (cobj_hash_op): Declaration renamed to
cobj_eq_hash_op.

* hash.c (cobj_hash_op): Renamed to cobj_eq_hash_op.
(hash_iter_ops): Refer to renamed cobj_hash_eq_op.

* ffi.c (ffi_type_builtin_ops, ffi_type_struct_ops,
ffi_type_ptr_ops, ffi-closure_ops, ffi_call_desc_ops):
Likewise.

* lib.c (cptr_ops): Likewise.

* parser.c (parser_ops): Likewise.

* rand.c (random_state_ops): Likewise.

* regex.c (char_set_ops, regex_obj_ops): Likewise.

* socket.c (dgram_strm_ops): Likewise.

* stream.c (null_ops, stdio_ops, tail_ops, pipe_ops, dir_ops,
string_in_ops, byte_in_ops, strlist_in_ops, string_out_ops,
strlist_out_ops, cat_stream_ops, record_adapter_ops):
Likewise.

* struct.c (struct_type_ops): Likewise.

* sysif.c (cptr_dl_ops): Likewise.

* syslog.c (syslog_strm_ops): Likewise.

* unwind.c (cont_ops): Likewise.

13 files changed, 30 insertions, 30 deletions

diff --git a/ffi.c b/ffi.c
index 71f095df..e72b3d1f 100644
--- a/ffi.c
+++ b/ffi.c
@@ -165,21 +165,21 @@ static struct cobj_ops ffi_type_builtin_ops =
                 ffi_type_print_op,
                 cobj_destroy_free_op,
                 cobj_mark_op,
-                cobj_hash_op);
+                cobj_eq_hash_op);
 
 static struct cobj_ops ffi_type_struct_ops =
   cobj_ops_init(eq,
                 ffi_type_print_op,
                 ffi_type_struct_destroy_op,
                 ffi_struct_type_mark,
-                cobj_hash_op);
+                cobj_eq_hash_op);
 
 static struct cobj_ops ffi_type_ptr_ops =
   cobj_ops_init(eq,
                 ffi_type_print_op,
                 cobj_destroy_free_op,
                 ffi_ptr_type_mark,
-                cobj_hash_op);
+                cobj_eq_hash_op);
 
 struct txr_ffi_closure {
   ffi_closure *clo;
@@ -234,7 +234,7 @@ static struct cobj_ops ffi_closure_ops =
                 ffi_closure_print_op,
                 ffi_closure_destroy_op,
                 ffi_closure_mark_op,
-                cobj_hash_op);
+                cobj_eq_hash_op);
 
 static void ffi_void_put(struct txr_ffi_type *tft, val n, mem_t *dst, val self)
 {
@@ -1881,7 +1881,7 @@ static struct cobj_ops ffi_call_desc_ops =
                 ffi_call_desc_print_op,
                 ffi_call_desc_destroy_op,
                 ffi_call_desc_mark_op,
-                cobj_hash_op);
+                cobj_eq_hash_op);
 
 val ffi_make_call_desc(val ntotal, val nfixed, val rettype, val argtypes)
 {
diff --git a/hash.c b/hash.c
index 8d27892f..2b838ae6 100644
--- a/hash.c
+++ b/hash.c
@@ -274,7 +274,7 @@ static cnum eql_hash(val obj, int *count)
   abort();
 }
 
-cnum cobj_hash_op(val obj, int *count)
+cnum cobj_eq_hash_op(val obj, int *count)
 {
   (void) count;
 
@@ -843,7 +843,7 @@ static struct cobj_ops hash_iter_ops = cobj_ops_init(eq,
                                                      cobj_print_op,
                                                      cobj_destroy_free_op,
                                                      hash_iter_mark,
-                                                     cobj_hash_op);
+                                                     cobj_eq_hash_op);
 
 val hash_begin(val hash)
 {
diff --git a/lib.c b/lib.c
index 829a9b99..03915d08 100644
--- a/lib.c
+++ b/lib.c
@@ -7394,7 +7394,7 @@ static struct cobj_ops cptr_ops = {
   cobj_print_op,
   cobj_destroy_stub_op,
   cobj_mark_op,
-  cobj_hash_op
+  cobj_eq_hash_op
 };
 
 val cptr(mem_t *ptr)
diff --git a/lib.h b/lib.h
index b5593475..f1274bf1 100644
--- a/lib.h
+++ b/lib.h
@@ -257,7 +257,7 @@ val cobj_equal_handle_op(val left, val right);
 void cobj_destroy_stub_op(val);
 void cobj_destroy_free_op(val);
 void cobj_mark_op(val);
-cnum cobj_hash_op(val, int *);
+cnum cobj_eq_hash_op(val, int *);
 
 struct env {
   obj_common;
diff --git a/parser.c b/parser.c
index 0cd962bb..5c22ac3a 100644
--- a/parser.c
+++ b/parser.c
@@ -100,7 +100,7 @@ static struct cobj_ops parser_ops = {
   cobj_print_op,
   parser_destroy,
   parser_mark,
-  cobj_hash_op,
+  cobj_eq_hash_op,
 };
 
 void parser_common_init(parser_t *p)
diff --git a/rand.c b/rand.c
index 1dec0a9e..bf57ca3c 100644
--- a/rand.c
+++ b/rand.c
@@ -65,7 +65,7 @@ static struct cobj_ops random_state_ops = cobj_ops_init(eq,
                                                         cobj_print_op,
                                                         cobj_destroy_free_op,
                                                         cobj_mark_op,
-                                                        cobj_hash_op);
+                                                        cobj_eq_hash_op);
 
 /* Source: bits from /dev/random on a Linux server */
 static rand32_t rand_tab[16] = {
diff --git a/regex.c b/regex.c
index 9568d312..705ac26d 100644
--- a/regex.c
+++ b/regex.c
@@ -804,7 +804,7 @@ static struct cobj_ops char_set_obj_ops = cobj_ops_init(eq,
                                                         cobj_print_op,
                                                         char_set_cobj_destroy,
                                                         cobj_mark_op,
-                                                        cobj_hash_op);
+                                                        cobj_eq_hash_op);
 
 static nfa_state_t *nfa_state_accept(void)
 {
@@ -1379,7 +1379,7 @@ static struct cobj_ops regex_obj_ops = cobj_ops_init(eq,
                                                      regex_print,
                                                      regex_destroy,
                                                      regex_mark,
-                                                     cobj_hash_op);
+                                                     cobj_eq_hash_op);
 
 static val reg_nullable(val);
 
diff --git a/socket.c b/socket.c
index aca7240c..51db01a9 100644
--- a/socket.c
+++ b/socket.c
@@ -648,7 +648,7 @@ static_def(struct strm_ops dgram_strm_ops =
                               dgram_print,
                               dgram_destroy,
                               dgram_mark,
-                              cobj_hash_op),
+                              cobj_eq_hash_op),
                 wli("dgram-sock"),
                 dgram_put_string,
                 dgram_put_char,
diff --git a/stream.c b/stream.c
index 398feaf6..9016555e 100644
--- a/stream.c
+++ b/stream.c
@@ -340,7 +340,7 @@ static struct strm_ops null_ops =
                               stream_print_op,
                               stream_destroy_op,
                               stream_mark_op,
-                              cobj_hash_op),
+                              cobj_eq_hash_op),
                 wli("null-stream"),
                 null_put_string, null_put_char, null_put_byte, null_get_line,
                 null_get_char, null_get_byte,
@@ -910,7 +910,7 @@ static struct strm_ops stdio_ops =
                               stdio_stream_print,
                               stdio_stream_destroy,
                               stdio_stream_mark,
-                              cobj_hash_op),
+                              cobj_eq_hash_op),
                 wli("file-stream"),
                 stdio_put_string,
                 stdio_put_char,
@@ -1099,7 +1099,7 @@ static struct strm_ops tail_ops =
                               stdio_stream_print,
                               stdio_stream_destroy,
                               stdio_stream_mark,
-                              cobj_hash_op),
+                              cobj_eq_hash_op),
                 wli("tail-stream"),
                 stdio_put_string,
                 stdio_put_char,
@@ -1194,7 +1194,7 @@ static struct strm_ops pipe_ops =
                               stdio_stream_print,
                               stdio_stream_destroy,
                               stdio_stream_mark,
-                              cobj_hash_op),
+                              cobj_eq_hash_op),
                 wli("pipe-stream"),
                 stdio_put_string,
                 stdio_put_char,
@@ -1550,7 +1550,7 @@ static struct strm_ops dir_ops =
                               stream_print_op,
                               dir_destroy,
                               dir_mark,
-                              cobj_hash_op),
+                              cobj_eq_hash_op),
                 wli("dir-stream"),
                 0, 0, 0,
                 dir_get_line,
@@ -1669,7 +1669,7 @@ static struct strm_ops string_in_ops =
                               stream_print_op,
                               stream_destroy_op,
                               string_in_stream_mark,
-                              cobj_hash_op),
+                              cobj_eq_hash_op),
                 wli("string-input-stream"),
                 0, 0, 0,
                 string_in_get_line,
@@ -1748,7 +1748,7 @@ static struct strm_ops byte_in_ops =
                               stream_print_op,
                               byte_in_stream_destroy,
                               stream_mark_op,
-                              cobj_hash_op),
+                              cobj_eq_hash_op),
                 wli("byte-input-stream"),
                 0, 0, 0, 0, 0,
                 byte_in_get_byte,
@@ -1882,7 +1882,7 @@ static struct strm_ops strlist_in_ops =
                               stream_print_op,
                               stream_destroy_op,
                               strlist_in_stream_mark,
-                              cobj_hash_op),
+                              cobj_eq_hash_op),
                 wli("strlist-input-stream"),
                 0, 0, 0,
                 strlist_in_get_line,
@@ -2023,7 +2023,7 @@ static struct strm_ops string_out_ops =
                               stream_print_op,
                               string_out_stream_destroy,
                               stream_mark_op,
-                              cobj_hash_op),
+                              cobj_eq_hash_op),
                 wli("string-output-stream"),
                 string_out_put_string,
                 string_out_put_char,
@@ -2144,7 +2144,7 @@ static struct strm_ops strlist_out_ops =
                               stream_print_op,
                               stream_destroy_op,
                               strlist_out_mark,
-                              cobj_hash_op),
+                              cobj_eq_hash_op),
                 wli("strlist-output-stream"),
                 strlist_out_put_string,
                 strlist_out_put_char,
@@ -2324,7 +2324,7 @@ static struct strm_ops cat_stream_ops =
                               cat_stream_print,
                               stream_destroy_op,
                               cat_mark,
-                              cobj_hash_op),
+                              cobj_eq_hash_op),
                 wli("catenated-stream"),
                 0, 0, 0,
                 cat_get_line,
@@ -2568,7 +2568,7 @@ static struct strm_ops record_adapter_ops =
                               stream_print_op,
                               stream_destroy_op,
                               record_adapter_mark_op,
-                              cobj_hash_op),
+                              cobj_eq_hash_op),
                 wli("record-adapter"),
                 delegate_put_string, delegate_put_char, delegate_put_byte,
                 record_adapter_get_line, delegate_get_char, delegate_get_byte,
diff --git a/struct.c b/struct.c
index 46b1bcab..3b16da7c 100644
--- a/struct.c
+++ b/struct.c
@@ -1596,7 +1596,7 @@ val static_slot_type_reg(val slot, val strct)
 
 static_def(struct cobj_ops struct_type_ops =
            cobj_ops_init(eq, struct_type_print, struct_type_destroy,
-                         struct_type_mark, cobj_hash_op))
+                         struct_type_mark, cobj_eq_hash_op))
 
 static_def(struct cobj_ops struct_inst_ops =
            cobj_ops_init_ex(struct_inst_equal, struct_inst_print,
diff --git a/sysif.c b/sysif.c
index 4eb5c1b7..e4d6de88 100644
--- a/sysif.c
+++ b/sysif.c
@@ -1470,7 +1470,7 @@ static struct cobj_ops cptr_dl_ops = {
   cobj_print_op,
   cptr_dl_destroy_op,
   cobj_mark_op,
-  cobj_hash_op
+  cobj_eq_hash_op
 };
 
 static val dlopen_wrap(val name, val flags)
diff --git a/syslog.c b/syslog.c
index f3933a25..1123bbeb 100644
--- a/syslog.c
+++ b/syslog.c
@@ -223,7 +223,7 @@ static_def(struct strm_ops syslog_strm_ops =
                               stream_print_op,
                               cobj_destroy_free_op,
                               syslog_mark,
-                              cobj_hash_op),
+                              cobj_eq_hash_op),
                 wli("syslog-stream"),
                 syslog_put_string,
                 syslog_put_char,
diff --git a/unwind.c b/unwind.c
index 4d96b875..94763e7e 100644
--- a/unwind.c
+++ b/unwind.c
@@ -848,7 +848,7 @@ static struct cobj_ops cont_ops = cobj_ops_init(eq,
                                                 cobj_print_op,
                                                 cont_destroy,
                                                 cont_mark,
-                                                cobj_hash_op);
+                                                cobj_eq_hash_op);
 
 static void call_copy_handlers(uw_frame_t *upto, int parent)
 {