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, 20 insertions, 10 deletions

diff --git a/ffi.c b/ffi.c
index 1a95ea80..acea5db0 100644
--- a/ffi.c
+++ b/ffi.c
@@ -346,28 +346,32 @@ static struct cobj_ops ffi_type_builtin_ops =
                 ffi_type_print_op,
                 cobj_destroy_free_op,
                 ffi_type_mark,
-                cobj_eq_hash_op);
+                cobj_eq_hash_op,
+                0);
 
 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_eq_hash_op);
+                cobj_eq_hash_op,
+                0);
 
 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_eq_hash_op);
+                cobj_eq_hash_op,
+                0);
 
 static struct cobj_ops ffi_type_enum_ops =
   cobj_ops_init(eq,
                 ffi_type_print_op,
                 cobj_destroy_free_op,
                 ffi_enum_type_mark,
-                cobj_eq_hash_op);
+                cobj_eq_hash_op,
+                0);
 
 cnum ffi_type_size(struct txr_ffi_type *tft)
 {
@@ -440,7 +444,8 @@ static struct cobj_ops ffi_closure_ops =
                 ffi_closure_print_op,
                 ffi_closure_destroy_op,
                 ffi_closure_mark_op,
-                cobj_eq_hash_op);
+                cobj_eq_hash_op,
+                0);
 
 #endif
 
@@ -5412,7 +5417,8 @@ static struct cobj_ops ffi_call_desc_ops =
                 ffi_call_desc_print_op,
                 ffi_call_desc_destroy_op,
                 ffi_call_desc_mark_op,
-                cobj_eq_hash_op);
+                cobj_eq_hash_op,
+                0);
 
 val ffi_make_call_desc(val ntotal, val nfixed, val rettype, val argtypes,
                        val name_in)
@@ -5954,14 +5960,16 @@ static struct cobj_ops carray_borrowed_ops =
                 carray_print_op,
                 cobj_destroy_free_op,
                 carray_mark_op,
-                cobj_eq_hash_op);
+                cobj_eq_hash_op,
+                copy_carray);
 
 static struct cobj_ops carray_owned_ops =
   cobj_ops_init(eq,
                 carray_print_op,
                 carray_destroy_op,
                 carray_mark_op,
-                cobj_eq_hash_op);
+                cobj_eq_hash_op,
+                copy_carray);
 
 val make_carray(val type, mem_t *data, cnum nelem, val ref, cnum offs)
 {
@@ -6888,7 +6896,8 @@ static struct cobj_ops carray_mmap_ops =
                 carray_print_op,
                 carray_munmap_op,
                 carray_mark_op,
-                cobj_eq_hash_op);
+                cobj_eq_hash_op,
+                copy_carray);
 
 val mmap_wrap(val type, val len, val prot, val flags,
               val source_opt, val offset_opt, val addr_opt)
@@ -7091,7 +7100,8 @@ static struct cobj_ops union_ops =
                 cobj_print_op,
                 union_destroy_op,
                 union_mark_op,
-                cobj_eq_hash_op);
+                cobj_eq_hash_op,
+                0);
 
 static val make_union_common(mem_t *data, struct txr_ffi_type *tft)
 {