cobj: clone method streamlines copy; structs get copy method.

* lib.h (struct cobj_ops): New function pointer, clone.
(cobj_ops_init, cobj_ops_init_ex): Add clone argument to macros.

* lib.c (seq_iter_cobj_ops): Use copy_iter as the clone operation.
(cptr_ops): Use copy_cptr as clone operation.
(copy): Replace if statements by check whether COBJ has a clone
operation. If so, we use it to copy the object.

* struct.h (enum special_slot): New member, copy_m.

* struct.c (copy_s): New symbol variable.
(special_sym): Associate copy_m enum value with copy symbol.
(struct_init): Initialize copy_s with interned symbol.
(struct_inst_clone): New static function.
(struct_type_ops): Specify no clone operation via null pointer.
(struct_inst_ops): Specify struct_inst_clone as clone
operation.

* arith.c (psq_ops): Indicate no clone operation via null pointer.

* buf.c (buf_strm_ops): Likewise.

* chksum.c (sha1_ops, sha256_ops, md5_ops): Likewise.

* ffi.c (ffi_type_builtin_ops, ffi_type_struct_ops,
ffi_type_ptr_ops, ffi_type_enum_ops, ffi_closure_ops,
union_ops): Likewise.
(carray_borrowed_ops, carry_owned_ops, carray_mmap_ops):
Specify copy_carray as clone operation.

* gc.c (prot_array_ops): Indicate no clone operation via
null pointer.

* gzip.c (gzio_ops_rd, gzip_ops_wr): Likewise.

* hash.c (hash_iter_ops): Likewise.
(hash_ops): Specify copy_hash as clone operation.

* parser.c (parser_ops): Indicate no clone operation via
null pointer.

* rand.c (random_state_clone): New static function.
(random_state_ops): Use random_state_clone as clone function.

* regex.c (char_set_obj_ops, regex_obj_ops): Indicate no clone
operation via null pointer.

* 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.

* strudel.c (strudel_ops): Likewise.

* sysif.c (cptr_dl_ops, opendir_ops): Likewise.

* syslog.c (syslog_strm_ops): Likewise.

* unwind.c (cont_ops): Likewise.

* vm.c (vm_desc_ops, vm_closure_ops): Likewise.

* tree.c (tree_ops): Use copy_search_tree for clone
operation.
(tree_iter_ops): Use copy_tree_iter for clone operation.

* genchksum.txr: Changes in chksum.c specified in one
place here.

* tests/012/oop.tl: Couple of new tests.

* txr.1: Documented.

1 files changed, 6 insertions, 14 deletions

diff --git a/lib.c b/lib.c
index 97b4cfd5..d967f5d8 100644
--- a/lib.c
+++ b/lib.c
@@ -1251,7 +1251,8 @@ struct cobj_ops seq_iter_cobj_ops = cobj_ops_init(eq,
                                                   cobj_print_op,
                                                   cobj_destroy_free_op,
                                                   seq_iter_mark,
-                                                  cobj_eq_hash_op);
+                                                  cobj_eq_hash_op,
+                                                  copy_iter);
 
 val seq_begin(val obj)
 {
@@ -10660,7 +10661,8 @@ static struct cobj_ops cptr_ops = cobj_ops_init(cobj_equal_handle_op,
                                                 cptr_print_op,
                                                 cobj_destroy_stub_op,
                                                 cobj_mark_op,
-                                                cobj_handle_hash_op);
+                                                cobj_handle_hash_op,
+                                                copy_cptr);
 
 val cptr_typed(mem_t *handle, val type_sym, struct cobj_ops *ops)
 {
@@ -13298,18 +13300,8 @@ val copy(val seq)
   case CPTR:
     return copy_cptr(seq);
   case COBJ:
-    if (seq->co.cls == hash_cls)
-      return copy_hash(seq);
-    if (seq->co.cls == random_state_cls)
-      return make_random_state(seq, nil);
-    if (seq->co.cls == carray_cls)
-      return copy_carray(seq);
-    if (seq->co.cls == tree_cls)
-      return copy_search_tree(seq);
-    if (seq->co.cls == tree_iter_cls)
-      return copy_tree_iter(seq);
-    if (obj_struct_p(seq))
-      return copy_struct(seq);
+    if (seq->co.ops->clone)
+      return seq->co.ops->clone(seq);
     /* fallthrough */
   default:
     type_mismatch(lit("copy: cannot copy object of type ~s"),