- Backported csmap_v1.h (with malloced nodes) to match csmap.

- Updated csmap/cmap to separate out types in order to later have incomplete values support.
- Added incomplete value support to csptr. I question the need because recursive structures should not use shared_ptr.
- Added c_forinitdel() macro, support up to 3 variables.

6 files changed, 177 insertions, 124 deletions

diff --git a/benchmarks/others/csmap_v1.h b/benchmarks/others/csmap_v1.h
index 061b1dfe..9b02497e 100644
--- a/benchmarks/others/csmap_v1.h
+++ b/benchmarks/others/csmap_v1.h
@@ -27,16 +27,23 @@
 /*

 #include <stdio.h>

 #include <stc/csmap.h>

-using_csset(i, int);        // Set of int

-using_csmap(ic, int, char); // Map of int -> char

+using_csmap(mx, int, char); // Sorted map<int, char>

 

 int main(void) {

-    csset_sx s = csset_sx_init();

-    csset_sx_insert(&s, 5);

-    csset_sx_insert(&s, 8);

-    c_foreach (i, csset_sx, s)

-        printf("set %d\n", i.ref->second);

-    csset_sx_del(&s);

+    c_forvar (csmap_mx m = csmap_mx_init(), csmap_mx_del(&m))

+    {

+        csmap_mx_insert(&m, 5, 'a');

+        csmap_mx_insert(&m, 8, 'b');

+        csmap_mx_insert(&m, 12, 'c');

+

+        csmap_mx_iter_t it = csmap_mx_find(&m, 10); // none

+        char val = csmap_mx_find(&m, 5).ref->second;

+        csmap_mx_put(&m, 5, 'd'); // update

+        csmap_mx_erase(&m, 8);

+

+        c_foreach (i, csmap_mx, m)

+            printf("map %d: %c\n", i.ref->first, i.ref->second);

+    }

 }

 */

 #include <stc/ccommon.h>

@@ -49,47 +56,56 @@ int main(void) {
             using_csmap_4(X, Key, Mapped, c_default_compare)

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

             using_csmap_6(X, Key, Mapped, keyCompare, c_default_del, c_default_fromraw)

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

+            using_csmap_6(X, Key, Mapped, keyCompare, mappedDel, c_no_clone)

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

-            using_csmap_8(X, Key, Mapped, keyCompare, mappedDel, mappedClone, c_default_del, c_default_fromraw)

-#define using_csmap_8(X, Key, Mapped, keyCompare, mappedDel, mappedClone, keyDel, keyClone) \

-            using_csmap_10(X, Key, Mapped, keyCompare, mappedDel, mappedClone, \

-                           keyDel, keyClone, c_default_toraw, Key)

+            using_csmap_8(X, Key, Mapped, keyCompare, mappedDel, mappedClone, c_default_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)

 

-#define using_csmap_10(X, Key, Mapped, keyCompareRaw, mappedDel, mappedClone, \

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

+                       mappedDel, mappedFromRaw, mappedToRaw, RawMapped, \

                        keyDel, keyFromRaw, keyToRaw, RawKey) \

-            _c_using_aatree(csmap_##X, csmap_, Key, Mapped, keyCompareRaw, mappedDel, keyDel, \

-                            keyFromRaw, keyToRaw, RawKey, mappedClone, c_default_toraw, Mapped)

+            _c_using_aatree(csmap_##X, csmap_, Key, Mapped, keyCompareRaw, \

+                            mappedDel, mappedFromRaw, mappedToRaw, RawMapped, \

+                            keyDel, keyFromRaw, keyToRaw, RawKey)

 

-/* csset: */

-#define using_csset(...) c_MACRO_OVERLOAD(using_csset, __VA_ARGS__)

 

-#define using_csset_2(X, Key) \

-            using_csset_3(X, Key, c_default_compare)

-#define using_csset_3(X, Key, keyCompare) \

-            using_csset_5(X, Key, keyCompare, c_default_del, c_default_fromraw)

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

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

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

-            _c_using_aatree(csset_##X, csset_, Key, Key, keyCompareRaw, @@, keyDel, \

-                            keyFromRaw, keyToRaw, RawKey, @@, @@, void)

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

+

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

+            using_csmap_keydef_8(X, Key, Mapped, keyCompare, \

+                           keyDel, keyClone, c_default_toraw, Key)

+

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

+                       keyDel, keyFromRaw, keyToRaw, RawKey) \

+            _c_using_aatree(csmap_##X, csmap_, Key, Mapped, keyCompareRaw, \

+                            c_default_del, c_default_fromraw, c_default_toraw, Mapped, \

+                            keyDel, keyFromRaw, keyToRaw, RawKey)

 

-/* csset_str, csmap_str, csmap_strkey, csmap_strval: */

-#define using_csset_str() \

-            _c_using_aatree_strkey(str, csset_, cstr, @@, @@)

 #define using_csmap_str() \

-            _c_using_aatree(csmap_str, csmap_, cstr, cstr, c_rawstr_compare, cstr_del, cstr_del, \

-                            cstr_from, cstr_toraw, const char*, cstr_from, cstr_toraw, const char*)

+            _c_using_aatree(csmap_str, csmap_, cstr, cstr, c_rawstr_compare, \

+                            cstr_del, cstr_from, cstr_toraw, const char*, \

+                            cstr_del, cstr_from, cstr_toraw, const char*)

 

 

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

 

 #define using_csmap_strkey_2(X, Mapped) \

-            _c_using_aatree_strkey(X, csmap_, Mapped, c_default_del, c_default_fromraw)

+            using_csmap_strkey_4(X, Mapped, c_default_del, c_default_fromraw)

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

+            using_csmap_strkey_4(X, Mapped, mappedDel, c_no_clone)

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

-            _c_using_aatree_strkey(X, csmap_, Mapped, mappedDel, mappedClone)

-#define _c_using_aatree_strkey(X, C, Mapped, mappedDel, mappedClone) \

-            _c_using_aatree(C##X, C, cstr, Mapped, c_rawstr_compare, mappedDel, cstr_del, \

-                            cstr_from, cstr_toraw, const char*, mappedClone, c_default_toraw, Mapped)

+            _c_using_aatree_strkey(X, csmap_, Mapped, mappedDel, mappedClone, c_default_toraw, Mapped)

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

+            _c_using_aatree_strkey(X, csmap_, Mapped, mappedDel, mappedFromRaw, mappedToRaw, RawMapped)

+

+#define _c_using_aatree_strkey(X, C, Mapped, mappedDel, mappedFromRaw, mappedToRaw, RawMapped) \

+            _c_using_aatree(C##X, C, cstr, Mapped, c_rawstr_compare, \

+                            mappedDel, mappedFromRaw, mappedToRaw, RawMapped, \

+                            cstr_del, cstr_from, cstr_toraw, const char*)

 

 

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

@@ -98,62 +114,70 @@ int main(void) {
             using_csmap_strval_3(X, Key, c_default_compare)

 #define using_csmap_strval_3(X, Key, keyCompare) \

             using_csmap_strval_5(X, Key, keyCompare, c_default_del, c_default_fromraw)

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

+            using_csmap_strval_5(X, Key, keyCompare, keyDel, c_no_clone)

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

             using_csmap_strval_7(X, Key, keyCompare, keyDel, keyClone, c_default_toraw, Key)

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

-            _c_using_aatree(csmap_##X, csmap_, Key, cstr, keyCompare, cstr_del, keyDel, \

-                            keyFromRaw, keyToRaw, RawKey, cstr_from, cstr_toraw, const char*)

 

-#define SET_ONLY_csset_(...) __VA_ARGS__

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

+            _c_using_aatree(csmap_##X, csmap_, Key, cstr, keyCompareRaw, \

+                            cstr_del, cstr_from, cstr_toraw, const char*, \

+                            keyDel, keyFromRaw, keyToRaw, RawKey)

+

 #define SET_ONLY_csmap_(...)

-#define MAP_ONLY_csset_(...)

 #define MAP_ONLY_csmap_(...) __VA_ARGS__

-#define KEY_REF_csset_(vp)   (vp)

 #define KEY_REF_csmap_(vp)   (&(vp)->first)

 

-#define _c_using_aatree_types(CX, C, Key, Mapped) \

+#define _c_aatree_types(CX, C, Key, Mapped) \

     typedef Key CX##_key_t; \

     typedef Mapped CX##_mapped_t; \

 \

     typedef SET_ONLY_##C( CX##_key_t ) \

-            MAP_ONLY_##C( struct {CX##_key_t first; \

-                                  CX##_mapped_t second;} ) \

+            MAP_ONLY_##C( struct CX##_value_t ) \

     CX##_value_t; \

 \

-    typedef struct CX##_node { \

-        struct CX##_node *link[2]; \

-        uint8_t level; \

-        CX##_value_t value; \

-    } CX##_node_t; \

+    typedef struct CX##_node_t CX##_node_t; \

 \

     typedef struct { \

         CX##_value_t *ref; \

         int _top; \

         CX##_node_t *_tn, *_st[36]; \

-    } CX##_iter_t

-

-

-#define _c_using_aatree(CX, C, Key, Mapped, keyCompareRaw, mappedDel, keyDel, \

-                        keyFromRaw, keyToRaw, RawKey, mappedFromRaw, mappedToRaw, RawMapped) \

-    _c_using_aatree_types(CX, C, Key, Mapped); \

+    } CX##_iter_t; \

+\

+    typedef struct { \

+        CX##_value_t *ref; \

+        bool inserted; \

+    } CX##_result_t; \

 \

     typedef struct { \

         CX##_node_t* root; \

         size_t size; \

-    } CX; \

+    } CX

+

+#define _c_aatree_complete_types(CX, C) \

+    MAP_ONLY_##C( struct CX##_value_t { \

+        CX##_key_t first; \

+        CX##_mapped_t second; \

+    }; ) \

+    struct CX##_node_t { \

+        struct CX##_node_t *link[2]; \

+        uint8_t level; \

+        CX##_value_t value; \

+    }

+

+#define _c_using_aatree(CX, C, Key, Mapped, keyCompareRaw, \

+                        mappedDel, mappedFromRaw, mappedToRaw, RawMapped, \

+                        keyDel, keyFromRaw, keyToRaw, RawKey) \

+    _c_aatree_types(CX, C, Key, Mapped); \

+    _c_aatree_complete_types(CX, C); \

 \

     typedef RawKey CX##_rawkey_t; \

     typedef RawMapped CX##_rawmapped_t; \

     typedef SET_ONLY_##C( CX##_rawkey_t ) \

-            MAP_ONLY_##C( struct {CX##_rawkey_t first; \

-                                  CX##_rawmapped_t second;} ) \

+            MAP_ONLY_##C( struct { CX##_rawkey_t first; \

+                                   CX##_rawmapped_t second; } ) \

     CX##_rawvalue_t; \

 \

-    typedef struct { \

-        CX##_value_t *ref; \

-        bool inserted; \

-    } CX##_result_t; \

-\

     STC_API CX               CX##_init(void); \

     STC_API CX##_value_t*    CX##_find_it(const CX* self, RawKey rkey, CX##_iter_t* out); \

     STC_API CX##_iter_t      CX##_lower_bound(const CX* self, RawKey rkey); \

@@ -274,18 +298,25 @@ int main(void) {
         self->size -= erased; return erased; \

     } \

 \

-    _c_implement_aatree(CX, C, Key, Mapped, keyCompareRaw, mappedDel, keyDel, \

-                        keyFromRaw, keyToRaw, RawKey, mappedFromRaw, mappedToRaw, RawMapped) \

-    typedef CX CX##_t

+    _c_implement_aatree(CX, C, Key, Mapped, keyCompareRaw, \

+                        mappedDel, mappedFromRaw, mappedToRaw, RawMapped, \

+                        keyDel, keyFromRaw, keyToRaw, RawKey) \

+    struct stc_trailing_semicolon

 

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

 

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

-#define _c_implement_aatree(CX, C, Key, Mapped, keyCompareRaw, mappedDel, keyDel, \

-                            keyFromRaw, keyToRaw, RawKey, mappedFromRaw, mappedToRaw, RawMapped) \

+

+_c_aatree_types(csmap_VOID, csmap_, int, int);

+_c_aatree_complete_types(csmap_VOID, csmap_);

+static csmap_VOID_node_t _csmap_sentinel = {&_csmap_sentinel, &_csmap_sentinel, 0};

+

+#define _c_implement_aatree(CX, C, Key, Mapped, keyCompareRaw, \

+                            mappedDel, mappedFromRaw, mappedToRaw, RawMapped, \

+                            keyDel, keyFromRaw, keyToRaw, RawKey) \

     STC_DEF CX \

     CX##_init(void) { \

-        CX m = {(CX##_node_t *) &aatree_nil, 0}; \

+        CX m = {(CX##_node_t *) &_csmap_sentinel, 0}; \

         return m; \

     } \

 \

@@ -364,7 +395,7 @@ int main(void) {
         } \

         tn = c_new(CX##_node_t); \

         res->ref = &tn->value, res->inserted = true; \

-        tn->link[0] = tn->link[1] = (CX##_node_t*) &aatree_nil, tn->level = 1; \

+        tn->link[0] = tn->link[1] = (CX##_node_t*) &_csmap_sentinel, tn->level = 1; \

         if (top == 0) return tn; \

         up[top - 1]->link[dir] = tn; \

         while (top--) { \

@@ -464,13 +495,9 @@ int main(void) {
         } \

     }

 

-

-_c_using_aatree_types(csmap_VOID, csmap_, int, int);

-static csmap_VOID_node_t aatree_nil = {&aatree_nil, &aatree_nil, 0};

-

 #else

-#define _c_implement_aatree(CX, C, Key, Mapped, keyCompareRaw, mappedDel, keyDel, \

-                            keyFromRaw, keyToRaw, RawKey, mappedFromRaw, mappedToRaw, RawMapped)

+#define _c_implement_aatree(CX, C, Key, Mapped, keyCompareRaw, \

+                            mappedDel, mappedFromRaw, mappedToRaw, RawMapped, \

+                            keyDel, keyFromRaw, keyToRaw, RawKey)

 #endif

-

 #endif

diff --git a/include/stc/ccommon.h b/include/stc/ccommon.h
index a650d6d8..ba00659e 100644
--- a/include/stc/ccommon.h
+++ b/include/stc/ccommon.h
@@ -67,6 +67,7 @@
         ((type *)((char *)(ptr) - offsetof(type, member)))

 

 #define c_struct(S)             typedef struct S S; struct S

+#define c_arg(...)              __VA_ARGS__

 #if __cplusplus

 #define c_new(T)                static_cast<T*>(c_malloc(sizeof(T)))

 #define c_new_n(T, n)           static_cast<T*>(c_malloc(sizeof(T)*(n)))

@@ -104,6 +105,9 @@
 

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

 

+#define c_true(...)             __VA_ARGS__

+#define c_false(...)

+

 /* Generic algorithms */

 

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

@@ -124,10 +128,14 @@
          ; (i <= _c_end) == (0 < _c_inc); i += _c_inc)

 

 #define c_forvar(declvar, ...) for (declvar, *_c_ii = NULL; !_c_ii; ++_c_ii, __VA_ARGS__)

-#define c_arg(...) __VA_ARGS__

 #define c_forscope(start, end) for (int _c_ii = (start, 0); !_c_ii; ++_c_ii, end)

 #define c_fordefer(...) for (int _c_ii = 0; !_c_ii; ++_c_ii, __VA_ARGS__)

 

+#define c_forinitdel(...) c_MACRO_OVERLOAD(c_forinitdel, __VA_ARGS__)

+#define c_forinitdel_2(CX, a) c_forvar(CX a = CX##_init(), CX##_del(&a))

+#define c_forinitdel_3(CX, a, b) c_forvar(c_arg(CX a = CX##_init(), b = CX##_init()), CX##_del(&b), CX##_del(&a))

+#define c_forinitdel_4(CX, a, b, c) c_forvar(c_arg(CX a = CX##_init(), b = CX##_init(), c = CX##_init()), CX##_del(&c), CX##_del(&b), CX##_del(&a))

+

 #define c_forbuffer(b, type, n) c_forbuffer_N(b, type, n, 256)

 #define c_forbuffer_N(b, type, n, BYTES) \

     for (type _c_b[((BYTES) - 1) / sizeof(type) + 1], \

diff --git a/include/stc/cmap.h b/include/stc/cmap.h
index 8c226aa2..7db8ec8c 100644
--- a/include/stc/cmap.h
+++ b/include/stc/cmap.h
@@ -146,41 +146,48 @@ STC_INLINE uint64_t c_default_hash32(const void* data, size_t ignored)
 STC_INLINE uint64_t c_default_hash64(const void* data, size_t ignored)

     {return *(const uint64_t *)data * 0xc6a4a7935bd1e99d;}

 

-#define _c_using_chash(CX, C, Key, Mapped, keyEqualsRaw, keyHashRaw, \

-                       mappedDel, mappedFromRaw, mappedToRaw, RawMapped, \

-                       keyDel, keyFromRaw, keyToRaw, RawKey) \

+#define _c_chash_types(CX, C, Key, Mapped) \

     typedef Key CX##_key_t; \

     typedef Mapped CX##_mapped_t; \

-    typedef RawKey CX##_rawkey_t; \

-    typedef RawMapped CX##_rawmapped_t; \

     typedef CMAP_SIZE_T CX##_size_t; \

 \

     typedef SET_ONLY_##C( const CX##_key_t ) \

-            MAP_ONLY_##C( struct {const CX##_key_t first; \

-                                  Mapped second;} ) \

+            MAP_ONLY_##C( struct CX##_value_t ) \

     CX##_value_t; \

 \

-    typedef SET_ONLY_##C( RawKey ) \

-            MAP_ONLY_##C( struct {RawKey first; \

-                                  RawMapped second;} ) \

-    CX##_rawvalue_t; \

-\

     typedef struct { \

         CX##_value_t *ref; \

         bool inserted; \

     } CX##_result_t; \

 \

     typedef struct { \

+        CX##_value_t *ref; \

+        uint8_t* _hx; \

+    } CX##_iter_t; \

+\

+    typedef struct { \

         CX##_value_t* table; \

         uint8_t* _hashx; \

         CX##_size_t size, bucket_count; \

         float max_load_factor; \

-    } CX; \

+    } CX

+

+#define _c_using_chash(CX, C, Key, Mapped, keyEqualsRaw, keyHashRaw, \

+                       mappedDel, mappedFromRaw, mappedToRaw, RawMapped, \

+                       keyDel, keyFromRaw, keyToRaw, RawKey) \

+    _c_chash_types(CX, C, Key, Mapped); \

 \

-    typedef struct { \

-        CX##_value_t *ref; \

-        uint8_t* _hx; \

-    } CX##_iter_t; \

+    MAP_ONLY_##C( struct CX##_value_t { \

+        const CX##_key_t first; \

+        CX##_mapped_t second; \

+    }; ) \

+\

+    typedef RawKey CX##_rawkey_t; \

+    typedef RawMapped CX##_rawmapped_t; \

+    typedef SET_ONLY_##C( RawKey ) \

+            MAP_ONLY_##C( struct { RawKey first; \

+                                   RawMapped second; } ) \

+    CX##_rawvalue_t; \

 \

     STC_API CX               CX##_with_capacity(size_t cap); \

     STC_API CX               CX##_clone(CX map); \

diff --git a/include/stc/csmap.h b/include/stc/csmap.h
index 336280bf..4f6780fa 100644
--- a/include/stc/csmap.h
+++ b/include/stc/csmap.h
@@ -133,40 +133,21 @@ int main(void) {
 struct csmap_rep { size_t root, disp, head, size, cap; void* nodes[]; };

 #define _csmap_rep(self) c_container_of((self)->nodes, struct csmap_rep, nodes)

 

-

-#define _c_using_aatree(CX, C, Key, Mapped, keyCompareRaw, \

-                        mappedDel, mappedFromRaw, mappedToRaw, RawMapped, \

-                        keyDel, keyFromRaw, keyToRaw, RawKey) \

+#define _c_aatree_types(CX, C, Key, Mapped) \

     typedef Key CX##_key_t; \

     typedef Mapped CX##_mapped_t; \

-    typedef RawKey CX##_rawkey_t; \

-    typedef RawMapped CX##_rawmapped_t; \

     typedef CSMAP_SIZE_T CX##_size_t; \

 \

     typedef SET_ONLY_##C( const CX##_key_t ) \

-            MAP_ONLY_##C( struct {const CX##_key_t first; \

-                                  CX##_mapped_t second;} ) \

+            MAP_ONLY_##C( struct CX##_value_t ) \

     CX##_value_t; \

 \

-    typedef SET_ONLY_##C( RawKey ) \

-            MAP_ONLY_##C( struct {RawKey first; \

-                                  RawMapped second;} ) \

-    CX##_rawvalue_t; \

-\

     typedef struct { \

         CX##_value_t *ref; \

         bool inserted; \

     } CX##_result_t; \

 \

-    typedef struct CX##_node { \

-        CX##_size_t link[2]; \

-        int8_t level; \

-        CX##_value_t value; \

-    } CX##_node_t; \

-\

-    typedef struct { \

-        CX##_node_t *nodes; \

-    } CX; \

+    typedef struct CX##_node_t CX##_node_t; \

 \

     typedef struct { \

         CX##_value_t *ref; \

@@ -175,6 +156,33 @@ struct csmap_rep { size_t root, disp, head, size, cap; void* nodes[]; };
         CX##_size_t _tn, _st[36]; \

     } CX##_iter_t; \

 \

+    typedef struct { \

+        CX##_node_t *nodes; \

+    } CX

+

+#define _c_using_aatree(CX, C, Key, Mapped, keyCompareRaw, \

+                        mappedDel, mappedFromRaw, mappedToRaw, RawMapped, \

+                        keyDel, keyFromRaw, keyToRaw, RawKey) \

+    _c_aatree_types(CX, C, Key, Mapped); \

+\

+    MAP_ONLY_##C( struct CX##_value_t { \

+        const CX##_key_t first; \

+        CX##_mapped_t second; \

+    }; ) \

+\

+    struct CX##_node_t { \

+        CX##_size_t link[2]; \

+        int8_t level; \

+        CX##_value_t value; \

+    }; \

+\

+    typedef RawKey CX##_rawkey_t; \

+    typedef RawMapped CX##_rawmapped_t; \

+    typedef SET_ONLY_##C( RawKey ) \

+            MAP_ONLY_##C( struct { RawKey first; \

+                                   RawMapped second; } ) \

+    CX##_rawvalue_t; \

+\

     STC_API CX               CX##_init(void); \

     STC_API CX               CX##_clone(CX tree); \

     STC_API void             CX##_del(CX* self); \

diff --git a/include/stc/csptr.h b/include/stc/csptr.h
index 66ae5240..6e682360 100644
--- a/include/stc/csptr.h
+++ b/include/stc/csptr.h
@@ -91,16 +91,22 @@ typedef long atomic_count_t;
 #define using_csptr_3(X, Value, valueCompare) \

             using_csptr_4(X, Value, valueCompare, c_default_del)

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

-            _c_using_csptr(csptr_##X, Value, valueCompare, valueDel)

+            _c_using_csptr(csptr_##X, Value, valueCompare, valueDel, c_true)

+#define using_csptr_5(X, Value, valueCompare, valueDel, defineTypes) \

+            _c_using_csptr(csptr_##X, Value, valueCompare, valueDel, defineTypes)

 

+#define forward_csptr(X, Value) _csptr_types(csptr_##X, Value)

 

-#define _c_using_csptr(CX, Value, valueCompare, valueDel) \

+#define _csptr_types(CX, Value) \

     typedef Value CX##_value_t; \

 \

     typedef struct { \

         CX##_value_t* get; \

         atomic_count_t* use_count; \

-    } CX; \

+    } CX

+

+#define _c_using_csptr(CX, Value, valueCompare, valueDel, defineTypes) \

+    defineTypes( _csptr_types(CX, Value); ) \

 \

     STC_INLINE CX \

     CX##_from(CX##_value_t* p) { \

diff --git a/include/stc/cvec.h b/include/stc/cvec.h
index 02537081..26287aeb 100644
--- a/include/stc/cvec.h
+++ b/include/stc/cvec.h
@@ -50,9 +50,6 @@
 struct cvec_rep { size_t size, cap; void* data[]; };

 #define _cvec_rep(self) c_container_of((self)->data, struct cvec_rep, data)

 

-#define c_true(...)  __VA_ARGS__

-#define c_false(...)

-

 #define _cvec_types(CX, Value) \

     typedef Value CX##_value_t; \

     typedef struct { CX##_value_t *ref; } CX##_iter_t; \