Removed key constness in cmap/csmap - more annoyance than protection. Made cdeq and clist forwardable.

Note: forwardable parameter is currently last (c_true/c_false). May be moved ahead to after _del parameter, maybe..

5 files changed, 59 insertions, 45 deletions

diff --git a/include/stc/cdeq.h b/include/stc/cdeq.h
index 846a9c7f..49de8662 100644
--- a/include/stc/cdeq.h
+++ b/include/stc/cdeq.h
@@ -27,6 +27,8 @@
 #include <stdlib.h>

 #include <string.h>

 

+#define forward_cdeq(X, Value) _c_cdeq_types(cdeq_##X, Value)

+

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

 

 #define using_cdeq_2(X, Value) \

@@ -38,22 +40,26 @@
 #define using_cdeq_5(X, Value, valueCompare, valueDel, valueClone) \

             using_cdeq_7(X, Value, valueCompare, valueDel, valueClone, c_default_toraw, Value)

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

-            _c_using_cdeq(cdeq_##X, Value, valueCompareRaw, valueDel, valueFromRaw, valueToRaw, RawValue)

+            _c_using_cdeq(cdeq_##X, Value, valueCompareRaw, valueDel, valueFromRaw, valueToRaw, RawValue, c_true)

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

+            _c_using_cdeq(cdeq_##X, Value, valueCompareRaw, valueDel, valueFromRaw, valueToRaw, RawValue, defTypes)

 

 #define using_cdeq_str() \

-            _c_using_cdeq(cdeq_str, cstr, c_rawstr_compare, cstr_del, cstr_from, cstr_toraw, const char*)

+            using_cdeq_7(str, cstr, c_rawstr_compare, cstr_del, cstr_from, cstr_toraw, const char*)

 

 

 struct cdeq_rep { size_t size, cap; void* base[]; };

 #define _cdeq_rep(self) c_container_of((self)->_base, struct cdeq_rep, base)

 

+#define _c_cdeq_types(CX, Value) \

+    typedef Value CX##_value_t; \

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

+    typedef struct {CX##_value_t *_base, *data;} CX

 

-#define _c_using_cdeq(CX, Value, valueCompareRaw, valueDel, valueFromRaw, valueToRaw, RawValue) \

+#define _c_using_cdeq(CX, Value, valueCompareRaw, valueDel, valueFromRaw, valueToRaw, RawValue, defTypes) \

 \

-    typedef Value CX##_value_t; \

+    defTypes( _c_cdeq_types(CX, Value); ) \

     typedef RawValue CX##_rawvalue_t; \

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

-    typedef struct {CX##_value_t *_base, *data;} CX; \

 \

     STC_API CX               CX##_init(void); \

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

diff --git a/include/stc/clist.h b/include/stc/clist.h
index 496fc9d5..4166fffe 100644
--- a/include/stc/clist.h
+++ b/include/stc/clist.h
@@ -56,6 +56,8 @@
 #include "ccommon.h"

 #include <stdlib.h>

 

+#define forward_clist(X, Value) _c_clist_types(clist_##X, Value)

+

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

 

 #define using_clist_2(X, Value) \

@@ -65,39 +67,45 @@
 #define using_clist_4(X, Value, valueCompare, valueDel) \

             using_clist_5(X, Value, valueCompare, valueDel, c_no_clone)

 #define using_clist_5(X, Value, valueCompare, valueDel, valueClone) \

-            _c_using_clist(clist_##X, Value, valueCompare, valueDel, valueClone, c_default_toraw, Value)

+            using_clist_7(X, Value, valueCompare, valueDel, valueClone, c_default_toraw, Value)

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

-            _c_using_clist(clist_##X, Value, valueCompareRaw, valueDel, valueFromRaw, valueToRaw, RawValue)

+            _c_using_clist(clist_##X, Value, valueCompareRaw, valueDel, valueFromRaw, valueToRaw, RawValue, c_true)

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

+            _c_using_clist(clist_##X, Value, valueCompareRaw, valueDel, valueFromRaw, valueToRaw, RawValue, defTypes)

 

 #define using_clist_str() \

-            _c_using_clist(clist_str, cstr, c_rawstr_compare, cstr_del, cstr_from, cstr_toraw, const char*)

+            using_clist_7(str, cstr, c_rawstr_compare, cstr_del, cstr_from, cstr_toraw, const char*)

 

 

-#define _c_using_clist_types(CX, Value) \

+#define _c_clist_types(CX, Value) \

     typedef Value CX##_value_t; \

-\

-    typedef struct CX##_node { \

-        struct CX##_node *next; \

-        CX##_value_t value; \

-    } CX##_node_t; \

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

 \

     typedef struct { \

-        CX##_node_t *last; \

-    } CX; \

+        CX##_node_t *const *_last, *prev; \

+        CX##_value_t *ref; \

+    } CX##_iter_t; \

 \

     typedef struct { \

-        CX##_node_t *const*_last, *prev; \

-        CX##_value_t *ref; \

-    } CX##_iter_t

+        CX##_node_t *last; \

+    } CX

+

+#define _c_clist_complete_types(CX) \

+    struct CX##_node_t { \

+        struct CX##_node_t *next; \

+        CX##_value_t value; \

+    }

 

-_c_using_clist_types(clist_VOID, int);

+_c_clist_types(clist_VOID, int);

+_c_clist_complete_types(clist_VOID);

 STC_API size_t _clist_count(const clist_VOID* self);

 #define _clist_node(CX, vp) c_container_of(vp, CX##_node_t, value)

 

 

-#define _c_using_clist(CX, Value, valueCompareRaw, valueDel, valueFromRaw, valueToRaw, RawValue) \

+#define _c_using_clist(CX, Value, valueCompareRaw, valueDel, valueFromRaw, valueToRaw, RawValue, defTypes) \

 \

-    _c_using_clist_types(CX, Value); \

+    defTypes( _c_clist_types(CX, Value); ) \

+    _c_clist_complete_types(CX); \

     typedef RawValue CX##_rawvalue_t; \

 \

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

diff --git a/include/stc/cmap.h b/include/stc/cmap.h
index 7db8ec8c..ccdc0d11 100644
--- a/include/stc/cmap.h
+++ b/include/stc/cmap.h
@@ -151,7 +151,7 @@ STC_INLINE uint64_t c_default_hash64(const void* data, size_t ignored)
     typedef Mapped CX##_mapped_t; \

     typedef CMAP_SIZE_T CX##_size_t; \

 \

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

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

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

     CX##_value_t; \

 \

@@ -178,7 +178,7 @@ STC_INLINE uint64_t c_default_hash64(const void* data, size_t ignored)
     _c_chash_types(CX, C, Key, Mapped); \

 \

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

-        const CX##_key_t first; \

+        CX##_key_t first; \

         CX##_mapped_t second; \

     }; ) \

 \

@@ -212,7 +212,7 @@ STC_INLINE uint64_t c_default_hash64(const void* data, size_t ignored)
 \

     STC_INLINE void \

     CX##_value_clone(CX##_value_t* _dst, CX##_value_t* _val) { \

-        *(CX##_key_t*) KEY_REF_##C(_dst) = keyFromRaw(keyToRaw(KEY_REF_##C(_val))); \

+        *KEY_REF_##C(_dst) = keyFromRaw(keyToRaw(KEY_REF_##C(_val))); \

         MAP_ONLY_##C( _dst->second = mappedFromRaw(mappedToRaw(&_val->second)); ) \

     } \

 \

@@ -224,7 +224,7 @@ STC_INLINE uint64_t c_default_hash64(const void* data, size_t ignored)
 \

     STC_INLINE void \

     CX##_value_del(CX##_value_t* _val) { \

-        keyDel((CX##_key_t*) KEY_REF_##C(_val)); \

+        keyDel(KEY_REF_##C(_val)); \

         MAP_ONLY_##C( mappedDel(&_val->second); ) \

     } \

 \

@@ -232,7 +232,7 @@ STC_INLINE uint64_t c_default_hash64(const void* data, size_t ignored)
     CX##_emplace(CX* self, RawKey rkey MAP_ONLY_##C(, RawMapped rmapped)) { \

         CX##_result_t _res = CX##_insert_entry_(self, rkey); \

         if (_res.inserted) { \

-            *(CX##_key_t*) KEY_REF_##C(_res.ref) = keyFromRaw(rkey); \

+            *KEY_REF_##C(_res.ref) = keyFromRaw(rkey); \

             MAP_ONLY_##C(_res.ref->second = mappedFromRaw(rmapped);) \

         } \

         return _res; \

@@ -247,7 +247,7 @@ STC_INLINE uint64_t c_default_hash64(const void* data, size_t ignored)
     STC_INLINE CX##_result_t \

     CX##_insert(CX* self, Key _key MAP_ONLY_##C(, Mapped _mapped)) { \

         CX##_result_t _res = CX##_insert_entry_(self, keyToRaw(&_key)); \

-        if (_res.inserted) {*(CX##_key_t*) KEY_REF_##C(_res.ref) = _key; MAP_ONLY_##C( _res.ref->second = _mapped; )} \

+        if (_res.inserted) {*KEY_REF_##C(_res.ref) = _key; MAP_ONLY_##C( _res.ref->second = _mapped; )} \

         else              {keyDel(&_key); MAP_ONLY_##C( mappedDel(&_mapped); )} \

         return _res; \

     } \

@@ -256,7 +256,7 @@ STC_INLINE uint64_t c_default_hash64(const void* data, size_t ignored)
         STC_INLINE CX##_result_t \

         CX##_insert_or_assign(CX* self, Key _key, Mapped _mapped) { \

             CX##_result_t _res = CX##_insert_entry_(self, keyToRaw(&_key)); \

-            if (_res.inserted) *(CX##_key_t*) &_res.ref->first = _key; \

+            if (_res.inserted) _res.ref->first = _key; \

             else {keyDel(&_key); mappedDel(&_res.ref->second);} \

             _res.ref->second = _mapped; return _res; \

         } \

@@ -269,7 +269,7 @@ STC_INLINE uint64_t c_default_hash64(const void* data, size_t ignored)
         STC_INLINE CX##_result_t \

         CX##_emplace_or_assign(CX* self, RawKey rkey, RawMapped rmapped) { \

             CX##_result_t _res = CX##_insert_entry_(self, rkey); \

-            if (_res.inserted) *(CX##_key_t*) &_res.ref->first = keyFromRaw(rkey); \

+            if (_res.inserted) _res.ref->first = keyFromRaw(rkey); \

             else mappedDel(&_res.ref->second); \

             _res.ref->second = mappedFromRaw(rmapped); return _res; \

         } \

diff --git a/include/stc/csmap.h b/include/stc/csmap.h
index 4f6780fa..05c21b61 100644
--- a/include/stc/csmap.h
+++ b/include/stc/csmap.h
@@ -138,7 +138,7 @@ struct csmap_rep { size_t root, disp, head, size, cap; void* nodes[]; };
     typedef Mapped CX##_mapped_t; \

     typedef CSMAP_SIZE_T CX##_size_t; \

 \

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

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

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

     CX##_value_t; \

 \

@@ -166,7 +166,7 @@ struct csmap_rep { size_t root, disp, head, size, cap; void* nodes[]; };
     _c_aatree_types(CX, C, Key, Mapped); \

 \

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

-        const CX##_key_t first; \

+        CX##_key_t first; \

         CX##_mapped_t second; \

     }; ) \

 \

@@ -221,12 +221,12 @@ struct csmap_rep { size_t root, disp, head, size, cap; void* nodes[]; };
     } \

     STC_INLINE void \

     CX##_value_del(CX##_value_t* val) { \

-        keyDel((CX##_key_t*) KEY_REF_##C(val)); \

+        keyDel(KEY_REF_##C(val)); \

         MAP_ONLY_##C( mappedDel(&val->second); ) \

     } \

     STC_INLINE void \

     CX##_value_clone(CX##_value_t* dst, CX##_value_t* val) { \

-        *(CX##_key_t*) KEY_REF_##C(dst) = keyFromRaw(keyToRaw(KEY_REF_##C(val))); \

+        *KEY_REF_##C(dst) = keyFromRaw(keyToRaw(KEY_REF_##C(val))); \

         MAP_ONLY_##C( dst->second = mappedFromRaw(mappedToRaw(&val->second)); ) \

     } \

 \

@@ -241,7 +241,7 @@ struct csmap_rep { size_t root, disp, head, size, cap; void* nodes[]; };
     CX##_emplace(CX* self, RawKey rkey MAP_ONLY_##C(, RawMapped rmapped)) { \

         CX##_result_t res = CX##_insert_entry_(self, rkey); \

         if (res.inserted) { \

-            *(CX##_key_t*) KEY_REF_##C(res.ref) = keyFromRaw(rkey); \

+            *KEY_REF_##C(res.ref) = keyFromRaw(rkey); \

             MAP_ONLY_##C(res.ref->second = mappedFromRaw(rmapped);) \

         } \

         return res; \

@@ -256,7 +256,7 @@ struct csmap_rep { size_t root, disp, head, size, cap; void* nodes[]; };
     STC_INLINE CX##_result_t \

     CX##_insert(CX* self, Key key MAP_ONLY_##C(, Mapped mapped)) { \

         CX##_result_t res = CX##_insert_entry_(self, keyToRaw(&key)); \

-        if (res.inserted) {*(CX##_key_t*) KEY_REF_##C(res.ref) = key; MAP_ONLY_##C( res.ref->second = mapped; )} \

+        if (res.inserted) {*KEY_REF_##C(res.ref) = key; MAP_ONLY_##C( res.ref->second = mapped; )} \

         else              {keyDel(&key); MAP_ONLY_##C( mappedDel(&mapped); )} \

         return res; \

     } \

@@ -265,7 +265,7 @@ struct csmap_rep { size_t root, disp, head, size, cap; void* nodes[]; };
         STC_INLINE CX##_result_t \

         CX##_insert_or_assign(CX* self, Key key, Mapped mapped) { \

             CX##_result_t res = CX##_insert_entry_(self, keyToRaw(&key)); \

-            if (res.inserted) *(CX##_key_t*) &res.ref->first = key; \

+            if (res.inserted) res.ref->first = key; \

             else {keyDel(&key); mappedDel(&res.ref->second);} \

             res.ref->second = mapped; return res; \

         } \

@@ -278,7 +278,7 @@ struct csmap_rep { size_t root, disp, head, size, cap; void* nodes[]; };
         STC_INLINE CX##_result_t \

         CX##_emplace_or_assign(CX* self, RawKey rkey, RawMapped rmapped) { \

             CX##_result_t res = CX##_insert_entry_(self, rkey); \

-            if (res.inserted) *(CX##_key_t*) &res.ref->first = keyFromRaw(rkey); \

+            if (res.inserted) res.ref->first = keyFromRaw(rkey); \

             else mappedDel(&res.ref->second); \

             res.ref->second = mappedFromRaw(rmapped); return res; \

         } \

diff --git a/include/stc/cvec.h b/include/stc/cvec.h
index 26287aeb..ed94e785 100644
--- a/include/stc/cvec.h
+++ b/include/stc/cvec.h
@@ -27,7 +27,7 @@
 #include <stdlib.h>

 #include <string.h>

 

-#define forward_cvec(X, Value) _cvec_types(cvec_##X, Value)

+#define forward_cvec(X, Value) _c_cvec_types(cvec_##X, Value)

 

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

 

@@ -41,8 +41,8 @@
             using_cvec_7(X, Value, valueCompare, valueDel, valueClone, c_default_toraw, Value)

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

             _c_using_cvec(cvec_##X, Value, valueCompareRaw, valueDel, valueFromRaw, valueToRaw, RawValue, c_true)

-#define using_cvec_8(X, Value, valueCompareRaw, valueDel, valueFromRaw, valueToRaw, RawValue, defineTypes) \

-            _c_using_cvec(cvec_##X, Value, valueCompareRaw, valueDel, valueFromRaw, valueToRaw, RawValue, defineTypes)

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

+            _c_using_cvec(cvec_##X, Value, valueCompareRaw, valueDel, valueFromRaw, valueToRaw, RawValue, defTypes)

 

 #define using_cvec_str() \

             using_cvec_7(str, cstr, c_rawstr_compare, cstr_del, cstr_from, cstr_toraw, const char*)

@@ -50,14 +50,14 @@
 struct cvec_rep { size_t size, cap; void* data[]; };

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

 

-#define _cvec_types(CX, Value) \

+#define _c_cvec_types(CX, Value) \

     typedef Value CX##_value_t; \

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

     typedef struct { CX##_value_t *data; } CX

 

-#define _c_using_cvec(CX, Value, valueCompareRaw, valueDel, valueFromRaw, valueToRaw, RawValue, defineTypes) \

+#define _c_using_cvec(CX, Value, valueCompareRaw, valueDel, valueFromRaw, valueToRaw, RawValue, defTypes) \

 \

-    defineTypes( _cvec_types(CX, Value); ) \

+    defTypes( _c_cvec_types(CX, Value); ) \

     typedef RawValue CX##_rawvalue_t; \

 \

     STC_API CX              CX##_init(void); \