Many internal renames. Reverted to specify both _del and _clone parameter when giving _del.

8 files changed, 90 insertions, 94 deletions

diff --git a/stc/carray.h b/stc/carray.h
index 3f0983bc..39e1fba8 100644
--- a/stc/carray.h
+++ b/stc/carray.h
@@ -48,12 +48,9 @@ int main()
 

 #define using_carray(...) c_MACRO_OVERLOAD(using_carray, __VA_ARGS__)

 #define using_carray_2(X, Value) \

-    using_carray_4(X, Value, c_default_del, c_default_fromraw)

+    using_carray_4(X, Value, c_plain_del, c_plain_fromraw)

 

-#define using_carray_3(X, Value, valueDestroy) \

-    using_carray_4(X, Value, valueDestroy, c_no_fromraw)

-

-#define using_carray_4(X, Value, valueDestroy, valueClone) \

+#define using_carray_4(X, Value, valueDel, valueClone) \

 \

     typedef Value carray1##X##_value_t; \

     typedef carray1##X##_value_t carray2##X##_value_t, carray3##X##_value_t; \

@@ -86,9 +83,9 @@ int main()
     STC_INLINE size_t \

     carray3##X##_zdim(carray3##X a) {return _carray_zdim(a);} \

 \

-    _using_carray_common(1, X, Value, valueDestroy, valueClone) \

-    _using_carray_common(2, X, Value, valueDestroy, valueClone) \

-    _using_carray_common(3, X, Value, valueDestroy, valueClone) \

+    _using_carray_common(1, X, Value, valueDel, valueClone) \

+    _using_carray_common(2, X, Value, valueDel, valueClone) \

+    _using_carray_common(3, X, Value, valueDel, valueClone) \

 \

     STC_INLINE carray1##X \

     carray1##X##_init(size_t xdim, Value val) { \

@@ -166,7 +163,7 @@ int main()
 #define _carray_ydim(a) (a)._ydim

 #define _carray_zdim(a) (a)._zdim

 

-#define _using_carray_common(D, X, Value, valueDestroy, valueClone) \

+#define _using_carray_common(D, X, Value, valueDel, valueClone) \

     typedef struct { Value *ref; } carray##D##X##_iter_t; \

 \

     STC_INLINE carray##D##X##_iter_t \

@@ -184,7 +181,7 @@ int main()
     carray##D##X##_del(carray##D##X* self) { \

         if (self->_xdim & _carray_OWN) { \

             c_foreach_3 (i, carray##D##X, *self) \

-                valueDestroy(i.ref); \

+                valueDel(i.ref); \

             c_free(self->data); \

         } \

     } \

diff --git a/stc/ccommon.h b/stc/ccommon.h
index d3ceed52..590609fa 100644
--- a/stc/ccommon.h
+++ b/stc/ccommon.h
@@ -78,19 +78,18 @@
 #define c_swap(T, x, y)         do { T __t = x; x = y; y = __t; } while (0)

 #define c_arraylen(a)           (sizeof (a)/sizeof (a)[0])

 

-#define c_default_compare(x, y) c_less_compare(c_default_less, x, y)

+#define c_default_compare(x, y) (c_default_less(y, x) - c_default_less(x, y))

 #define c_default_less(x, y)    (*(x) < *(y))

-#define c_less_compare(less, x, y) (less(y, x) - less(x, y))

 #define c_no_compare(x, y)      (assert(!"c_no_compare() called"), 0)

 

 #define c_default_equals(x, y)  (*(x) == *(y))

-#define c_memcmp_equals(x, y)   (memcmp(x, y, sizeof *(x)) == 0)

+#define c_plain_equals(x, y)    (memcmp(x, y, sizeof *(x)) == 0)

 

-#define c_no_fromraw(x)         (assert(!"emplace*() with c_no_fromraw"), x)

-#define c_default_fromraw(x)    (x)

-#define c_default_toraw(ptr)    (*(ptr))

+#define c_plain_fromraw(x)      (x)

+#define c_no_clone(x)           (assert(!"emplace*() with c_no_clone"), x)

+#define c_plain_toraw(ptr)    (*(ptr))

 

-#define c_default_del(ptr)      ((void) (ptr))

+#define c_plain_del(ptr)      ((void) (ptr))

 

 /* Generic algorithms */

 

diff --git a/stc/cdeq.h b/stc/cdeq.h
index 0b5ed8d3..a5c743a5 100644
--- a/stc/cdeq.h
+++ b/stc/cdeq.h
@@ -31,9 +31,9 @@
 #define using_cdeq_2(X, Value) \

                     using_cdeq_3(X, Value, c_default_compare)

 #define using_cdeq_3(X, Value, valueCompare) \

-                    using_cdeq_7(X, Value, valueCompare, c_default_del, c_default_fromraw, c_default_toraw, Value)

-#define using_cdeq_4(X, Value, valueCompare, valueDestroy) \

-                    using_cdeq_7(X, Value, valueCompare, valueDestroy, c_no_fromraw, c_default_toraw, Value)

+                    using_cdeq_7(X, Value, valueCompare, c_plain_del, c_plain_fromraw, c_plain_toraw, Value)

+#define using_cdeq_5(X, Value, valueCompare, valueDel, valueFromRaw) \

+                    using_cdeq_7(X, Value, valueCompare, valueDel, valueFromRaw, c_plain_toraw, Value)

 #define using_cdeq_str() \

                     using_cdeq_7(str, cstr_t, cstr_compare_raw, cstr_del, cstr_from, cstr_c_str, const char*)

 

@@ -49,7 +49,7 @@ struct cdeq_rep { size_t size, cap; void* base[]; };
 #define cdeq_rep_(self) c_container_of((self)->base, struct cdeq_rep, base)

 typedef int (*c_cmp_fn)(const void*, const void*);

 

-#define using_cdeq_7(X, Value, valueCompareRaw, valueDestroy, valueFromRaw, valueToRaw, RawValue) \

+#define using_cdeq_7(X, Value, valueCompareRaw, valueDel, valueFromRaw, valueToRaw, RawValue) \

     typedefs_cdeq(X, Value, RawValue); \

 \

     STC_API cdeq_##X \

@@ -110,7 +110,7 @@ typedef int (*c_cmp_fn)(const void*, const void*);
     } \

     STC_INLINE void \

     cdeq_##X##_pop_back(cdeq_##X* self) { \

-        valueDestroy(&self->data[--cdeq_rep_(self)->size]); \

+        valueDel(&self->data[--cdeq_rep_(self)->size]); \

     } \

 \

     STC_API void \

@@ -121,7 +121,7 @@ typedef int (*c_cmp_fn)(const void*, const void*);
     } \

     STC_INLINE void \

     cdeq_##X##_pop_front(cdeq_##X* self) { \

-        valueDestroy(self->data++); \

+        valueDel(self->data++); \

         --cdeq_rep_(self)->size; \

     } \

 \

@@ -207,7 +207,7 @@ typedef int (*c_cmp_fn)(const void*, const void*);
     cdeq_##X##_sort(cdeq_##X* self) { \

         cdeq_##X##_sort_range(cdeq_##X##_begin(self), cdeq_##X##_end(self), cdeq_##X##_value_compare); \

     } \

-    _c_implement_cdeq_7(X, Value, valueCompareRaw, valueDestroy, valueFromRaw, valueToRaw, RawValue) \

+    _c_implement_cdeq_7(X, Value, valueCompareRaw, valueDel, valueFromRaw, valueToRaw, RawValue) \

     typedef cdeq_##X cdeq_##X##_t

 

 /* -------------------------- IMPLEMENTATION ------------------------- */

@@ -219,7 +219,7 @@ static struct cdeq_rep _cdeq_inits = {0, 0};
 static inline double _minf(double x, double y) {return x < y ? x : y;}

 static inline double _maxf(double x, double y) {return x > y ? x : y;}

 

-#define _c_implement_cdeq_7(X, Value, valueCompareRaw, valueDestroy, valueFromRaw, valueToRaw, RawValue) \

+#define _c_implement_cdeq_7(X, Value, valueCompareRaw, valueDel, valueFromRaw, valueToRaw, RawValue) \

 \

     STC_DEF cdeq_##X \

     cdeq_##X##_init(void) { \

@@ -240,7 +240,7 @@ static inline double _maxf(double x, double y) {return x > y ? x : y;}
     cdeq_##X##_clear(cdeq_##X* self) { \

         struct cdeq_rep* rep = cdeq_rep_(self); if (rep->cap) { \

             for (cdeq_##X##_value_t *p = self->data, *q = p + rep->size; p != q; ++p) \

-                valueDestroy(p); \

+                valueDel(p); \

             rep->size = 0; \

         } \

     } \

@@ -278,7 +278,7 @@ static inline double _maxf(double x, double y) {return x > y ? x : y;}
     cdeq_##X##_resize(cdeq_##X* self, size_t size, Value null_val) { \

         _cdeq_##X##_expand(self, size, false); \

         size_t i, n = cdeq_rep_(self)->size; \

-        for (i=size; i<n; ++i) valueDestroy(self->data + i); \

+        for (i=size; i<n; ++i) valueDel(self->data + i); \

         for (i=n; i<size; ++i) self->data[i] = null_val; \

         if (self->data) cdeq_rep_(self)->size = size; \

     } \

@@ -330,7 +330,7 @@ static inline double _maxf(double x, double y) {return x > y ? x : y;}
         intptr_t len = finish - first; \

         if (len > 0) { \

             cdeq_##X##_value_t* p = first, *end = self->data + cdeq_rep_(self)->size; \

-            while (p != finish) valueDestroy(p++); \

+            while (p != finish) valueDel(p++); \

             if (first == self->data) self->data += len; \

             else memmove(first, finish, (end - finish) * sizeof(Value)); \

             cdeq_rep_(self)->size -= len; \

@@ -354,7 +354,7 @@ static inline double _maxf(double x, double y) {return x > y ? x : y;}
     }

 

 #else

-#define _c_implement_cdeq_7(X, Value, valueCompareRaw, valueDestroy, valueFromRaw, valueToRaw, RawValue)

+#define _c_implement_cdeq_7(X, Value, valueCompareRaw, valueDel, valueFromRaw, valueToRaw, RawValue)

 #endif

 

 #endif

diff --git a/stc/clist.h b/stc/clist.h
index 9ee6fb1f..95dee6e7 100644
--- a/stc/clist.h
+++ b/stc/clist.h
@@ -59,9 +59,9 @@
 #define using_clist_2(X, Value) \

                     using_clist_3(X, Value, c_default_compare)

 #define using_clist_3(X, Value, valueCompare) \

-                    using_clist_7(X, Value, valueCompare, c_default_del, c_default_fromraw, c_default_toraw, Value)

-#define using_clist_4(X, Value, valueCompare, valueDestroy) \

-                    using_clist_7(X, Value, valueCompare, valueDestroy, c_no_fromraw, c_default_toraw, Value)

+                    using_clist_7(X, Value, valueCompare, c_plain_del, c_plain_fromraw, c_plain_toraw, Value)

+#define using_clist_5(X, Value, valueCompare, valueDel, valueFromRaw) \

+                    using_clist_7(X, Value, valueCompare, valueDel, valueFromRaw, c_plain_toraw, Value)

 #define using_clist_str() \

                     using_clist_7(str, cstr_t, cstr_compare_raw, cstr_del, cstr_from, cstr_c_str, const char*)

 

@@ -96,7 +96,7 @@ using_clist_types(void, int);
 STC_API size_t _clist_size(const clist_void* self);

 #define _clist_node(X, vp) c_container_of(vp, clist_##X##_node_t, value)

 

-#define using_clist_7(X, Value, valueCompareRaw, valueDestroy, valueFromRaw, valueToRaw, RawValue) \

+#define using_clist_7(X, Value, valueCompareRaw, valueDel, valueFromRaw, valueToRaw, RawValue) \

 \

     using_clist_types(X, Value); \

     typedef RawValue clist_##X##_rawvalue_t; \

@@ -209,13 +209,13 @@ STC_API size_t _clist_size(const clist_void* self);
     STC_INLINE Value* \

     clist_##X##_back(clist_##X* self) {return &self->last->value;} \

 \

-    _c_implement_clist_7(X, Value, valueCompareRaw, valueDestroy, valueFromRaw, valueToRaw, RawValue) \

+    _c_implement_clist_7(X, Value, valueCompareRaw, valueDel, valueFromRaw, valueToRaw, RawValue) \

     typedef clist_##X clist_##X##_t

 

 /* -------------------------- IMPLEMENTATION ------------------------- */

 

 #if !defined(STC_HEADER) || defined(STC_IMPLEMENTATION)

-#define _c_implement_clist_7(X, Value, valueCompareRaw, valueDestroy, valueFromRaw, valueToRaw, RawValue) \

+#define _c_implement_clist_7(X, Value, valueCompareRaw, valueDel, valueFromRaw, valueToRaw, RawValue) \

 \

     STC_DEF clist_##X \

     clist_##X##_clone(clist_##X list) { \

@@ -292,7 +292,7 @@ STC_API size_t _clist_size(const clist_void* self);
         node->next = next; \

         if (del == next) self->last = node = NULL; \

         else if (self->last == del) self->last = node, node = NULL; \

-        valueDestroy(&del->value); c_free(del); \

+        valueDel(&del->value); c_free(del); \

         return node; \

     } \

 \

@@ -418,7 +418,7 @@ _clist_mergesort(clist_void_node_t *list, int (*cmp)(const void*, const void*))
 }

 

 #else

-#define _c_implement_clist_7(X, Value, valueCompareRaw, valueDestroy, valueFromRaw, valueToRaw, RawValue)

+#define _c_implement_clist_7(X, Value, valueCompareRaw, valueDel, valueFromRaw, valueToRaw, RawValue)

 #endif

 

 #endif

diff --git a/stc/cmap.h b/stc/cmap.h
index 43fae80d..203f0263 100644
--- a/stc/cmap.h
+++ b/stc/cmap.h
@@ -65,17 +65,17 @@ typedef struct {size_t idx; uint32_t hx;} chash_bucket_t;
 

 #define using_cmap_5(X, Key, Mapped, keyEquals, keyHash) \

     using_cmap_9(X, Key, Mapped, keyEquals, keyHash, \

-                    c_default_del, c_default_fromraw, c_default_toraw, Mapped)

+                    c_plain_del, c_plain_fromraw, c_plain_toraw, Mapped)

 

-#define using_cmap_6(X, Key, Mapped, keyEquals, keyHash, mappedDel) \

+#define using_cmap_7(X, Key, Mapped, keyEquals, keyHash, mappedDel, mappedClone) \

     using_cmap_9(X, Key, Mapped, keyEquals, keyHash, \

-                    mappedDel, c_no_fromraw, c_default_toraw, Mapped)

+                    mappedDel, mappedClone, c_plain_toraw, Mapped)

 

-#define using_cmap_9(X, Key, Mapped, keyEqualsRaw, keyHashRaw, \

-                          mappedDel, mappedFromRaw, mappedToRaw, RawMapped) \

-    _using_CHASH(X, cmap, Key, Mapped, keyEqualsRaw, keyHashRaw, \

+#define using_cmap_9(X, Key, Mapped, keyEquals, keyHash, \

+                        mappedDel, mappedFromRaw, mappedToRaw, RawMapped) \

+    _using_CHASH(X, cmap, Key, Mapped, keyEquals, keyHash, \

                     mappedDel, mappedFromRaw, mappedToRaw, RawMapped, \

-                    c_default_del, c_default_fromraw, c_default_toraw, Key)

+                    c_plain_del, c_plain_fromraw, c_plain_toraw, Key)

 

 #define using_cmap_13(X, Key, Mapped, keyEqualsRaw, keyHashRaw, \

                          mappedDel, mappedFromRaw, mappedToRaw, RawMapped, \

@@ -85,13 +85,13 @@ typedef struct {size_t idx; uint32_t hx;} chash_bucket_t;
                     keyDel, keyFromRaw, keyToRaw, RawKey)

 

 #define using_cmap_keydef(...) c_MACRO_OVERLOAD(using_cmap_keydef, __VA_ARGS__)

-#define using_cmap_keydef_6(X, Key, Mapped, keyEquals, keyHash, keyDel) \

+#define using_cmap_keydef_7(X, Key, Mapped, keyEquals, keyHash, keyDel, keyClone) \

     using_cmap_keydef_9(X, Key, Mapped, keyEquals, keyHash, \

-                           keyDel, c_no_fromraw, c_default_toraw, Key)

+                           keyDel, keyClone, c_plain_toraw, Key)

 #define using_cmap_keydef_9(X, Key, Mapped, keyEqualsRaw, keyHashRaw, \

                                keyDel, keyFromRaw, keyToRaw, RawKey) \

     _using_CHASH(X, cmap, Key, Mapped, keyEqualsRaw, keyHashRaw, \

-                    c_default_del, c_default_fromraw, c_default_toraw, Mapped, \

+                    c_plain_del, c_plain_fromraw, c_plain_toraw, Mapped, \

                     keyDel, keyFromRaw, keyToRaw, RawKey)

 

 /* cset: */

@@ -102,10 +102,10 @@ typedef struct {size_t idx; uint32_t hx;} chash_bucket_t;
     using_cset_4(X, Key, c_default_equals, c_default_hash)

 

 #define using_cset_4(X, Key, keyEquals, keyHash) \

-    using_cset_8(X, Key, keyEquals, keyHash, c_default_del, c_default_fromraw, c_default_toraw, Key)

+    using_cset_8(X, Key, keyEquals, keyHash, c_plain_del, c_plain_fromraw, c_plain_toraw, Key)

 

-#define using_cset_5(X, Key, keyEquals, keyHash, keyDel) \

-    using_cset_8(X, Key, keyEquals, keyHash, keyDel, c_no_fromraw, c_default_toraw, Key)

+#define using_cset_6(X, Key, keyEquals, keyHash, keyDel, keyClone) \

+    using_cset_8(X, Key, keyEquals, keyHash, keyDel, keyClone, c_plain_toraw, Key)

 

 #define using_cset_8(X, Key, keyEqualsRaw, keyHashRaw, keyDel, keyFromRaw, keyToRaw, RawKey) \

     _using_CHASH(X, cset, Key, Key, keyEqualsRaw, keyHashRaw, \

@@ -124,10 +124,10 @@ typedef struct {size_t idx; uint32_t hx;} chash_bucket_t;
     c_MACRO_OVERLOAD(using_cmap_strkey, __VA_ARGS__)

 

 #define using_cmap_strkey_2(X, Mapped) \

-    _using_CHASH_strkey(X, cmap, Mapped, c_default_del, c_default_fromraw, c_default_toraw, Mapped)

+    _using_CHASH_strkey(X, cmap, Mapped, c_plain_del, c_plain_fromraw, c_plain_toraw, Mapped)

 

-#define using_cmap_strkey_3(X, Mapped, mappedDel) \

-    _using_CHASH_strkey(X, cmap, Mapped, mappedDel, c_no_fromraw, c_default_toraw, Mapped)

+#define using_cmap_strkey_4(X, Mapped, mappedDel, mappedClone) \

+    _using_CHASH_strkey(X, cmap, Mapped, mappedDel, mappedClone, c_plain_toraw, Mapped)

 

 #define using_cmap_strkey_6(X, Mapped, mappedDel, mappedFromRaw, mappedToRaw, RawMapped) \

     _using_CHASH_strkey(X, cmap, Mapped, mappedDel, mappedFromRaw, mappedToRaw, RawMapped)

@@ -144,13 +144,13 @@ typedef struct {size_t idx; uint32_t hx;} chash_bucket_t;
     using_cmap_strval_4(X, Key, c_default_equals, c_default_hash)

 

 #define using_cmap_strval_4(X, Key, keyEquals, keyHash) \

-    using_cmap_strval_8(X, Key, keyEquals, keyHash, c_default_del, c_default_fromraw, c_default_toraw, Key)

+    using_cmap_strval_8(X, Key, keyEquals, keyHash, c_plain_del, c_plain_fromraw, c_plain_toraw, Key)

 

-#define using_cmap_strval_5(X, Key, keyEquals, keyHash, keyDel) \

-    using_cmap_strval_8(X, Key, keyEquals, keyHash, keyDel, c_no_fromraw, c_default_toraw, Key)

+#define using_cmap_strval_6(X, Key, keyEquals, keyHash, keyDel, keyClone) \

+    using_cmap_strval_8(X, Key, keyEquals, keyHash, keyDel, keyClone, c_plain_toraw, Key)

 

-#define using_cmap_strval_8(X, Key, keyEquals, keyHash, keyDel, keyFromRaw, keyToRaw, RawKey) \

-    _using_CHASH(X, cmap, Key, cstr_t, keyEquals, keyHash, \

+#define using_cmap_strval_8(X, Key, keyEqualsRaw, keyHashRaw, keyDel, keyFromRaw, keyToRaw, RawKey) \

+    _using_CHASH(X, cmap, Key, cstr_t, keyEqualsRaw, keyHashRaw, \

                     cstr_del, cstr_from, cstr_c_str, const char*, \

                     keyDel, keyFromRaw, keyToRaw, RawKey)

 

diff --git a/stc/cptr.h b/stc/cptr.h
index 61b56123..2614238d 100644
--- a/stc/cptr.h
+++ b/stc/cptr.h
@@ -45,7 +45,7 @@ int Person_compare(const Person* p, const Person* q) {
 }

 

 using_cptr(pe, Person, Person_compare, Person_del);

-using_cvec(pe, Person*, cptr_pe_compare, cptr_pe_del);

+using_cvec(pe, Person*, cptr_pe_compare, cptr_pe_del, c_no_clone);

 

 int main() {

     cvec_pe vec = cvec_pe_init();

@@ -65,15 +65,15 @@ int main() {
     using_cptr_3(X, Value, c_default_compare)

 

 #define using_cptr_3(X, Value, valueCompare) \

-    using_cptr_4(X, Value, valueCompare, c_default_del)

+    using_cptr_4(X, Value, valueCompare, c_plain_del)

 

-#define using_cptr_4(X, Value, valueCompare, valueDestroy) \

+#define using_cptr_4(X, Value, valueCompare, valueDel) \

     typedef Value cptr_##X##_value_t; \

     typedef cptr_##X##_value_t *cptr_##X; \

 \

     STC_INLINE void \

     cptr_##X##_del(cptr_##X* self) { \

-        valueDestroy(*self); \

+        valueDel(*self); \

         c_free(*self); \

     } \

 \

@@ -158,9 +158,9 @@ typedef long atomic_count_t;
     using_csptr_3(X, Value, c_default_compare)

 

 #define using_csptr_3(X, Value, valueCompare) \

-    using_csptr_4(X, Value, valueCompare, c_default_del)

+    using_csptr_4(X, Value, valueCompare, c_plain_del)

 

-#define using_csptr_4(X, Value, valueCompare, valueDestroy) \

+#define using_csptr_4(X, Value, valueCompare, valueDel) \

     typedef Value csptr_##X##_value_t; \

     typedef struct { csptr_##X##_value_t* get; atomic_count_t* use_count; } csptr_##X; \

 \

@@ -185,7 +185,7 @@ typedef long atomic_count_t;
     csptr_##X##_del(csptr_##X* self) { \

         if (self->use_count && atomic_decrement(self->use_count) == 0) { \

             c_free(self->use_count); \

-            valueDestroy(self->get); \

+            valueDel(self->get); \

             c_free(self->get); \

         } \

     } \

diff --git a/stc/csmap.h b/stc/csmap.h
index 0f9fcec2..7b6b04bd 100644
--- a/stc/csmap.h
+++ b/stc/csmap.h
@@ -49,15 +49,15 @@ int main(void) {
     using_csmap_4(X, Key, Mapped, c_default_compare)

 

 #define using_csmap_4(X, Key, Mapped, keyCompare) \

-    using_csmap_8(X, Key, Mapped, keyCompare, c_default_del, c_default_fromraw, c_default_toraw, Mapped)

+    using_csmap_8(X, Key, Mapped, keyCompare, c_plain_del, c_plain_fromraw, c_plain_toraw, Mapped)

 

-#define using_csmap_5(X, Key, Mapped, keyCompare, mappedDel) \

-    using_csmap_8(X, Key, Mapped, keyCompare, mappedDel, c_no_fromraw, c_default_toraw, Mapped)

+#define using_csmap_6(X, Key, Mapped, keyCompare, mappedDel, mappedClone) \

+    using_csmap_8(X, Key, Mapped, keyCompare, mappedDel, mappedClone, c_plain_toraw, Mapped)

 

 #define using_csmap_8(X, Key, Mapped, keyCompare, mappedDel, mappedFromRaw, mappedToRaw, RawMapped) \

     using_csmap_12(X, Key, Mapped, keyCompare, \

                       mappedDel, mappedFromRaw, mappedToRaw, RawMapped, \

-                      c_default_del, c_default_fromraw, c_default_toraw, Key)

+                      c_plain_del, c_plain_fromraw, c_plain_toraw, Key)

 

 #define using_csmap_12(X, Key, Mapped, keyCompareRaw, \

                           mappedDel, mappedFromRaw, mappedToRaw, RawMapped, \

@@ -67,13 +67,13 @@ int main(void) {
                      keyDel, keyFromRaw, keyToRaw, RawKey)

 

 #define using_csmap_keydef(...) c_MACRO_OVERLOAD(using_csmap_keydef, __VA_ARGS__)

-#define using_csmap_keydef_5(X, Key, Mapped, keyCompare, keyDel) \

+#define using_csmap_keydef_6(X, Key, Mapped, keyCompare, keyDel, keyClone) \

     using_csmap_keydef_8(X, Key, Mapped, keyCompare, \

-                            keyDel, c_no_fromraw, c_default_toraw, Key)

+                            keyDel, keyClone, c_plain_toraw, Key)

 #define using_csmap_keydef_8(X, Key, Mapped, keyCompareRaw, \

                                 keyDel, keyFromRaw, keyToRaw, RawKey) \

     _using_AATREE(X, csmap, Key, Mapped, keyCompareRaw, \

-                     c_default_del, c_default_fromraw, c_default_toraw, Mapped, \

+                     c_plain_del, c_plain_fromraw, c_plain_toraw, Mapped, \

                      keyDel, keyFromRaw, keyToRaw, RawKey)

 

 /* csset: */

@@ -84,10 +84,10 @@ int main(void) {
     using_csset_3(X, Key, c_default_compare)

 

 #define using_csset_3(X, Key, keyCompare) \

-    using_csset_7(X, Key, keyCompare, c_default_del, c_default_fromraw, c_default_toraw, Key)

+    using_csset_7(X, Key, keyCompare, c_plain_del, c_plain_fromraw, c_plain_toraw, Key)

 

-#define using_csset_4(X, Key, keyCompare, keyDel) \

-    using_csset_7(X, Key, keyCompare, keyDel, c_no_fromraw, c_default_toraw, Key)

+#define using_csset_5(X, Key, keyCompare, keyDel, keyClone) \

+    using_csset_7(X, Key, keyCompare, keyDel, keyClone, c_plain_toraw, Key)

 

 #define using_csset_7(X, Key, keyCompareRaw, keyDel, keyFromRaw, keyToRaw, RawKey) \

     _using_AATREE(X, csset, Key, Key, keyCompareRaw, \

@@ -106,10 +106,10 @@ int main(void) {
     c_MACRO_OVERLOAD(using_csmap_strkey, __VA_ARGS__)

 

 #define using_csmap_strkey_2(X, Mapped) \

-    _using_AATREE_strkey(X, csmap, Mapped, c_default_del, c_default_fromraw, c_default_toraw, Mapped)

+    _using_AATREE_strkey(X, csmap, Mapped, c_plain_del, c_plain_fromraw, c_plain_toraw, Mapped)

 

-#define using_csmap_strkey_3(X, Mapped, mappedDel) \

-    _using_AATREE_strkey(X, csmap, Mapped, mappedDel, c_no_fromraw, c_default_toraw, Mapped)

+#define using_csmap_strkey_4(X, Mapped, mappedDel, mappedClone) \

+    _using_AATREE_strkey(X, csmap, Mapped, mappedDel, mappedClone, c_plain_toraw, Mapped)

 

 #define using_csmap_strkey_6(X, Mapped, mappedDel, mappedFromRaw, mappedToRaw, RawMapped) \

     _using_AATREE_strkey(X, csmap, Mapped, mappedDel, mappedFromRaw, mappedToRaw, RawMapped)

@@ -126,13 +126,13 @@ int main(void) {
     using_csmap_strval_3(X, Key, c_default_compare)

 

 #define using_csmap_strval_3(X, Key, keyCompare) \

-    using_csmap_strval_7(X, Key, keyCompare, c_default_del, c_default_fromraw, c_default_toraw, Key)

+    using_csmap_strval_7(X, Key, keyCompare, c_plain_del, c_plain_fromraw, c_plain_toraw, Key)

 

-#define using_csmap_strval_4(X, Key, keyCompare, keyDel) \

-    using_csmap_strval_7(X, Key, keyCompare, keyDel, c_no_fromraw, c_default_toraw, Key)

+#define using_csmap_strval_5(X, Key, keyCompare, keyDel, keyClone) \

+    using_csmap_strval_7(X, Key, keyCompare, keyDel, keyClone, c_plain_toraw, Key)

 

-#define using_csmap_strval_7(X, Key, keyCompare, keyDel, keyFromRaw, keyToRaw, RawKey) \

-    _using_AATREE(X, csmap, Key, cstr_t, keyCompare, \

+#define using_csmap_strval_7(X, Key, keyCompareRaw, keyDel, keyFromRaw, keyToRaw, RawKey) \

+    _using_AATREE(X, csmap, Key, cstr_t, keyCompareRaw, \

                      cstr_del, cstr_from, cstr_c_str, const char*, \

                      keyDel, keyFromRaw, keyToRaw, RawKey)

 

diff --git a/stc/cvec.h b/stc/cvec.h
index 14e353be..1fa54d30 100644
--- a/stc/cvec.h
+++ b/stc/cvec.h
@@ -31,9 +31,9 @@
 #define using_cvec_2(X, Value) \

                     using_cvec_3(X, Value, c_default_compare)

 #define using_cvec_3(X, Value, valueCompare) \

-                    using_cvec_7(X, Value, valueCompare, c_default_del, c_default_fromraw, c_default_toraw, Value)

-#define using_cvec_4(X, Value, valueCompare, valueDestroy) \

-                    using_cvec_7(X, Value, valueCompare, valueDestroy, c_no_fromraw, c_default_toraw, Value)

+                    using_cvec_7(X, Value, valueCompare, c_plain_del, c_plain_fromraw, c_plain_toraw, Value)

+#define using_cvec_5(X, Value, valueCompare, valueDel, valueFromRaw) \

+                    using_cvec_7(X, Value, valueCompare, valueDel, valueFromRaw, c_plain_toraw, Value)

 #define using_cvec_str() \

                     using_cvec_7(str, cstr_t, cstr_compare_raw, cstr_del, cstr_from, cstr_c_str, const char*)

 

@@ -49,7 +49,7 @@ struct cvec_rep { size_t size, cap; void* data[]; };
 #define cvec_rep_(self) c_container_of((self)->data, struct cvec_rep, data)

 typedef int (*c_cmp_fn)(const void*, const void*);

 

-#define using_cvec_7(X, Value, valueCompareRaw, valueDestroy, valueFromRaw, valueToRaw, RawValue) \

+#define using_cvec_7(X, Value, valueCompareRaw, valueDel, valueFromRaw, valueToRaw, RawValue) \

     typedefs_cvec(X, Value, RawValue); \

 \

     STC_API cvec_##X \

@@ -105,7 +105,7 @@ typedef int (*c_cmp_fn)(const void*, const void*);
     } \

     STC_INLINE void \

     cvec_##X##_pop_back(cvec_##X* self) { \

-        valueDestroy(&self->data[--cvec_rep_(self)->size]); \

+        valueDel(&self->data[--cvec_rep_(self)->size]); \

     } \

 \

     STC_API cvec_##X##_iter_t \

@@ -197,7 +197,7 @@ typedef int (*c_cmp_fn)(const void*, const void*);
         cvec_##X##_sort_range(cvec_##X##_begin(self), cvec_##X##_end(self), cvec_##X##_value_compare); \

     } \

 \

-    _c_implement_cvec_7(X, Value, valueCompareRaw, valueDestroy, valueFromRaw, valueToRaw, RawValue) \

+    _c_implement_cvec_7(X, Value, valueCompareRaw, valueDel, valueFromRaw, valueToRaw, RawValue) \

     typedef cvec_##X cvec_##X##_t

 

 /* -------------------------- IMPLEMENTATION ------------------------- */

@@ -205,7 +205,7 @@ typedef int (*c_cmp_fn)(const void*, const void*);
 #if !defined(STC_HEADER) || defined(STC_IMPLEMENTATION)

 static struct cvec_rep _cvec_inits = {0, 0};

 

-#define _c_implement_cvec_7(X, Value, valueCompareRaw, valueDestroy, valueFromRaw, valueToRaw, RawValue) \

+#define _c_implement_cvec_7(X, Value, valueCompareRaw, valueDel, valueFromRaw, valueToRaw, RawValue) \

 \

     STC_DEF cvec_##X \

     cvec_##X##_init(void) { \

@@ -225,7 +225,7 @@ static struct cvec_rep _cvec_inits = {0, 0};
     cvec_##X##_clear(cvec_##X* self) { \

         struct cvec_rep* rep = cvec_rep_(self); if (rep->cap) { \

             for (cvec_##X##_value_t *p = self->data, *q = p + rep->size; p != q; ++p) \

-                valueDestroy(p); \

+                valueDel(p); \

             rep->size = 0; \

         } \

     } \

@@ -253,7 +253,7 @@ static struct cvec_rep _cvec_inits = {0, 0};
         cvec_##X##_reserve(self, len); \

         struct cvec_rep* rep = cvec_rep_(self); \

         size_t i, n = rep->size; \

-        for (i = len; i < n; ++i) valueDestroy(self->data + i); \

+        for (i = len; i < n; ++i) valueDel(self->data + i); \

         for (i = n; i < len; ++i) self->data[i] = null_val; \

         if (rep->cap) rep->size = len; \

     } \

@@ -294,7 +294,7 @@ static struct cvec_rep _cvec_inits = {0, 0};
         intptr_t len = finish - first; \

         if (len > 0) { \

             cvec_##X##_value_t* p = first, *end = self->data + cvec_rep_(self)->size; \

-            while (p != finish) valueDestroy(p++); \

+            while (p != finish) valueDel(p++); \

             memmove(first, finish, (end - finish) * sizeof(Value)); \

             cvec_rep_(self)->size -= len; \

         } \

@@ -332,7 +332,7 @@ static struct cvec_rep _cvec_inits = {0, 0};
     }

 

 #else

-#define _c_implement_cvec_7(X, Value, valueCompareRaw, valueDestroy, valueFromRaw, valueToRaw, RawValue)

+#define _c_implement_cvec_7(X, Value, valueCompareRaw, valueDel, valueFromRaw, valueToRaw, RawValue)

 #endif

 

 #endif