From 82d96a5b79ac0ba3c28770c25f2157a500799f92 Mon Sep 17 00:00:00 2001 From: Tyge Løvset Date: Wed, 2 Jun 2021 20:52:25 +0200 Subject: 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.. --- include/stc/cdeq.h | 18 ++++++++++++------ include/stc/clist.h | 42 +++++++++++++++++++++++++----------------- include/stc/cmap.h | 16 ++++++++-------- include/stc/csmap.h | 16 ++++++++-------- include/stc/cvec.h | 12 ++++++------ 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 #include +#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 +#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 #include -#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); \ -- cgit v1.2.3