From 5fabf7416364a3b15bc253d98e95a02a56cf409a Mon Sep 17 00:00:00 2001 From: Tyge Løvset Date: Tue, 7 Sep 2021 09:48:19 +0200 Subject: Switched to lowercase input define symbols, e.g. i_KEY => i_key, etc. --- include/stc/carray.h | 28 ++++---- include/stc/ccommon.h | 2 +- include/stc/cdeq.h | 88 +++++++++++------------ include/stc/clist.h | 80 ++++++++++----------- include/stc/clist_v1.h | 76 ++++++++++---------- include/stc/cmap.h | 98 ++++++++++++------------- include/stc/cpque.h | 18 ++--- include/stc/cset.h | 6 +- include/stc/csmap.h | 110 ++++++++++++++-------------- include/stc/csmap_v1.h | 96 ++++++++++++------------- include/stc/csptr.h | 10 +-- include/stc/csset.h | 2 +- include/stc/cvec.h | 94 ++++++++++++------------ include/stc/template.h | 170 ++++++++++++++++++++++---------------------- include/stc/test_new_list.c | 14 ++-- include/stc/test_new_map.c | 18 ++--- include/stc/test_new_vec.c | 14 ++-- 17 files changed, 462 insertions(+), 462 deletions(-) diff --git a/include/stc/carray.h b/include/stc/carray.h index 0d28ff62..e70a4b64 100644 --- a/include/stc/carray.h +++ b/include/stc/carray.h @@ -50,9 +50,9 @@ int main() { } } */ - defTypes( _c_carray2_types(Self, i_VAL); ) + defTypes( _c_carray2_types(Self, i_val); ) \ - STC_API Self cx_memb(_with_values)(size_t xdim, size_t ydim, i_VAL value); \ + STC_API Self cx_memb(_with_values)(size_t xdim, size_t ydim, i_val value); \ STC_API Self cx_memb(_with_storage)(size_t xdim, size_t ydim, cx_value_t* storage); \ STC_API Self cx_memb(_clone)(Self src); \ \ @@ -76,15 +76,15 @@ int main() { } \ STC_INLINE void cx_memb(_next)(cx_iter_t* it) { ++it->ref; } \ \ - _c_implement_carray2(Self, i_VAL, i_VALDEL, i_VALFROM) \ + _c_implement_carray2(Self, i_val, i_valdel, i_valfrom) \ STC_API void cx_memb(_del)(Self* self) // carray3: - defTypes( _c_carray3_types(Self, i_VAL); ) + defTypes( _c_carray3_types(Self, i_val); ) \ - STC_API Self cx_memb(_with_values)(size_t xdim, size_t ydim, size_t zdim, i_VAL value); \ + STC_API Self cx_memb(_with_values)(size_t xdim, size_t ydim, size_t zdim, i_val value); \ STC_API Self cx_memb(_with_storage)(size_t xdim, size_t ydim, size_t zdim, cx_value_t* storage); \ STC_API Self cx_memb(_clone)(Self src); \ \ @@ -111,14 +111,14 @@ int main() { } \ STC_INLINE void cx_memb(_next)(cx_iter_t* it) { ++it->ref; } \ \ - _c_implement_carray3(Self, i_VAL, i_VALDEL, i_VALFROM) \ + _c_implement_carray3(Self, i_val, i_valdel, i_valfrom) \ STC_API void cx_memb(_del)(Self* self) /* -------------------------- IMPLEMENTATION ------------------------- */ #if !defined(STC_HEADER) || defined(STC_IMPLEMENTATION) -#define _c_implement_carray2(Self, i_VAL, i_VALDEL, i_VALFROM) \ +#define _c_implement_carray2(Self, i_val, i_valdel, i_valfrom) \ \ STC_DEF Self cx_memb(_with_storage)(size_t xdim, size_t ydim, cx_value_t* block) { \ Self _arr = {c_new_n(cx_value_t*, xdim), xdim, ydim}; \ @@ -127,7 +127,7 @@ int main() { return _arr; \ } \ \ - STC_DEF Self cx_memb(_with_values)(size_t xdim, size_t ydim, i_VAL value) { \ + STC_DEF Self cx_memb(_with_values)(size_t xdim, size_t ydim, i_val value) { \ Self _arr = cx_memb(_init)(xdim, ydim); \ for (cx_value_t* p = _arr.data[0], *e = p + xdim*ydim; p != e; ++p) \ *p = value; \ @@ -137,21 +137,21 @@ int main() { STC_DEF Self cx_memb(_clone)(Self src) { \ Self _arr = cx_memb(_init)(src.xdim, src.ydim); \ for (cx_value_t* p = _arr.data[0], *q = src.data[0], *e = p + cx_memb(_size)(src); p != e; ++p, ++q) \ - *p = i_VALFROM(*q); \ + *p = i_valfrom(*q); \ return _arr; \ } \ \ STC_DEF void cx_memb(_del)(Self* self) { \ if (!self->data) return; \ for (cx_value_t* p = self->data[0], *e = p + cx_memb(_size)(*self); p != e; ++p) \ - i_VALDEL(p); \ + i_valdel(p); \ c_free(self->data[0]); /* data */ \ c_free(self->data); /* pointers */ \ } // carray3 impl. -#define _c_implement_carray3(Self, i_VAL, i_VALDEL, i_VALFROM) \ +#define _c_implement_carray3(Self, i_val, i_valdel, i_valfrom) \ \ STC_DEF Self cx_memb(_with_storage)(size_t xdim, size_t ydim, size_t zdim, cx_value_t* block) { \ Self _arr = {c_new_n(cx_value_t**, xdim*(ydim + 1)), xdim, ydim, zdim}; \ @@ -162,7 +162,7 @@ int main() { return _arr; \ } \ \ - STC_DEF Self cx_memb(_with_values)(size_t xdim, size_t ydim, size_t zdim, i_VAL value) { \ + STC_DEF Self cx_memb(_with_values)(size_t xdim, size_t ydim, size_t zdim, i_val value) { \ Self _arr = cx_memb(_init)(xdim, ydim, zdim); \ for (cx_value_t* p = **_arr.data, *e = p + xdim*ydim*zdim; p != e; ++p) \ *p = value; \ @@ -172,14 +172,14 @@ int main() { STC_DEF Self cx_memb(_clone)(Self src) { \ Self _arr = cx_memb(_init)(src.xdim, src.ydim, src.zdim); \ for (cx_value_t* p = **_arr.data, *q = **src.data, *e = p + cx_memb(_size)(src); p != e; ++p, ++q) \ - *p = i_VALFROM(*q); \ + *p = i_valfrom(*q); \ return _arr; \ } \ \ STC_DEF void cx_memb(_del)(Self* self) { \ if (!self->data) return; \ for (cx_value_t* p = **self->data, *e = p + cx_memb(_size)(*self); p != e; ++p) \ - i_VALDEL(p); \ + i_valdel(p); \ c_free(self->data[0][0]); /* data */ \ c_free(self->data); /* pointers */ \ } diff --git a/include/stc/ccommon.h b/include/stc/ccommon.h index a2dd32a6..d1df91a3 100644 --- a/include/stc/ccommon.h +++ b/include/stc/ccommon.h @@ -39,7 +39,7 @@ #endif #define STC_INLINE static inline -#if defined(STC_HEADER) || defined(STC_IMPLEMENTATION) || defined(i_IMP) +#if defined(STC_HEADER) || defined(STC_IMPLEMENTATION) || defined(i_imp) # define STC_API extern # define STC_DEF # define STC_LIBRARY_ONLY(...) __VA_ARGS__ diff --git a/include/stc/cdeq.h b/include/stc/cdeq.h index 6eca970a..65e2cd0d 100644 --- a/include/stc/cdeq.h +++ b/include/stc/cdeq.h @@ -28,17 +28,17 @@ #include \ - defTypes( _c_cdeq_types(Self, i_VAL); ) \ - typedef i_VALRAW cx_rawvalue_t; \ + defTypes( _c_cdeq_types(Self, i_val); ) \ + typedef i_valraw cx_rawvalue_t; \ \ STC_API Self cx_memb(_init)(void); \ STC_API Self cx_memb(_clone)(Self cx); \ STC_API void cx_memb(_clear)(Self* self); \ STC_API void cx_memb(_del)(Self* self); \ - STC_API cx_iter_t cx_memb(_find_in)(cx_iter_t p1, cx_iter_t p2, i_VALRAW raw); \ + STC_API cx_iter_t cx_memb(_find_in)(cx_iter_t p1, cx_iter_t p2, i_valraw raw); \ STC_API int cx_memb(_value_compare)(const cx_value_t* x, const cx_value_t* y); \ - STC_API void cx_memb(_push_back)(Self* self, i_VAL value); \ - STC_API void cx_memb(_push_front)(Self* self, i_VAL value); \ + STC_API void cx_memb(_push_back)(Self* self, i_val value); \ + STC_API void cx_memb(_push_front)(Self* self, i_val value); \ STC_API cx_iter_t cx_memb(_erase_range_p)(Self* self, cx_value_t* p1, cx_value_t* p2); \ STC_API cx_iter_t cx_memb(_insert_range_p)(Self* self, cx_value_t* pos, \ const cx_value_t* p1, const cx_value_t* p2, bool clone); \ @@ -50,18 +50,18 @@ STC_INLINE size_t cx_memb(_size)(Self cx) { return _cdeq_rep(&cx)->size; } \ STC_INLINE size_t cx_memb(_capacity)(Self cx) { return _cdeq_rep(&cx)->cap; } \ STC_INLINE void cx_memb(_swap)(Self* a, Self* b) {c_swap(Self, *a, *b); } \ - STC_INLINE i_VAL cx_memb(_value_fromraw)(i_VALRAW raw) { return i_VALFROM(raw); } \ - STC_INLINE i_VALRAW cx_memb(_value_toraw)(cx_value_t* pval) { return i_VALTO(pval); } \ - STC_INLINE i_VAL cx_memb(_value_clone)(i_VAL val) \ - { return i_VALFROM(i_VALTO(&val)); } \ - STC_INLINE void cx_memb(_emplace_back)(Self* self, i_VALRAW raw) \ - { cx_memb(_push_back)(self, i_VALFROM(raw)); } \ - STC_INLINE void cx_memb(_emplace_front)(Self* self, i_VALRAW raw) \ - { cx_memb(_push_front)(self, i_VALFROM(raw)); } \ + STC_INLINE i_val cx_memb(_value_fromraw)(i_valraw raw) { return i_valfrom(raw); } \ + STC_INLINE i_valraw cx_memb(_value_toraw)(cx_value_t* pval) { return i_valto(pval); } \ + STC_INLINE i_val cx_memb(_value_clone)(i_val val) \ + { return i_valfrom(i_valto(&val)); } \ + STC_INLINE void cx_memb(_emplace_back)(Self* self, i_valraw raw) \ + { cx_memb(_push_back)(self, i_valfrom(raw)); } \ + STC_INLINE void cx_memb(_emplace_front)(Self* self, i_valraw raw) \ + { cx_memb(_push_front)(self, i_valfrom(raw)); } \ STC_INLINE void cx_memb(_pop_back)(Self* self) \ - {i_VALDEL(&self->data[--_cdeq_rep(self)->size]); } \ + {i_valdel(&self->data[--_cdeq_rep(self)->size]); } \ STC_INLINE void cx_memb(_pop_front)(Self* self) \ - {i_VALDEL(self->data++); --_cdeq_rep(self)->size; } \ + {i_valdel(self->data++); --_cdeq_rep(self)->size; } \ STC_INLINE cx_value_t* cx_memb(_front)(const Self* self) { return self->data; } \ STC_INLINE cx_value_t* cx_memb(_back)(const Self* self) \ { return self->data + _cdeq_rep(self)->size - 1; } \ @@ -95,7 +95,7 @@ } \ \ STC_INLINE cx_iter_t \ - cx_memb(_insert)(Self* self, size_t idx, i_VAL value) { \ + cx_memb(_insert)(Self* self, size_t idx, i_val value) { \ return cx_memb(_insert_range_p)(self, self->data + idx, &value, &value + 1, false); \ } \ STC_INLINE cx_iter_t \ @@ -103,12 +103,12 @@ return cx_memb(_insert_range_p)(self, self->data + idx, arr, arr + n, false); \ } \ STC_INLINE cx_iter_t \ - cx_memb(_insert_at)(Self* self, cx_iter_t it, i_VAL value) { \ + cx_memb(_insert_at)(Self* self, cx_iter_t it, i_val value) { \ return cx_memb(_insert_range_p)(self, it.ref, &value, &value + 1, false); \ } \ \ STC_INLINE cx_iter_t \ - cx_memb(_emplace)(Self* self, size_t idx, i_VALRAW raw) { \ + cx_memb(_emplace)(Self* self, size_t idx, i_valraw raw) { \ return cx_memb(_emplace_range_p)(self, self->data + idx, &raw, &raw + 1); \ } \ STC_INLINE cx_iter_t \ @@ -116,7 +116,7 @@ return cx_memb(_emplace_range_p)(self, self->data + idx, arr, arr + n); \ } \ STC_INLINE cx_iter_t \ - cx_memb(_emplace_at)(Self* self, cx_iter_t it, i_VALRAW raw) { \ + cx_memb(_emplace_at)(Self* self, cx_iter_t it, i_valraw raw) { \ return cx_memb(_emplace_range_p)(self, it.ref, &raw, &raw + 1); \ } \ STC_INLINE cx_iter_t \ @@ -146,12 +146,12 @@ } \ \ STC_INLINE cx_iter_t \ - cx_memb(_find)(const Self* self, i_VALRAW raw) { \ + cx_memb(_find)(const Self* self, i_valraw raw) { \ return cx_memb(_find_in)(cx_memb(_begin)(self), cx_memb(_end)(self), raw); \ } \ \ STC_INLINE cx_value_t* \ - cx_memb(_get)(const Self* self, i_VALRAW raw) { \ + cx_memb(_get)(const Self* self, i_valraw raw) { \ cx_iter_t end = cx_memb(_end)(self); \ cx_value_t* val = cx_memb(_find_in)(cx_memb(_begin)(self), end, raw).ref; \ return val == end.ref ? NULL : val; \ @@ -168,7 +168,7 @@ cx_memb(_sort_range)(cx_memb(_begin)(self), cx_memb(_end)(self), cx_memb(_value_compare)); \ } \ \ - _c_implement_cdeq(Self, i_VAL, i_CMP, i_VALDEL, i_VALFROM, i_VALTO, i_VALRAW) \ + _c_implement_cdeq(Self, i_val, i_cmp, i_valdel, i_valfrom, i_valto, i_valraw) \ struct stc_trailing_semicolon /* -------------------------- IMPLEMENTATION ------------------------- */ @@ -178,7 +178,7 @@ static struct cdeq_rep _cdeq_sentinel = {0, 0}; #define _cdeq_nfront(self) ((self)->data - (self)->_base) -#define _c_implement_cdeq(Self, i_VAL, i_CMP, i_VALDEL, i_VALFROM, i_VALTO, i_VALRAW) \ +#define _c_implement_cdeq(Self, i_val, i_cmp, i_valdel, i_valfrom, i_valto, i_valraw) \ \ STC_DEF Self \ cx_memb(_init)(void) { \ @@ -190,7 +190,7 @@ static struct cdeq_rep _cdeq_sentinel = {0, 0}; cx_memb(_clear)(Self* self) { \ struct cdeq_rep* rep = _cdeq_rep(self); if (rep->cap) { \ for (cx_value_t *p = self->data, *q = p + rep->size; p != q; ++p) \ - i_VALDEL(p); \ + i_valdel(p); \ rep->size = 0; \ } \ } \ @@ -208,7 +208,7 @@ static struct cdeq_rep _cdeq_sentinel = {0, 0}; size_t sz = rep->size, cap = (size_t) (sz*1.7) + n + 7; \ size_t nfront = _cdeq_nfront(self); \ rep = (struct cdeq_rep*) c_realloc(rep->cap ? rep : NULL, \ - offsetof(struct cdeq_rep, base) + cap*sizeof(i_VAL)); \ + offsetof(struct cdeq_rep, base) + cap*sizeof(i_val)); \ rep->size = sz, rep->cap = cap; \ self->_base = (cx_value_t *) rep->base; \ self->data = self->_base + nfront; \ @@ -221,13 +221,13 @@ static struct cdeq_rep _cdeq_sentinel = {0, 0}; size_t sz = rep->size, cap = rep->cap; \ size_t nfront = _cdeq_nfront(self), nback = cap - sz - nfront; \ if (nfront >= n) { \ - self->data = (cx_value_t *) memmove(self->data - n, self->data, idx*sizeof(i_VAL)); \ + self->data = (cx_value_t *) memmove(self->data - n, self->data, idx*sizeof(i_val)); \ } else { \ if (sz*1.3 + n > cap) cap = cx_memb(_realloc_)(self, n); \ size_t unused = cap - (sz + n); \ size_t pos = (nback*2 < unused) ? unused - nback : unused/2; \ - memmove(self->_base + pos + idx + n, self->data + idx, (sz - idx)*sizeof(i_VAL)); \ - self->data = (cx_value_t *) memmove(self->_base + pos, self->data, idx*sizeof(i_VAL)); \ + memmove(self->_base + pos + idx + n, self->data + idx, (sz - idx)*sizeof(i_val)); \ + self->data = (cx_value_t *) memmove(self->_base + pos, self->data, idx*sizeof(i_val)); \ } \ } \ \ @@ -237,12 +237,12 @@ static struct cdeq_rep _cdeq_sentinel = {0, 0}; size_t sz = rep->size, cap = rep->cap; \ size_t nfront = _cdeq_nfront(self), nback = cap - sz - nfront; \ if (nback >= n || sz*1.3 + n > cap && cx_memb(_realloc_)(self, n)) { \ - memmove(self->data + idx + n, self->data + idx, (sz - idx)*sizeof(i_VAL)); \ + memmove(self->data + idx + n, self->data + idx, (sz - idx)*sizeof(i_val)); \ } else { \ size_t unused = cap - (sz + n); \ size_t pos = (nfront*2 < unused) ? nfront : unused/2; \ - memmove(self->_base + pos, self->data, idx*sizeof(i_VAL)); \ - memmove(self->data + pos + idx + n, self->data + idx, (sz - idx)*sizeof(i_VAL)); \ + memmove(self->_base + pos, self->data, idx*sizeof(i_val)); \ + memmove(self->data + pos + idx + n, self->data + idx, (sz - idx)*sizeof(i_val)); \ self->data = ((cx_value_t *) self->_base) + pos; \ } \ } \ @@ -257,7 +257,7 @@ static struct cdeq_rep _cdeq_sentinel = {0, 0}; } \ \ STC_DEF void \ - cx_memb(_push_front)(Self* self, i_VAL value) { \ + cx_memb(_push_front)(Self* self, i_val value) { \ if (self->data == self->_base) \ cx_memb(_expand_left_)(self, 0, 1); \ else \ @@ -267,7 +267,7 @@ static struct cdeq_rep _cdeq_sentinel = {0, 0}; } \ \ STC_DEF void \ - cx_memb(_push_back)(Self* self, i_VAL value) { \ + cx_memb(_push_back)(Self* self, i_val value) { \ struct cdeq_rep* rep = _cdeq_rep(self); \ if (_cdeq_nfront(self) + rep->size == rep->cap) \ cx_memb(_expand_right_)(self, rep->size, 1); \ @@ -287,7 +287,7 @@ static struct cdeq_rep _cdeq_sentinel = {0, 0}; const cx_value_t* p2, bool clone) { \ pos = cx_memb(_insert_space_)(self, pos, p2 - p1); \ cx_iter_t it = {pos}; \ - if (clone) while (p1 != p2) *pos++ = i_VALFROM(i_VALTO(p1++)); \ + if (clone) while (p1 != p2) *pos++ = i_valfrom(i_valto(p1++)); \ else memcpy(pos, p1, (p2 - p1)*sizeof *p1); \ return it; \ } \ @@ -296,7 +296,7 @@ static struct cdeq_rep _cdeq_sentinel = {0, 0}; cx_memb(_emplace_range_p)(Self* self, cx_value_t* pos, const cx_rawvalue_t* p1, const cx_rawvalue_t* p2) { \ pos = cx_memb(_insert_space_)(self, pos, p2 - p1); \ cx_iter_t it = {pos}; \ - while (p1 != p2) *pos++ = i_VALFROM(*p1++); \ + while (p1 != p2) *pos++ = i_valfrom(*p1++); \ return it; \ } \ \ @@ -305,32 +305,32 @@ static struct cdeq_rep _cdeq_sentinel = {0, 0}; size_t n = p2 - p1; \ if (n > 0) { \ cx_value_t* p = p1, *end = self->data + _cdeq_rep(self)->size; \ - while (p != p2) i_VALDEL(p++); \ + while (p != p2) i_valdel(p++); \ if (p1 == self->data) self->data += n; \ - else memmove(p1, p2, (end - p2) * sizeof(i_VAL)); \ + else memmove(p1, p2, (end - p2) * sizeof(i_val)); \ _cdeq_rep(self)->size -= n; \ } \ return c_make(cx_iter_t){p1}; \ } \ \ STC_DEF cx_iter_t \ - cx_memb(_find_in)(cx_iter_t i1, cx_iter_t i2, i_VALRAW raw) { \ + cx_memb(_find_in)(cx_iter_t i1, cx_iter_t i2, i_valraw raw) { \ for (; i1.ref != i2.ref; ++i1.ref) { \ - i_VALRAW r = i_VALTO(i1.ref); \ - if (i_CMP(&raw, &r) == 0) return i1; \ + i_valraw r = i_valto(i1.ref); \ + if (i_cmp(&raw, &r) == 0) return i1; \ } \ return i2; \ } \ \ STC_DEF int \ cx_memb(_value_compare)(const cx_value_t* x, const cx_value_t* y) { \ - i_VALRAW rx = i_VALTO(x); \ - i_VALRAW ry = i_VALTO(y); \ - return i_CMP(&rx, &ry); \ + i_valraw rx = i_valto(x); \ + i_valraw ry = i_valto(y); \ + return i_cmp(&rx, &ry); \ } #else -#define _c_implement_cdeq(Self, i_VAL, i_CMP, i_VALDEL, i_VALFROM, i_VALTO, i_VALRAW) +#define _c_implement_cdeq(Self, i_val, i_cmp, i_valdel, i_valfrom, i_valto, i_valraw) #endif #endif diff --git a/include/stc/clist.h b/include/stc/clist.h index 63633e55..43790aac 100644 --- a/include/stc/clist.h +++ b/include/stc/clist.h @@ -30,8 +30,8 @@ #include #include - #define i_TAG ix - #define i_VAL int64_t + #define i_tag ix + #define i_val int64_t #include int main() { @@ -72,14 +72,14 @@ _c_clist_types(clist_VOID, int); _c_clist_complete_types(clist_VOID, dummy); #endif // CLIST_H_INCLUDED -#define i_MODULE clist +#define i_module clist #include "template.h" -#if !defined i_FWD -cx_deftypes(_c_clist_types, Self, i_VAL); +#if !defined i_fwd +cx_deftypes(_c_clist_types, Self, i_val); #endif cx_deftypes(_c_clist_complete_types, Self); -typedef i_VALRAW cx_rawvalue_t; +typedef i_valraw cx_rawvalue_t; #ifndef CLIST_H_INCLUDED @@ -91,7 +91,7 @@ typedef i_VALRAW cx_rawvalue_t; entry->value = val // +: set self->last based on node -#if !defined(STC_HEADER) || defined(i_IMP) && (i_IMP == 2) +#if !defined(STC_HEADER) || defined(i_imp) && (i_imp == 2) // NON TEMPLATED CODE STC_DEF size_t @@ -157,17 +157,17 @@ _clist_mergesort(clist_VOID_node_t *list, int (*cmp)(const clist_VOID_node_t*, c STC_API Self cx_memb(_clone)(Self cx); STC_API void cx_memb(_del)(Self* self); -STC_API void cx_memb(_push_back)(Self* self, i_VAL value); -STC_API void cx_memb(_push_front)(Self* self, i_VAL value); -STC_API cx_iter_t cx_memb(_insert)(Self* self, cx_iter_t it, i_VAL value); +STC_API void cx_memb(_push_back)(Self* self, i_val value); +STC_API void cx_memb(_push_front)(Self* self, i_val value); +STC_API cx_iter_t cx_memb(_insert)(Self* self, cx_iter_t it, i_val value); STC_API void cx_memb(_emplace_items)(Self *self, const cx_rawvalue_t arr[], size_t n); STC_API cx_iter_t cx_memb(_erase_at)(Self* self, cx_iter_t it); STC_API cx_iter_t cx_memb(_erase_range)(Self* self, cx_iter_t it1, cx_iter_t it2); -STC_API size_t cx_memb(_remove)(Self* self, i_VALRAW val); +STC_API size_t cx_memb(_remove)(Self* self, i_valraw val); STC_API cx_iter_t cx_memb(_splice)(Self* self, cx_iter_t it, Self* other); STC_API Self cx_memb(_split_off)(Self* self, cx_iter_t it1, cx_iter_t it2); STC_API void cx_memb(_sort)(Self* self); -STC_API cx_iter_t cx_memb(_find_in)(cx_iter_t it1, cx_iter_t it2, i_VALRAW val); +STC_API cx_iter_t cx_memb(_find_in)(cx_iter_t it1, cx_iter_t it2, i_valraw val); STC_API cx_node_t* cx_memb(_erase_after_)(Self* self, cx_node_t* node); STC_INLINE Self cx_memb(_init)(void) { return c_make(Self){NULL}; } @@ -175,20 +175,20 @@ STC_INLINE bool cx_memb(_empty)(Self cx) { return cx.last == NULL; } STC_INLINE size_t cx_memb(_count)(Self cx) { return _clist_count((const clist_VOID*) &cx); } STC_INLINE void cx_memb(_clear)(Self* self) { cx_memb(_del)(self); } -STC_INLINE i_VAL cx_memb(_value_fromraw)(i_VALRAW raw) { return i_VALFROM(raw); } -STC_INLINE i_VALRAW cx_memb(_value_toraw)(cx_value_t* pval) { return i_VALTO(pval); } -STC_INLINE i_VAL cx_memb(_value_clone)(i_VAL val) - { return i_VALFROM(i_VALTO(&val)); } +STC_INLINE i_val cx_memb(_value_fromraw)(i_valraw raw) { return i_valfrom(raw); } +STC_INLINE i_valraw cx_memb(_value_toraw)(cx_value_t* pval) { return i_valto(pval); } +STC_INLINE i_val cx_memb(_value_clone)(i_val val) + { return i_valfrom(i_valto(&val)); } STC_INLINE void cx_memb(_pop_front)(Self* self) { cx_memb(_erase_after_)(self, self->last); } STC_INLINE cx_iter_t cx_memb(_erase)(Self* self, cx_iter_t it) { return cx_memb(_erase_at)(self, it); } -STC_INLINE void cx_memb(_emplace_back)(Self* self, i_VALRAW raw) - { cx_memb(_push_back)(self, i_VALFROM(raw)); } -STC_INLINE void cx_memb(_emplace_front)(Self* self, i_VALRAW raw) - { cx_memb(_push_front)(self, i_VALFROM(raw)); } -STC_INLINE cx_iter_t cx_memb(_emplace)(Self* self, cx_iter_t it, i_VALRAW raw) - { return cx_memb(_insert)(self, it, i_VALFROM(raw)); } +STC_INLINE void cx_memb(_emplace_back)(Self* self, i_valraw raw) + { cx_memb(_push_back)(self, i_valfrom(raw)); } +STC_INLINE void cx_memb(_emplace_front)(Self* self, i_valraw raw) + { cx_memb(_push_front)(self, i_valfrom(raw)); } +STC_INLINE cx_iter_t cx_memb(_emplace)(Self* self, cx_iter_t it, i_valraw raw) + { return cx_memb(_insert)(self, it, i_valfrom(raw)); } STC_INLINE cx_value_t* cx_memb(_front)(const Self* self) { return &self->last->next->value; } STC_INLINE cx_value_t* cx_memb(_back)(const Self* self) { return &self->last->value; } @@ -228,23 +228,23 @@ cx_memb(_splice_range)(Self* self, cx_iter_t it, } STC_INLINE cx_iter_t -cx_memb(_find)(const Self* self, i_VALRAW val) { +cx_memb(_find)(const Self* self, i_valraw val) { return cx_memb(_find_in)(cx_memb(_begin)(self), cx_memb(_end)(self), val); } STC_INLINE cx_value_t* -cx_memb(_get)(const Self* self, i_VALRAW val) { +cx_memb(_get)(const Self* self, i_valraw val) { return cx_memb(_find_in)(cx_memb(_begin)(self), cx_memb(_end)(self), val).ref; } // -------------------------- IMPLEMENTATION ------------------------- -#if !defined(STC_HEADER) || defined(STC_IMPLEMENTATION) || defined(i_IMP) +#if !defined(STC_HEADER) || defined(STC_IMPLEMENTATION) || defined(i_imp) STC_DEF Self cx_memb(_clone)(Self cx) { Self out = cx_memb(_init)(); - c_foreach (it, Self, cx) cx_memb(_emplace_back)(&out, i_VALTO(it.ref)); + c_foreach (it, Self, cx) cx_memb(_emplace_back)(&out, i_valto(it.ref)); return out; } @@ -254,24 +254,24 @@ cx_memb(_del)(Self* self) { } STC_DEF void -cx_memb(_push_back)(Self* self, i_VAL value) { +cx_memb(_push_back)(Self* self, i_val value) { _c_clist_insert_after(self, Self, self->last, value); self->last = entry; } STC_DEF void -cx_memb(_push_front)(Self* self, i_VAL value) { +cx_memb(_push_front)(Self* self, i_val value) { _c_clist_insert_after(self, Self, self->last, value); if (!self->last) self->last = entry; } STC_DEF void cx_memb(_emplace_items)(Self *self, const cx_rawvalue_t arr[], size_t n) { - for (size_t i=0; ilast; _c_clist_insert_after(self, Self, node, value); if (!self->last || !it.ref) { @@ -300,10 +300,10 @@ cx_memb(_erase_range)(Self* self, cx_iter_t it1, cx_iter_t it2) { } STC_DEF cx_iter_t -cx_memb(_find_in)(cx_iter_t it1, cx_iter_t it2, i_VALRAW val) { +cx_memb(_find_in)(cx_iter_t it1, cx_iter_t it2, i_valraw val) { c_foreach (it, Self, it1, it2) { - i_VALRAW r = i_VALTO(it.ref); - if (i_CMP(&r, &val) == 0) return it; + i_valraw r = i_valto(it.ref); + if (i_cmp(&r, &val) == 0) return it; } it2.ref = NULL; return it2; } @@ -314,18 +314,18 @@ cx_memb(_erase_after_)(Self* self, cx_node_t* node) { node->next = next; if (del == next) self->last = node = NULL; else if (self->last == del) self->last = node, node = NULL; - i_VALDEL(&del->value); c_free(del); + i_valdel(&del->value); c_free(del); return node; } STC_DEF size_t -cx_memb(_remove)(Self* self, i_VALRAW val) { +cx_memb(_remove)(Self* self, i_valraw val) { size_t n = 0; cx_node_t* prev = self->last, *node; while (prev) { node = prev->next; - i_VALRAW r = i_VALTO(&node->value); - if (i_CMP(&r, &val) == 0) + i_valraw r = i_valto(&node->value); + if (i_cmp(&r, &val) == 0) prev = cx_memb(_erase_after_)(self, prev), ++n; else prev = (node == self->last ? NULL : node); @@ -361,9 +361,9 @@ cx_memb(_split_off)(Self* self, cx_iter_t it1, cx_iter_t it2) { STC_DEF int cx_memb(_sort_cmp_)(const clist_VOID_node_t* x, const clist_VOID_node_t* y) { - i_VALRAW a = i_VALTO(&((const cx_node_t *) x)->value); - i_VALRAW b = i_VALTO(&((const cx_node_t *) y)->value); - return i_CMP(&a, &b); + i_valraw a = i_valto(&((const cx_node_t *) x)->value); + i_valraw b = i_valto(&((const cx_node_t *) y)->value); + return i_cmp(&a, &b); } STC_DEF void diff --git a/include/stc/clist_v1.h b/include/stc/clist_v1.h index 8a3d6cb7..e19b2764 100644 --- a/include/stc/clist_v1.h +++ b/include/stc/clist_v1.h @@ -61,25 +61,25 @@ _c_clist_types(clist_VOID, int); STC_API size_t _clist_count(const clist_VOID* self); #define _clist_node(Self, vp) c_container_of(vp, cx_node_t, value) -#define _c_using_clist(Self, i_VAL, i_CMP, i_VALDEL, i_VALFROM, i_VALTO, i_VALRAW, defTypes) \ +#define _c_using_clist(Self, i_val, i_cmp, i_valdel, i_valfrom, i_valto, i_valraw, defTypes) \ \ - defTypes( _c_clist_types(Self, i_VAL); ) \ - typedef i_VALRAW cx_rawvalue_t; \ + defTypes( _c_clist_types(Self, i_val); ) \ + typedef i_valraw cx_rawvalue_t; \ \ STC_API Self cx_memb(_clone)(Self lst); \ STC_API void cx_memb(_del)(Self* self); \ - STC_API void cx_memb(_push_back)(Self* self, i_VAL value); \ - STC_API void cx_memb(_push_front)(Self* self, i_VAL value); \ + STC_API void cx_memb(_push_back)(Self* self, i_val value); \ + STC_API void cx_memb(_push_front)(Self* self, i_val value); \ STC_API void cx_memb(_emplace_items)(Self *self, const cx_rawvalue_t arr[], size_t n); \ STC_API Self cx_memb(_split_after)(Self* self, cx_iter_t pos1, cx_iter_t pos2); \ STC_API void cx_memb(_splice_after)(Self* self, cx_iter_t pos, Self* other); \ STC_DEF void cx_memb(_splice_after_range)(Self* self, cx_iter_t pos, Self* other, cx_iter_t i1, cx_iter_t i2); \ - STC_API cx_iter_t cx_memb(_find)(const Self* self, i_VALRAW val); \ - STC_API cx_iter_t cx_memb(_find_before)(const Self* self, i_VALRAW val); \ - STC_API cx_iter_t cx_memb(_find_before_in)(cx_iter_t it1, cx_iter_t it2, i_VALRAW val); \ + STC_API cx_iter_t cx_memb(_find)(const Self* self, i_valraw val); \ + STC_API cx_iter_t cx_memb(_find_before)(const Self* self, i_valraw val); \ + STC_API cx_iter_t cx_memb(_find_before_in)(cx_iter_t it1, cx_iter_t it2, i_valraw val); \ STC_API void cx_memb(_sort)(Self* self); \ - STC_API size_t cx_memb(_remove)(Self* self, i_VALRAW val); \ - STC_API cx_iter_t cx_memb(_insert_after)(Self* self, cx_iter_t pos, i_VAL value); \ + STC_API size_t cx_memb(_remove)(Self* self, i_valraw val); \ + STC_API cx_iter_t cx_memb(_insert_after)(Self* self, cx_iter_t pos, i_val value); \ STC_API cx_iter_t cx_memb(_erase_after)(Self* self, cx_iter_t pos); \ STC_API cx_iter_t cx_memb(_erase_range_after)(Self* self, cx_iter_t pos, cx_iter_t it2); \ STC_API cx_node_t* cx_memb(_erase_after_)(Self* self, cx_node_t* node); \ @@ -87,13 +87,13 @@ STC_API size_t _clist_count(const clist_VOID* self); STC_INLINE Self cx_memb(_init)(void) {Self lst = {NULL}; return lst; } \ STC_INLINE bool cx_memb(_empty)(Self lst) { return lst.last == NULL; } \ STC_INLINE size_t cx_memb(_count)(Self lst) { return _clist_count((const clist_VOID*) &lst); } \ - STC_INLINE i_VAL cx_memb(_value_fromraw)(i_VALRAW raw) { return i_VALFROM(raw); } \ - STC_INLINE i_VAL cx_memb(_value_clone)(i_VAL val) { return i_VALFROM(i_VALTO(&val)); } \ + STC_INLINE i_val cx_memb(_value_fromraw)(i_valraw raw) { return i_valfrom(raw); } \ + STC_INLINE i_val cx_memb(_value_clone)(i_val val) { return i_valfrom(i_valto(&val)); } \ STC_INLINE void cx_memb(_clear)(Self* self) { cx_memb(_del)(self); } \ - STC_INLINE void cx_memb(_emplace_back)(Self* self, i_VALRAW raw) \ - { cx_memb(_push_back)(self, i_VALFROM(raw)); } \ - STC_INLINE void cx_memb(_emplace_front)(Self* self, i_VALRAW raw) \ - { cx_memb(_push_front)(self, i_VALFROM(raw)); } \ + STC_INLINE void cx_memb(_emplace_back)(Self* self, i_valraw raw) \ + { cx_memb(_push_back)(self, i_valfrom(raw)); } \ + STC_INLINE void cx_memb(_emplace_front)(Self* self, i_valraw raw) \ + { cx_memb(_push_front)(self, i_valfrom(raw)); } \ STC_INLINE cx_value_t* \ cx_memb(_front)(const Self* self) { return &self->last->next->value; } \ STC_INLINE cx_value_t* \ @@ -105,8 +105,8 @@ STC_API size_t _clist_count(const clist_VOID* self); { cx_memb(_splice_after)(self, cx_memb(_last)(self), other); } \ \ STC_INLINE cx_iter_t \ - cx_memb(_emplace_after)(Self* self, cx_iter_t pos, i_VALRAW raw) { \ - return cx_memb(_insert_after)(self, pos, i_VALFROM(raw)); \ + cx_memb(_emplace_after)(Self* self, cx_iter_t pos, i_valraw raw) { \ + return cx_memb(_insert_after)(self, pos, i_valfrom(raw)); \ } \ \ STC_INLINE cx_iter_t \ @@ -143,19 +143,19 @@ STC_API size_t _clist_count(const clist_VOID* self); while (n-- && it.ref) cx_memb(_next)(&it); return it; \ } \ \ - _c_implement_clist(Self, i_VAL, i_CMP, i_VALDEL, i_VALFROM, i_VALTO, i_VALRAW) \ + _c_implement_clist(Self, i_val, i_cmp, i_valdel, i_valfrom, i_valto, i_valraw) \ struct stc_trailing_semicolon /* -------------------------- IMPLEMENTATION ------------------------- */ #if !defined(STC_HEADER) || defined(STC_IMPLEMENTATION) -#define _c_implement_clist(Self, i_VAL, i_CMP, i_VALDEL, i_VALFROM, i_VALTO, i_VALRAW) \ +#define _c_implement_clist(Self, i_val, i_cmp, i_valdel, i_valfrom, i_valto, i_valraw) \ \ STC_DEF Self \ cx_memb(_clone)(Self lst) { \ Self out = cx_memb(_init)(); \ c_foreach_3 (i, Self, lst) \ - cx_memb(_emplace_back)(&out, i_VALTO(i.ref)); \ + cx_memb(_emplace_back)(&out, i_valto(i.ref)); \ return out; \ } \ \ @@ -165,23 +165,23 @@ STC_API size_t _clist_count(const clist_VOID* self); } \ \ STC_DEF void \ - cx_memb(_push_back)(Self* self, i_VAL value) { \ + cx_memb(_push_back)(Self* self, i_val value) { \ _c_clist_insert_after(self, Self, self->last, value); \ self->last = entry; \ } \ STC_DEF void \ - cx_memb(_push_front)(Self* self, i_VAL value) { \ + cx_memb(_push_front)(Self* self, i_val value) { \ _c_clist_insert_after(self, Self, self->last, value); \ if (!self->last) self->last = entry; \ } \ \ STC_DEF void \ cx_memb(_emplace_items)(Self *self, const cx_rawvalue_t arr[], size_t n) { \ - for (size_t i=0; ilast && pos._state == 0) self->last = entry; \ @@ -203,24 +203,24 @@ STC_API size_t _clist_count(const clist_VOID* self); } \ \ STC_DEF cx_iter_t \ - cx_memb(_find_before_in)(cx_iter_t it1, cx_iter_t it2, i_VALRAW val) { \ + cx_memb(_find_before_in)(cx_iter_t it1, cx_iter_t it2, i_valraw val) { \ cx_iter_t i = it1; \ for (cx_memb(_next)(&i); i.ref != it2.ref; cx_memb(_next)(&i)) { \ - i_VALRAW r = i_VALTO(i.ref); \ - if (i_CMP(&r, &val) == 0) return it1; \ + i_valraw r = i_valto(i.ref); \ + if (i_cmp(&r, &val) == 0) return it1; \ it1 = i; \ } \ it1.ref = NULL; return it1; \ } \ \ STC_DEF cx_iter_t \ - cx_memb(_find_before)(const Self* self, i_VALRAW val) { \ + cx_memb(_find_before)(const Self* self, i_valraw val) { \ cx_iter_t it = cx_memb(_find_before_in)(cx_memb(_before_begin)(self), cx_memb(_end)(self), val); \ return it; \ } \ \ STC_DEF cx_iter_t \ - cx_memb(_find)(const Self* self, i_VALRAW val) { \ + cx_memb(_find)(const Self* self, i_valraw val) { \ cx_iter_t it = cx_memb(_find_before_in)(cx_memb(_before_begin)(self), cx_memb(_end)(self), val); \ if (it.ref != cx_memb(_end)(self).ref) cx_memb(_next)(&it); \ return it; \ @@ -232,18 +232,18 @@ STC_API size_t _clist_count(const clist_VOID* self); node->next = next; \ if (del == next) self->last = node = NULL; \ else if (self->last == del) self->last = node, node = NULL; \ - i_VALDEL(&del->value); c_free(del); \ + i_valdel(&del->value); c_free(del); \ return node; \ } \ \ STC_DEF size_t \ - cx_memb(_remove)(Self* self, i_VALRAW val) { \ + cx_memb(_remove)(Self* self, i_valraw val) { \ size_t n = 0; \ cx_node_t* prev = self->last, *node; \ while (prev) { \ node = prev->next; \ - i_VALRAW r = i_VALTO(&node->value); \ - if (i_CMP(&r, &val) == 0) \ + i_valraw r = i_valto(&node->value); \ + if (i_cmp(&r, &val) == 0) \ prev = cx_memb(_erase_after_)(self, prev), ++n; \ else \ prev = (node == self->last ? NULL : node); \ @@ -281,9 +281,9 @@ STC_API size_t _clist_count(const clist_VOID* self); \ STC_DEF int \ cx_memb(_sort_cmp_)(const void* x, const void* y) { \ - i_VALRAW a = i_VALTO(&((cx_node_t *) x)->value); \ - i_VALRAW b = i_VALTO(&((cx_node_t *) y)->value); \ - return i_CMP(&a, &b); \ + i_valraw a = i_valto(&((cx_node_t *) x)->value); \ + i_valraw b = i_valto(&((cx_node_t *) y)->value); \ + return i_cmp(&a, &b); \ } \ \ STC_DEF void \ @@ -361,7 +361,7 @@ _clist_mergesort(clist_VOID_node_t *list, int (*cmp)(const void*, const void*)) } #else -#define _c_implement_clist(Self, i_VAL, i_CMP, i_VALDEL, i_VALFROM, i_VALTO, i_VALRAW) +#define _c_implement_clist(Self, i_val, i_cmp, i_valdel, i_valfrom, i_valto, i_valraw) #endif #endif diff --git a/include/stc/cmap.h b/include/stc/cmap.h index d6f480d0..474d43df 100644 --- a/include/stc/cmap.h +++ b/include/stc/cmap.h @@ -25,9 +25,9 @@ /* #include -#define i_TAG mx -#define i_KEY int -#define i_VAL char // Map of int -> char +#define i_tag mx +#define i_key int +#define i_val char // Map of int -> char #include int main(void) { @@ -58,7 +58,7 @@ int main(void) { #define _cmap_inits {NULL, NULL, 0, 0, 0.85f} typedef struct { size_t idx; uint_fast8_t hx; } chash_bucket_t; -#if !defined(STC_HEADER) || defined(STC_IMPLEMENTATION) || defined(i_IMP) +#if !defined(STC_HEADER) || defined(STC_IMPLEMENTATION) || defined(i_imp) STC_INLINE uint64_t c_default_hash(const void *key, size_t len) { const uint64_t m = 0xb5ad4eceda1ce2a9; @@ -87,15 +87,15 @@ STC_INLINE uint64_t c_default_hash64(const void* data, size_t ignored) #endif #endif // CMAP_H_INCLUDED -#ifndef i_MODULE -#define i_MODULE cmap +#ifndef i_module +#define i_module cmap #define cx_MAP_ONLY c_true #define cx_SET_ONLY c_false #define cx_keyref(vp) (&(vp)->first) #endif #include "template.h" -#ifndef i_FWD -cx_deftypes(_c_chash_types, Self, i_KEY, i_VAL, cx_MAP_ONLY, cx_SET_ONLY); +#ifndef i_fwd +cx_deftypes(_c_chash_types, Self, i_key, i_val, cx_MAP_ONLY, cx_SET_ONLY); #endif cx_MAP_ONLY( struct cx_value_t { @@ -103,11 +103,11 @@ cx_MAP_ONLY( struct cx_value_t { cx_mapped_t second; }; ) -typedef i_KEYRAW cx_rawkey_t; -typedef i_VALRAW cx_memb(_rawmapped_t); -typedef cx_SET_ONLY( i_KEYRAW ) - cx_MAP_ONLY( struct { i_KEYRAW first; - i_VALRAW second; } ) +typedef i_keyraw cx_rawkey_t; +typedef i_valraw cx_memb(_rawmapped_t); +typedef cx_SET_ONLY( i_keyraw ) + cx_MAP_ONLY( struct { i_keyraw first; + i_valraw second; } ) cx_rawvalue_t; STC_API Self cx_memb(_with_capacity)(size_t cap); @@ -116,7 +116,7 @@ STC_API void cx_memb(_del)(Self* self); STC_API void cx_memb(_clear)(Self* self); STC_API void cx_memb(_reserve)(Self* self, size_t capacity); STC_API chash_bucket_t cx_memb(_bucket_)(const Self* self, const cx_rawkey_t* rkeyptr); -STC_API cx_result_t cx_memb(_insert_entry_)(Self* self, i_KEYRAW rkey); +STC_API cx_result_t cx_memb(_insert_entry_)(Self* self, i_keyraw rkey); STC_API void cx_memb(_erase_entry)(Self* self, cx_value_t* val); STC_INLINE Self cx_memb(_init)(void) { return c_make(Self)_cmap_inits; } @@ -128,20 +128,20 @@ STC_INLINE size_t cx_memb(_bucket_count)(Self map) { return map.bucket_cou STC_INLINE size_t cx_memb(_capacity)(Self map) { return (size_t) (map.bucket_count * map.max_load_factor); } STC_INLINE void cx_memb(_swap)(Self *map1, Self *map2) {c_swap(Self, *map1, *map2); } -STC_INLINE bool cx_memb(_contains)(const Self* self, i_KEYRAW rkey) +STC_INLINE bool cx_memb(_contains)(const Self* self, i_keyraw rkey) { return self->size && self->_hashx[cx_memb(_bucket_)(self, &rkey).idx]; } cx_MAP_ONLY( - STC_API cx_result_t cx_memb(_insert_or_assign)(Self* self, i_KEY _key, i_VAL _mapped); - STC_API cx_result_t cx_memb(_emplace_or_assign)(Self* self, i_KEYRAW rkey, i_VALRAW rmapped); + STC_API cx_result_t cx_memb(_insert_or_assign)(Self* self, i_key _key, i_val _mapped); + STC_API cx_result_t cx_memb(_emplace_or_assign)(Self* self, i_keyraw rkey, i_valraw rmapped); STC_INLINE cx_result_t /* short-form, like operator[]: */ - cx_memb(_put)(Self* self, i_KEY key, i_VAL mapped) { + cx_memb(_put)(Self* self, i_key key, i_val mapped) { return cx_memb(_insert_or_assign)(self, key, mapped); } STC_INLINE cx_mapped_t* - cx_memb(_at)(const Self* self, i_KEYRAW rkey) { + cx_memb(_at)(const Self* self, i_keyraw rkey) { chash_bucket_t b = cx_memb(_bucket_)(self, &rkey); return &self->table[b.idx].second; } @@ -149,28 +149,28 @@ cx_MAP_ONLY( STC_INLINE void cx_memb(_value_clone)(cx_value_t* _dst, cx_value_t* _val) { - *cx_keyref(_dst) = i_KEYFROM(i_KEYTO(cx_keyref(_val))); - cx_MAP_ONLY( _dst->second = i_VALFROM(i_VALTO(&_val->second)); ) + *cx_keyref(_dst) = i_keyfrom(i_keyto(cx_keyref(_val))); + cx_MAP_ONLY( _dst->second = i_valfrom(i_valto(&_val->second)); ) } STC_INLINE cx_rawvalue_t cx_memb(_value_toraw)(cx_value_t* val) { - return cx_SET_ONLY( i_KEYTO(val) ) - cx_MAP_ONLY( c_make(cx_rawvalue_t){i_KEYTO(&val->first), i_VALTO(&val->second)} ); + return cx_SET_ONLY( i_keyto(val) ) + cx_MAP_ONLY( c_make(cx_rawvalue_t){i_keyto(&val->first), i_valto(&val->second)} ); } STC_INLINE void cx_memb(_value_del)(cx_value_t* _val) { - i_KEYDEL(cx_keyref(_val)); - cx_MAP_ONLY( i_VALDEL(&_val->second); ) + i_keydel(cx_keyref(_val)); + cx_MAP_ONLY( i_valdel(&_val->second); ) } STC_INLINE cx_result_t -cx_memb(_emplace)(Self* self, i_KEYRAW rkey cx_MAP_ONLY(, i_VALRAW rmapped)) { +cx_memb(_emplace)(Self* self, i_keyraw rkey cx_MAP_ONLY(, i_valraw rmapped)) { cx_result_t _res = cx_memb(_insert_entry_)(self, rkey); if (_res.inserted) { - *cx_keyref(_res.ref) = i_KEYFROM(rkey); - cx_MAP_ONLY(_res.ref->second = i_VALFROM(rmapped);) + *cx_keyref(_res.ref) = i_keyfrom(rkey); + cx_MAP_ONLY(_res.ref->second = i_valfrom(rmapped);) } return _res; } @@ -182,15 +182,15 @@ cx_memb(_emplace_items)(Self* self, const cx_rawvalue_t arr[], size_t n) { } STC_INLINE cx_result_t -cx_memb(_insert)(Self* self, i_KEY _key cx_MAP_ONLY(, i_VAL _mapped)) { - cx_result_t _res = cx_memb(_insert_entry_)(self, i_KEYTO(&_key)); +cx_memb(_insert)(Self* self, i_key _key cx_MAP_ONLY(, i_val _mapped)) { + cx_result_t _res = cx_memb(_insert_entry_)(self, i_keyto(&_key)); if (_res.inserted) { *cx_keyref(_res.ref) = _key; cx_MAP_ONLY( _res.ref->second = _mapped; )} - else { i_KEYDEL(&_key); cx_MAP_ONLY( i_VALDEL(&_mapped); )} + else { i_keydel(&_key); cx_MAP_ONLY( i_valdel(&_mapped); )} return _res; } STC_INLINE cx_iter_t -cx_memb(_find)(const Self* self, i_KEYRAW rkey) { +cx_memb(_find)(const Self* self, i_keyraw rkey) { cx_iter_t it = {NULL}; if (self->size == 0) return it; chash_bucket_t b = cx_memb(_bucket_)(self, &rkey); @@ -199,7 +199,7 @@ cx_memb(_find)(const Self* self, i_KEYRAW rkey) { } STC_INLINE cx_value_t* -cx_memb(_get)(const Self* self, i_KEYRAW rkey) +cx_memb(_get)(const Self* self, i_keyraw rkey) { return cx_memb(_find)(self, rkey).ref; } STC_INLINE cx_iter_t @@ -218,7 +218,7 @@ cx_memb(_next)(cx_iter_t* it) {while ((++it->ref, *++it->_hx == 0)) ; } STC_INLINE size_t -cx_memb(_erase)(Self* self, i_KEYRAW rkey) { +cx_memb(_erase)(Self* self, i_keyraw rkey) { if (self->size == 0) return 0; chash_bucket_t b = cx_memb(_bucket_)(self, &rkey); return self->_hashx[b.idx] ? cx_memb(_erase_entry)(self, self->table + b.idx), 1 : 0; @@ -233,7 +233,7 @@ cx_memb(_erase_at)(Self* self, cx_iter_t it) { /* -------------------------- IMPLEMENTATION ------------------------- */ -#if !defined(STC_HEADER) || defined(STC_IMPLEMENTATION) || defined(i_IMP) +#if !defined(STC_HEADER) || defined(STC_IMPLEMENTATION) || defined(i_imp) //STC_INLINE size_t fastrange_uint64_t(uint64_t x, uint64_t n) // { uint64_t lo, hi; c_umul128(x, n, &lo, &hi); return hi; } @@ -268,32 +268,32 @@ STC_DEF void cx_memb(_clear)(Self* self) { cx_MAP_ONLY( STC_DEF cx_result_t - cx_memb(_insert_or_assign)(Self* self, i_KEY _key, i_VAL _mapped) { - cx_result_t _res = cx_memb(_insert_entry_)(self, i_KEYTO(&_key)); + cx_memb(_insert_or_assign)(Self* self, i_key _key, i_val _mapped) { + cx_result_t _res = cx_memb(_insert_entry_)(self, i_keyto(&_key)); if (_res.inserted) _res.ref->first = _key; - else { i_KEYDEL(&_key); i_VALDEL(&_res.ref->second); } + else { i_keydel(&_key); i_valdel(&_res.ref->second); } _res.ref->second = _mapped; return _res; } STC_DEF cx_result_t - cx_memb(_emplace_or_assign)(Self* self, i_KEYRAW rkey, i_VALRAW rmapped) { + cx_memb(_emplace_or_assign)(Self* self, i_keyraw rkey, i_valraw rmapped) { cx_result_t _res = cx_memb(_insert_entry_)(self, rkey); - if (_res.inserted) _res.ref->first = i_KEYFROM(rkey); - else i_VALDEL(&_res.ref->second); - _res.ref->second = i_VALFROM(rmapped); return _res; + if (_res.inserted) _res.ref->first = i_keyfrom(rkey); + else i_valdel(&_res.ref->second); + _res.ref->second = i_valfrom(rmapped); return _res; } ) STC_DEF chash_bucket_t cx_memb(_bucket_)(const Self* self, const cx_rawkey_t* rkeyptr) { - const uint64_t _hash = i_HASH(rkeyptr, sizeof *rkeyptr); + const uint64_t _hash = i_hash(rkeyptr, sizeof *rkeyptr); uint_fast8_t _hx; size_t _cap = self->bucket_count; chash_bucket_t b = {c_PASTE(fastrange_,MAP_SIZE_T)(_hash, _cap), (uint_fast8_t)(_hash | 0x80)}; const uint8_t* _hashx = self->_hashx; while ((_hx = _hashx[b.idx])) { if (_hx == b.hx) { - cx_rawkey_t _raw = i_KEYTO(cx_keyref(self->table + b.idx)); - if (i_EQU(&_raw, rkeyptr)) break; + cx_rawkey_t _raw = i_keyto(cx_keyref(self->table + b.idx)); + if (i_equ(&_raw, rkeyptr)) break; } if (++b.idx == _cap) b.idx = 0; } @@ -301,7 +301,7 @@ cx_memb(_bucket_)(const Self* self, const cx_rawkey_t* rkeyptr) { } STC_DEF cx_result_t -cx_memb(_insert_entry_)(Self* self, i_KEYRAW rkey) { +cx_memb(_insert_entry_)(Self* self, i_keyraw rkey) { if (self->size + 1 >= (cx_memb(_size_t)) (self->bucket_count * self->max_load_factor)) cx_memb(_reserve)(self, 8 + (self->size*13ull >> 3)); chash_bucket_t b = cx_memb(_bucket_)(self, &rkey); @@ -344,7 +344,7 @@ cx_memb(_reserve)(Self* self, size_t _newcap) { uint8_t* _hashx = self->_hashx; for (size_t i = 0; i < _oldcap; ++i, ++e) if (_tmp._hashx[i]) { - cx_rawkey_t _raw = i_KEYTO(cx_keyref(e)); + cx_rawkey_t _raw = i_keyto(cx_keyref(e)); chash_bucket_t b = cx_memb(_bucket_)(self, &_raw); _slot[b.idx] = *e; _hashx[b.idx] = (uint8_t) b.hx; @@ -363,8 +363,8 @@ cx_memb(_erase_entry)(Self* self, cx_value_t* _val) { if (++j == _cap) j = 0; if (! _hashx[j]) break; - cx_rawkey_t _raw = i_KEYTO(cx_keyref(_slot+j)); - k = c_PASTE(fastrange_,MAP_SIZE_T)(i_HASH(&_raw, sizeof _raw), _cap); + cx_rawkey_t _raw = i_keyto(cx_keyref(_slot+j)); + k = c_PASTE(fastrange_,MAP_SIZE_T)(i_hash(&_raw, sizeof _raw), _cap); if ((j < i) ^ (k <= i) ^ (k > j)) /* is k outside (i, j]? */ _slot[i] = _slot[j], _hashx[i] = _hashx[j], i = j; } diff --git a/include/stc/cpque.h b/include/stc/cpque.h index 102cf0aa..a9bc6b56 100644 --- a/include/stc/cpque.h +++ b/include/stc/cpque.h @@ -55,10 +55,10 @@ #define using_cpque_2(X, ctype) \ _c_using_cpque(cpque_##X, ctype, ctype##_value_compare) -#define using_cpque_3(X, ctype, i_CMP) \ - _c_using_cpque(cpque_##X, ctype, i_CMP) +#define using_cpque_3(X, ctype, i_cmp) \ + _c_using_cpque(cpque_##X, ctype, i_cmp) -#define _c_using_cpque(Self, ctype, i_CMP) \ +#define _c_using_cpque(Self, ctype, i_cmp) \ typedef ctype Self; \ typedef ctype##_value_t cx_value_t; \ typedef ctype##_rawvalue_t cx_rawvalue_t; \ @@ -84,7 +84,7 @@ { cx_memb(_push)(self, ctype##_value_fromraw(raw)); } \ STC_API void cx_memb(_emplace_items)(Self *self, const cx_rawvalue_t arr[], size_t n); \ \ - _c_implement_cpque(Self, ctype, i_CMP) \ + _c_implement_cpque(Self, ctype, i_cmp) \ struct stc_trailing_semicolon @@ -92,14 +92,14 @@ #if !defined(STC_HEADER) || defined(STC_IMPLEMENTATION) -#define _c_implement_cpque(Self, ctype, i_CMP) \ +#define _c_implement_cpque(Self, ctype, i_cmp) \ \ STC_INLINE void \ cx_memb(_sift_down_)(cx_value_t* arr, size_t i, size_t n) { \ size_t r = i, c = i << 1; \ while (c <= n) { \ - c += (c < n && i_CMP(&arr[c], &arr[c + 1]) < 0); \ - if (i_CMP(&arr[r], &arr[c]) < 0) { \ + c += (c < n && i_cmp(&arr[c], &arr[c + 1]) < 0); \ + if (i_cmp(&arr[r], &arr[c]) < 0) { \ cx_value_t tmp = arr[r]; arr[r] = arr[c]; arr[r = c] = tmp; \ } else \ return; \ @@ -128,7 +128,7 @@ ctype##_push_back(self, value); /* sift-up the value */ \ size_t n = cx_memb(_size)(*self), c = n; \ cx_value_t *arr = self->data - 1; \ - for (; c > 1 && i_CMP(&arr[c >> 1], &value) < 0; c >>= 1) \ + for (; c > 1 && i_cmp(&arr[c >> 1], &value) < 0; c >>= 1) \ arr[c] = arr[c >> 1]; \ if (c != n) arr[c] = value; \ } \ @@ -140,7 +140,7 @@ } \ #else -#define _c_implement_cpque(Self, ctype, i_CMP) +#define _c_implement_cpque(Self, ctype, i_cmp) #endif #endif diff --git a/include/stc/cset.h b/include/stc/cset.h index aaa42e46..ffdbca0d 100644 --- a/include/stc/cset.h +++ b/include/stc/cset.h @@ -23,8 +23,8 @@ // Unordered set - implemented as closed hashing with linear probing and no tombstones. /* -#define i_TAG sx -#define i_KEY int +#define i_tag sx +#define i_key int #include #include @@ -39,7 +39,7 @@ int main(void) { } */ -#define i_MODULE cset +#define i_module cset #define cx_MAP_ONLY c_false #define cx_SET_ONLY c_true #define cx_keyref(vp) (vp) diff --git a/include/stc/csmap.h b/include/stc/csmap.h index 2b0a9245..3ea30083 100644 --- a/include/stc/csmap.h +++ b/include/stc/csmap.h @@ -56,7 +56,7 @@ 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) #if !defined cx_forwarded - _c_aatree_types(Self, C, i_KEY, i_VAL); + _c_aatree_types(Self, C, i_key, i_val); #endif \ @@ -71,25 +71,25 @@ struct csmap_rep { size_t root, disp, head, size, cap; void* nodes[]; }; cx_value_t value; \ }; \ \ - typedef i_KEYRAW cx_rawkey_t; \ - typedef i_VALRAW cx_memb(_rawmapped_t); \ - typedef cx_SET_ONLY( i_KEYRAW ) \ - cx_MAP_ONLY( struct { i_KEYRAW first; \ - i_VALRAW second; } ) \ + typedef i_keyraw cx_rawkey_t; \ + typedef i_valraw cx_memb(_rawmapped_t); \ + typedef cx_SET_ONLY( i_keyraw ) \ + cx_MAP_ONLY( struct { i_keyraw first; \ + i_valraw second; } ) \ cx_rawvalue_t; \ \ STC_API Self cx_memb(_init)(void); \ STC_API Self cx_memb(_clone)(Self tree); \ STC_API void cx_memb(_del)(Self* self); \ STC_API void cx_memb(_reserve)(Self* self, size_t cap); \ - STC_API cx_value_t* cx_memb(_find_it)(const Self* self, i_KEYRAW rkey, cx_iter_t* out); \ - STC_API cx_iter_t cx_memb(_lower_bound)(const Self* self, i_KEYRAW rkey); \ + STC_API cx_value_t* cx_memb(_find_it)(const Self* self, i_keyraw rkey, cx_iter_t* out); \ + STC_API cx_iter_t cx_memb(_lower_bound)(const Self* self, i_keyraw rkey); \ STC_API cx_value_t* cx_memb(_front)(const Self* self); \ STC_API cx_value_t* cx_memb(_back)(const Self* self); \ - STC_API int cx_memb(_erase)(Self* self, i_KEYRAW rkey); \ + STC_API int cx_memb(_erase)(Self* self, i_keyraw rkey); \ STC_API cx_iter_t cx_memb(_erase_at)(Self* self, cx_iter_t it); \ STC_API cx_iter_t cx_memb(_erase_range)(Self* self, cx_iter_t it1, cx_iter_t it2); \ - STC_API cx_result_t cx_memb(_insert_entry_)(Self* self, i_KEYRAW rkey); \ + STC_API cx_result_t cx_memb(_insert_entry_)(Self* self, i_keyraw rkey); \ STC_API void cx_memb(_next)(cx_iter_t* it); \ \ STC_INLINE bool cx_memb(_empty)(Self tree) { return _csmap_rep(&tree)->size == 0; } \ @@ -97,9 +97,9 @@ struct csmap_rep { size_t root, disp, head, size, cap; void* nodes[]; }; STC_INLINE size_t cx_memb(_capacity)(Self tree) { return _csmap_rep(&tree)->cap; } \ STC_INLINE void cx_memb(_clear)(Self* self) { cx_memb(_del)(self); *self = cx_memb(_init)(); } \ STC_INLINE void cx_memb(_swap)(Self* a, Self* b) {c_swap(Self, *a, *b); } \ - STC_INLINE bool cx_memb(_contains)(const Self* self, i_KEYRAW rkey) \ + STC_INLINE bool cx_memb(_contains)(const Self* self, i_keyraw rkey) \ {cx_iter_t it; return cx_memb(_find_it)(self, rkey, &it) != NULL; } \ - STC_INLINE cx_value_t* cx_memb(_get)(const Self* self, i_KEYRAW rkey) \ + STC_INLINE cx_value_t* cx_memb(_get)(const Self* self, i_keyraw rkey) \ {cx_iter_t it; return cx_memb(_find_it)(self, rkey, &it); } \ \ STC_INLINE Self \ @@ -111,33 +111,33 @@ struct csmap_rep { size_t root, disp, head, size, cap; void* nodes[]; }; \ STC_INLINE cx_rawvalue_t \ cx_memb(_value_toraw)(cx_value_t* val) { \ - return cx_SET_ONLY( i_KEYTO(val) ) \ - cx_MAP_ONLY( c_make(cx_rawvalue_t){i_KEYTO(&val->first), i_VALTO(&val->second)} ); \ + return cx_SET_ONLY( i_keyto(val) ) \ + cx_MAP_ONLY( c_make(cx_rawvalue_t){i_keyto(&val->first), i_valto(&val->second)} ); \ } \ STC_INLINE void \ cx_memb(_value_del)(cx_value_t* val) { \ - i_KEYDEL(cx_keyref(val)); \ - cx_MAP_ONLY( i_VALDEL(&val->second); ) \ + i_keydel(cx_keyref(val)); \ + cx_MAP_ONLY( i_valdel(&val->second); ) \ } \ STC_INLINE void \ cx_memb(_value_clone)(cx_value_t* dst, cx_value_t* val) { \ - *cx_keyref(dst) = i_KEYFROM(i_KEYTO(cx_keyref(val))); \ - cx_MAP_ONLY( dst->second = i_VALFROM(i_VALTO(&val->second)); ) \ + *cx_keyref(dst) = i_keyfrom(i_keyto(cx_keyref(val))); \ + cx_MAP_ONLY( dst->second = i_valfrom(i_valto(&val->second)); ) \ } \ \ STC_INLINE cx_iter_t \ - cx_memb(_find)(const Self* self, i_KEYRAW rkey) { \ + cx_memb(_find)(const Self* self, i_keyraw rkey) { \ cx_iter_t it; \ cx_memb(_find_it)(self, rkey, &it); \ return it; \ } \ \ STC_INLINE cx_result_t \ - cx_memb(_emplace)(Self* self, i_KEYRAW rkey cx_MAP_ONLY(, i_VALRAW rmapped)) { \ + cx_memb(_emplace)(Self* self, i_keyraw rkey cx_MAP_ONLY(, i_valraw rmapped)) { \ cx_result_t res = cx_memb(_insert_entry_)(self, rkey); \ if (res.inserted) { \ - *cx_keyref(res.ref) = i_KEYFROM(rkey); \ - cx_MAP_ONLY(res.ref->second = i_VALFROM(rmapped);) \ + *cx_keyref(res.ref) = i_keyfrom(rkey); \ + cx_MAP_ONLY(res.ref->second = i_valfrom(rmapped);) \ } \ return res; \ } \ @@ -149,37 +149,37 @@ struct csmap_rep { size_t root, disp, head, size, cap; void* nodes[]; }; } \ \ STC_INLINE cx_result_t \ - cx_memb(_insert)(Self* self, i_KEY key cx_MAP_ONLY(, i_VAL mapped)) { \ - cx_result_t res = cx_memb(_insert_entry_)(self, i_KEYTO(&key)); \ + cx_memb(_insert)(Self* self, i_key key cx_MAP_ONLY(, i_val mapped)) { \ + cx_result_t res = cx_memb(_insert_entry_)(self, i_keyto(&key)); \ if (res.inserted) {*cx_keyref(res.ref) = key; cx_MAP_ONLY( res.ref->second = mapped; )} \ - else {i_KEYDEL(&key); cx_MAP_ONLY( i_VALDEL(&mapped); )} \ + else {i_keydel(&key); cx_MAP_ONLY( i_valdel(&mapped); )} \ return res; \ } \ \ cx_MAP_ONLY( \ STC_INLINE cx_result_t \ - cx_memb(_insert_or_assign)(Self* self, i_KEY key, i_VAL mapped) { \ - cx_result_t res = cx_memb(_insert_entry_)(self, i_KEYTO(&key)); \ + cx_memb(_insert_or_assign)(Self* self, i_key key, i_val mapped) { \ + cx_result_t res = cx_memb(_insert_entry_)(self, i_keyto(&key)); \ if (res.inserted) res.ref->first = key; \ - else {i_KEYDEL(&key); i_VALDEL(&res.ref->second); } \ + else {i_keydel(&key); i_valdel(&res.ref->second); } \ res.ref->second = mapped; return res; \ } \ \ STC_INLINE cx_result_t \ - cx_memb(_put)(Self* self, i_KEY key, i_VAL mapped) { \ + cx_memb(_put)(Self* self, i_key key, i_val mapped) { \ return cx_memb(_insert_or_assign)(self, key, mapped); \ } \ \ STC_INLINE cx_result_t \ - cx_memb(_emplace_or_assign)(Self* self, i_KEYRAW rkey, i_VALRAW rmapped) { \ + cx_memb(_emplace_or_assign)(Self* self, i_keyraw rkey, i_valraw rmapped) { \ cx_result_t res = cx_memb(_insert_entry_)(self, rkey); \ - if (res.inserted) res.ref->first = i_KEYFROM(rkey); \ - else i_VALDEL(&res.ref->second); \ - res.ref->second = i_VALFROM(rmapped); return res; \ + if (res.inserted) res.ref->first = i_keyfrom(rkey); \ + else i_valdel(&res.ref->second); \ + res.ref->second = i_valfrom(rmapped); return res; \ } \ \ STC_INLINE cx_mapped_t* \ - cx_memb(_at)(const Self* self, i_KEYRAW rkey) { \ + cx_memb(_at)(const Self* self, i_keyraw rkey) { \ cx_iter_t it; \ return &cx_memb(_find_it)(self, rkey, &it)->second; \ }) \ @@ -203,9 +203,9 @@ struct csmap_rep { size_t root, disp, head, size, cap; void* nodes[]; }; return it; \ } \ \ - _c_implement_aatree(Self, C, i_KEY, i_VAL, i_CMP, \ - i_VALDEL, i_VALFROM, i_VALTO, i_VALRAW, \ - i_KEYDEL, i_KEYFROM, i_KEYTO, i_KEYRAW) \ + _c_implement_aatree(Self, C, i_key, i_val, i_cmp, \ + i_valdel, i_valfrom, i_valto, i_valraw, \ + i_keydel, i_keyfrom, i_keyto, i_keyraw) \ struct stc_trailing_semicolon /* -------------------------- IMPLEMENTATION ------------------------- */ @@ -213,9 +213,9 @@ struct csmap_rep { size_t root, disp, head, size, cap; void* nodes[]; }; #if !defined(STC_HEADER) || defined(STC_IMPLEMENTATION) static struct csmap_rep _csmap_sentinel = {0, 0, 0, 0, 0}; -#define _c_implement_aatree(Self, C, i_KEY, i_VAL, i_CMP, \ - i_VALDEL, i_VALFROM, i_VALTO, i_VALRAW, \ - i_KEYDEL, i_KEYFROM, i_KEYTO, i_KEYRAW) \ +#define _c_implement_aatree(Self, C, i_key, i_val, i_cmp, \ + i_valdel, i_valfrom, i_valto, i_valraw, \ + i_keydel, i_keyfrom, i_keyto, i_keyraw) \ STC_DEF Self \ cx_memb(_init)(void) { \ Self tree = {(cx_node_t *) _csmap_sentinel.nodes}; \ @@ -268,13 +268,13 @@ static struct csmap_rep _csmap_sentinel = {0, 0, 0, 0, 0}; } \ \ STC_DEF cx_value_t* \ - cx_memb(_find_it)(const Self* self, i_KEYRAW rkey, cx_iter_t* out) { \ + cx_memb(_find_it)(const Self* self, i_keyraw rkey, cx_iter_t* out) { \ cx_memb(_size_t) tn = _csmap_rep(self)->root; \ cx_node_t *d = out->_d = self->nodes; \ out->_top = 0; \ while (tn) { \ - int c; cx_rawkey_t raw = i_KEYTO(cx_keyref(&d[tn].value)); \ - if ((c = i_CMP(&raw, &rkey)) < 0) \ + int c; cx_rawkey_t raw = i_keyto(cx_keyref(&d[tn].value)); \ + if ((c = i_cmp(&raw, &rkey)) < 0) \ tn = d[tn].link[1]; \ else if (c > 0) \ { out->_st[out->_top++] = tn; tn = d[tn].link[0]; } \ @@ -285,7 +285,7 @@ static struct csmap_rep _csmap_sentinel = {0, 0, 0, 0, 0}; } \ \ STC_DEF cx_iter_t \ - cx_memb(_lower_bound)(const Self* self, i_KEYRAW rkey) { \ + cx_memb(_lower_bound)(const Self* self, i_keyraw rkey) { \ cx_iter_t it; \ cx_memb(_find_it)(self, rkey, &it); \ if (!it.ref && it._top) { \ @@ -340,8 +340,8 @@ static struct csmap_rep _csmap_sentinel = {0, 0, 0, 0, 0}; int c, top = 0, dir = 0; \ while (tx) { \ up[top++] = tx; \ - i_KEYRAW raw = i_KEYTO(cx_keyref(&d[tx].value)); \ - if ((c = i_CMP(&raw, rkey)) == 0) {res->ref = &d[tx].value; return tn; } \ + i_keyraw raw = i_keyto(cx_keyref(&d[tx].value)); \ + if ((c = i_cmp(&raw, rkey)) == 0) {res->ref = &d[tx].value; return tn; } \ dir = (c < 0); \ tx = d[tx].link[dir]; \ } \ @@ -359,7 +359,7 @@ static struct csmap_rep _csmap_sentinel = {0, 0, 0, 0, 0}; } \ \ STC_DEF cx_result_t \ - cx_memb(_insert_entry_)(Self* self, i_KEYRAW rkey) { \ + cx_memb(_insert_entry_)(Self* self, i_keyraw rkey) { \ cx_result_t res = {NULL, false}; \ cx_memb(_size_t) tn = cx_memb(_insert_entry_i_)(self, (cx_memb(_size_t)) _csmap_rep(self)->root, &rkey, &res); \ _csmap_rep(self)->root = tn; \ @@ -370,8 +370,8 @@ static struct csmap_rep _csmap_sentinel = {0, 0, 0, 0, 0}; STC_DEF cx_memb(_size_t) \ cx_memb(_erase_r_)(cx_node_t *d, cx_memb(_size_t) tn, const cx_rawkey_t* rkey, int *erased) { \ if (tn == 0) return 0; \ - i_KEYRAW raw = i_KEYTO(cx_keyref(&d[tn].value)); \ - cx_memb(_size_t) tx; int c = i_CMP(&raw, rkey); \ + i_keyraw raw = i_keyto(cx_keyref(&d[tn].value)); \ + cx_memb(_size_t) tx; int c = i_cmp(&raw, rkey); \ if (c != 0) \ d[tn].link[c < 0] = cx_memb(_erase_r_)(d, d[tn].link[c < 0], rkey, erased); \ else { \ @@ -381,7 +381,7 @@ static struct csmap_rep _csmap_sentinel = {0, 0, 0, 0, 0}; while (d[tx].link[1]) \ tx = d[tx].link[1]; \ d[tn].value = d[tx].value; /* move */ \ - raw = i_KEYTO(cx_keyref(&d[tn].value)); \ + raw = i_keyto(cx_keyref(&d[tn].value)); \ d[tn].link[0] = cx_memb(_erase_r_)(d, d[tn].link[0], &raw, erased); \ } else { /* unlink node */ \ tx = tn; \ @@ -406,7 +406,7 @@ static struct csmap_rep _csmap_sentinel = {0, 0, 0, 0, 0}; } \ \ STC_DEF int \ - cx_memb(_erase)(Self* self, i_KEYRAW rkey) { \ + cx_memb(_erase)(Self* self, i_keyraw rkey) { \ int erased = 0; \ cx_memb(_size_t) root = cx_memb(_erase_r_)(self->nodes, (cx_memb(_size_t)) _csmap_rep(self)->root, &rkey, &erased); \ return erased ? (_csmap_rep(self)->root = root, --_csmap_rep(self)->size, 1) : 0; \ @@ -414,9 +414,9 @@ static struct csmap_rep _csmap_sentinel = {0, 0, 0, 0, 0}; \ STC_DEF cx_iter_t \ cx_memb(_erase_at)(Self* self, cx_iter_t it) { \ - cx_rawkey_t raw = i_KEYTO(cx_keyref(it.ref)), nxt; \ + cx_rawkey_t raw = i_keyto(cx_keyref(it.ref)), nxt; \ cx_memb(_next)(&it); \ - if (it.ref) nxt = i_KEYTO(cx_keyref(it.ref)); \ + if (it.ref) nxt = i_keyto(cx_keyref(it.ref)); \ cx_memb(_erase)(self, raw); \ if (it.ref) cx_memb(_find_it)(self, nxt, &it); \ return it; \ @@ -427,12 +427,12 @@ static struct csmap_rep _csmap_sentinel = {0, 0, 0, 0, 0}; if (!it2.ref) { while (it1.ref) it1 = cx_memb(_erase_at)(self, it1); \ return it1; } \ cx_key_t k1 = *cx_keyref(it1.ref), k2 = *cx_keyref(it2.ref); \ - cx_rawkey_t r1 = i_KEYTO(&k1); \ + cx_rawkey_t r1 = i_keyto(&k1); \ for (;;) { \ if (memcmp(&k1, &k2, sizeof k1) == 0) return it1; \ cx_memb(_next)(&it1); k1 = *cx_keyref(it1.ref); \ cx_memb(_erase)(self, r1); \ - cx_memb(_find_it)(self, (r1 = i_KEYTO(&k1)), &it1); \ + cx_memb(_find_it)(self, (r1 = i_keyto(&k1)), &it1); \ } \ } \ \ diff --git a/include/stc/csmap_v1.h b/include/stc/csmap_v1.h index e5f35944..b9f443a8 100644 --- a/include/stc/csmap_v1.h +++ b/include/stc/csmap_v1.h @@ -64,21 +64,21 @@ int main(void) { } #ifndef cx_forwarded - _c_aatree_types(Self, C, i_KEY, i_VAL); + _c_aatree_types(Self, C, i_key, i_val); #endif _c_aatree_complete_types(Self, C); \ \ - typedef i_KEYRAW cx_rawkey_t; \ - typedef i_VALRAW cx_memb(_rawmapped_t); \ + typedef i_keyraw cx_rawkey_t; \ + typedef i_valraw cx_memb(_rawmapped_t); \ typedef cx_SET_ONLY( cx_rawkey_t ) \ cx_MAP_ONLY( struct { cx_rawkey_t first; \ cx_memb(_rawmapped_t) second; } ) \ cx_rawvalue_t; \ \ STC_API Self cx_memb(_init)(void); \ - STC_API cx_value_t* cx_memb(_find_it)(const Self* self, i_KEYRAW rkey, cx_iter_t* out); \ - STC_API cx_iter_t cx_memb(_lower_bound)(const Self* self, i_KEYRAW rkey); \ + STC_API cx_value_t* cx_memb(_find_it)(const Self* self, i_keyraw rkey, cx_iter_t* out); \ + STC_API cx_iter_t cx_memb(_lower_bound)(const Self* self, i_keyraw rkey); \ STC_API cx_value_t* cx_memb(_front)(const Self* self); \ STC_API cx_value_t* cx_memb(_back)(const Self* self); \ STC_API cx_iter_t cx_memb(_erase_at)(Self* self, cx_iter_t it); \ @@ -86,7 +86,7 @@ int main(void) { STC_API cx_node_t* cx_memb(_erase_r_)(cx_node_t *tn, const cx_rawkey_t* rkey, int *erased); \ STC_API void cx_memb(_del_r_)(cx_node_t* tn); \ STC_API cx_node_t* cx_memb(_clone_r_)(cx_node_t *tn); \ - STC_API cx_result_t cx_memb(_insert_entry_)(Self* self, i_KEYRAW rkey); \ + STC_API cx_result_t cx_memb(_insert_entry_)(Self* self, i_keyraw rkey); \ STC_API void cx_memb(_next)(cx_iter_t* it); \ \ STC_INLINE bool cx_memb(_empty)(Self cx) { return cx.size == 0; } \ @@ -95,31 +95,31 @@ int main(void) { STC_INLINE void cx_memb(_clear)(Self* self) { cx_memb(_del)(self); *self = cx_memb(_init)(); } \ STC_INLINE void cx_memb(_swap)(Self* a, Self* b) {c_swap(Self, *a, *b); } \ STC_INLINE Self cx_memb(_clone)(Self cx) { return c_make(Self){ cx_memb(_clone_r_)(cx.root), cx.size}; } \ - STC_INLINE cx_iter_t cx_memb(_find)(const Self* self, i_KEYRAW rkey) \ + STC_INLINE cx_iter_t cx_memb(_find)(const Self* self, i_keyraw rkey) \ {cx_iter_t it; cx_memb(_find_it)(self, rkey, &it); return it; } \ - STC_INLINE bool cx_memb(_contains)(const Self* self, i_KEYRAW rkey) \ + STC_INLINE bool cx_memb(_contains)(const Self* self, i_keyraw rkey) \ {cx_iter_t it; return cx_memb(_find_it)(self, rkey, &it) != NULL; } \ - STC_INLINE cx_value_t* cx_memb(_get)(const Self* self, i_KEYRAW rkey) \ + STC_INLINE cx_value_t* cx_memb(_get)(const Self* self, i_keyraw rkey) \ {cx_iter_t it; return cx_memb(_find_it)(self, rkey, &it); } \ \ STC_INLINE void \ cx_memb(_value_del)(cx_value_t* val) { \ - i_KEYDEL(cx_keyref(val)); \ - cx_MAP_ONLY( i_VALDEL(&val->second); ) \ + i_keydel(cx_keyref(val)); \ + cx_MAP_ONLY( i_valdel(&val->second); ) \ } \ \ STC_INLINE void \ cx_memb(_value_clone)(cx_value_t* dst, cx_value_t* val) { \ - *cx_keyref(dst) = i_KEYFROM(i_KEYTO(cx_keyref(val))); \ - cx_MAP_ONLY( dst->second = i_VALFROM(i_VALTO(&val->second)); ) \ + *cx_keyref(dst) = i_keyfrom(i_keyto(cx_keyref(val))); \ + cx_MAP_ONLY( dst->second = i_valfrom(i_valto(&val->second)); ) \ } \ \ STC_INLINE cx_result_t \ - cx_memb(_emplace)(Self* self, i_KEYRAW rkey cx_MAP_ONLY(, i_VALRAW rmapped)) { \ + cx_memb(_emplace)(Self* self, i_keyraw rkey cx_MAP_ONLY(, i_valraw rmapped)) { \ cx_result_t res = cx_memb(_insert_entry_)(self, rkey); \ if (res.inserted) { \ - *cx_keyref(res.ref) = i_KEYFROM(rkey); \ - cx_MAP_ONLY(res.ref->second = i_VALFROM(rmapped);) \ + *cx_keyref(res.ref) = i_keyfrom(rkey); \ + cx_MAP_ONLY(res.ref->second = i_valfrom(rmapped);) \ } \ return res; \ } \ @@ -131,37 +131,37 @@ int main(void) { } \ \ STC_INLINE cx_result_t \ - cx_memb(_insert)(Self* self, i_KEY key cx_MAP_ONLY(, i_VAL mapped)) { \ - cx_result_t res = cx_memb(_insert_entry_)(self, i_KEYTO(&key)); \ + cx_memb(_insert)(Self* self, i_key key cx_MAP_ONLY(, i_val mapped)) { \ + cx_result_t res = cx_memb(_insert_entry_)(self, i_keyto(&key)); \ if (res.inserted) {*cx_keyref(res.ref) = key; cx_MAP_ONLY( res.ref->second = mapped; )} \ - else {i_KEYDEL(&key); cx_MAP_ONLY( i_VALDEL(&mapped); )} \ + else {i_keydel(&key); cx_MAP_ONLY( i_valdel(&mapped); )} \ return res; \ } \ \ cx_MAP_ONLY( \ STC_INLINE cx_result_t \ - cx_memb(_insert_or_assign)(Self* self, i_KEY key, i_VAL mapped) { \ - cx_result_t res = cx_memb(_insert_entry_)(self, i_KEYTO(&key)); \ + cx_memb(_insert_or_assign)(Self* self, i_key key, i_val mapped) { \ + cx_result_t res = cx_memb(_insert_entry_)(self, i_keyto(&key)); \ if (res.inserted) res.ref->first = key; \ - else {i_KEYDEL(&key); i_VALDEL(&res.ref->second); } \ + else {i_keydel(&key); i_valdel(&res.ref->second); } \ res.ref->second = mapped; return res; \ } \ \ STC_INLINE cx_result_t \ - cx_memb(_put)(Self* self, i_KEY key, i_VAL mapped) { \ + cx_memb(_put)(Self* self, i_key key, i_val mapped) { \ return cx_memb(_insert_or_assign)(self, key, mapped); \ } \ \ STC_INLINE cx_result_t \ - cx_memb(_emplace_or_assign)(Self* self, i_KEYRAW rkey, i_VALRAW rmapped) { \ + cx_memb(_emplace_or_assign)(Self* self, i_keyraw rkey, i_valraw rmapped) { \ cx_result_t res = cx_memb(_insert_entry_)(self, rkey); \ - if (res.inserted) res.ref->first = i_KEYFROM(rkey); \ - else i_VALDEL(&res.ref->second); \ - res.ref->second = i_VALFROM(rmapped); return res; \ + if (res.inserted) res.ref->first = i_keyfrom(rkey); \ + else i_valdel(&res.ref->second); \ + res.ref->second = i_valfrom(rmapped); return res; \ } \ \ STC_INLINE cx_mapped_t* \ - cx_memb(_at)(const Self* self, i_KEYRAW rkey) { \ + cx_memb(_at)(const Self* self, i_keyraw rkey) { \ cx_iter_t it; \ return &cx_memb(_find_it)(self, rkey, &it)->second; \ }) \ @@ -178,7 +178,7 @@ int main(void) { } \ \ STC_INLINE size_t \ - cx_memb(_erase)(Self* self, i_KEYRAW rkey) { \ + cx_memb(_erase)(Self* self, i_keyraw rkey) { \ int erased = 0; \ self->root = cx_memb(_erase_r_)(self->root, &rkey, &erased); \ self->size -= erased; return erased; \ @@ -190,9 +190,9 @@ int main(void) { return it; \ } \ \ - _c_implement_aatree(Self, C, i_KEY, i_VAL, i_CMP, \ - i_VALDEL, i_VALFROM, i_VALTO, i_VALRAW, \ - i_KEYDEL, i_KEYFROM, i_KEYTO, i_KEYRAW) \ + _c_implement_aatree(Self, C, i_key, i_val, i_cmp, \ + i_valdel, i_valfrom, i_valto, i_valraw, \ + i_keydel, i_keyfrom, i_keyto, i_keyraw) \ struct stc_trailing_semicolon /* -------------------------- IMPLEMENTATION ------------------------- */ @@ -203,9 +203,9 @@ _c_aatree_types(csmap_SENTINEL, csmap_, int, int); _c_aatree_complete_types(csmap_SENTINEL, csmap_); static csmap_SENTINEL_node_t _aatree_sentinel = {&_aatree_sentinel, &_aatree_sentinel, 0}; -#define _c_implement_aatree(Self, C, i_KEY, i_VAL, i_CMP, \ - i_VALDEL, i_VALFROM, i_VALTO, i_VALRAW, \ - i_KEYDEL, i_KEYFROM, i_KEYTO, i_KEYRAW) \ +#define _c_implement_aatree(Self, C, i_key, i_val, i_cmp, \ + i_valdel, i_valfrom, i_valto, i_valraw, \ + i_keydel, i_keyfrom, i_keyto, i_keyraw) \ STC_DEF Self \ cx_memb(_init)(void) { \ Self cx = {(cx_node_t *) &_aatree_sentinel, 0}; \ @@ -231,8 +231,8 @@ static csmap_SENTINEL_node_t _aatree_sentinel = {&_aatree_sentinel, &_aatree_sen cx_node_t *tn = self->root; \ out->_top = 0; \ while (tn->level) { \ - int c; cx_rawkey_t rx = i_KEYTO(cx_keyref(&tn->value)); \ - if ((c = i_CMP(&rx, &rkey)) < 0) tn = tn->link[1]; \ + int c; cx_rawkey_t rx = i_keyto(cx_keyref(&tn->value)); \ + if ((c = i_cmp(&rx, &rkey)) < 0) tn = tn->link[1]; \ else if (c > 0) {out->_st[out->_top++] = tn; tn = tn->link[0]; } \ else {out->_tn = tn->link[1]; return (out->ref = &tn->value); } \ } \ @@ -240,7 +240,7 @@ static csmap_SENTINEL_node_t _aatree_sentinel = {&_aatree_sentinel, &_aatree_sen } \ \ STC_DEF cx_iter_t \ - cx_memb(_lower_bound)(const Self* self, i_KEYRAW rkey) { \ + cx_memb(_lower_bound)(const Self* self, i_keyraw rkey) { \ cx_iter_t it; \ cx_memb(_find_it)(self, rkey, &it); \ if (!it.ref && it._top) { \ @@ -295,8 +295,8 @@ static csmap_SENTINEL_node_t _aatree_sentinel = {&_aatree_sentinel, &_aatree_sen int c, top = 0, dir = 0; \ while (tx->level) { \ up[top++] = tx; \ - cx_rawkey_t r = i_KEYTO(cx_keyref(&tx->value)); \ - if (!(c = i_CMP(&r, rkey))) {res->ref = &tx->value; return tn; } \ + cx_rawkey_t r = i_keyto(cx_keyref(&tx->value)); \ + if (!(c = i_cmp(&r, rkey))) {res->ref = &tx->value; return tn; } \ tx = tx->link[(dir = (c < 0))]; \ } \ tn = c_new(cx_node_t); \ @@ -314,7 +314,7 @@ static csmap_SENTINEL_node_t _aatree_sentinel = {&_aatree_sentinel, &_aatree_sen } \ \ STC_DEF cx_result_t \ - cx_memb(_insert_entry_)(Self* self, i_KEYRAW rkey) { \ + cx_memb(_insert_entry_)(Self* self, i_keyraw rkey) { \ cx_result_t res = {NULL, false}; \ self->root = cx_memb(_insert_entry_i_)(self->root, &rkey, &res); \ self->size += res.inserted; \ @@ -325,8 +325,8 @@ static csmap_SENTINEL_node_t _aatree_sentinel = {&_aatree_sentinel, &_aatree_sen cx_memb(_erase_r_)(cx_node_t *tn, const cx_rawkey_t* rkey, int *erased) { \ if (tn->level == 0) \ return tn; \ - cx_rawkey_t raw = i_KEYTO(cx_keyref(&tn->value)); \ - cx_node_t *tx; int c = i_CMP(&raw, rkey); \ + cx_rawkey_t raw = i_keyto(cx_keyref(&tn->value)); \ + cx_node_t *tx; int c = i_cmp(&raw, rkey); \ if (c != 0) \ tn->link[c < 0] = cx_memb(_erase_r_)(tn->link[c < 0], rkey, erased); \ else { \ @@ -336,7 +336,7 @@ static csmap_SENTINEL_node_t _aatree_sentinel = {&_aatree_sentinel, &_aatree_sen while (tx->link[1]->level) \ tx = tx->link[1]; \ tn->value = tx->value; \ - raw = i_KEYTO(cx_keyref(&tn->value)); \ + raw = i_keyto(cx_keyref(&tn->value)); \ tn->link[0] = cx_memb(_erase_r_)(tn->link[0], &raw, erased); \ } else { \ tx = tn; \ @@ -357,9 +357,9 @@ static csmap_SENTINEL_node_t _aatree_sentinel = {&_aatree_sentinel, &_aatree_sen } \ STC_DEF cx_iter_t \ cx_memb(_erase_at)(Self* self, cx_iter_t it) { \ - cx_rawkey_t raw = i_KEYTO(cx_keyref(it.ref)), nxt; \ + cx_rawkey_t raw = i_keyto(cx_keyref(it.ref)), nxt; \ cx_memb(_next)(&it); \ - if (it.ref) nxt = i_KEYTO(cx_keyref(it.ref)); \ + if (it.ref) nxt = i_keyto(cx_keyref(it.ref)); \ cx_memb(_erase)(self, raw); \ if (it.ref) cx_memb(_find_it)(self, nxt, &it); \ return it; \ @@ -370,12 +370,12 @@ static csmap_SENTINEL_node_t _aatree_sentinel = {&_aatree_sentinel, &_aatree_sen if (!it2.ref) { while (it1.ref) it1 = cx_memb(_erase_at)(self, it1); \ return it1; } \ cx_key_t k1 = *cx_keyref(it1.ref), k2 = *cx_keyref(it2.ref); \ - cx_rawkey_t r1 = i_KEYTO(&k1); \ + cx_rawkey_t r1 = i_keyto(&k1); \ for (;;) { \ if (memcmp(&k1, &k2, sizeof k1) == 0) return it1; \ cx_memb(_next)(&it1); k1 = *cx_keyref(it1.ref); \ cx_memb(_erase)(self, r1); \ - cx_memb(_find_it)(self, (r1 = i_KEYTO(&k1)), &it1); \ + cx_memb(_find_it)(self, (r1 = i_keyto(&k1)), &it1); \ } \ } \ \ diff --git a/include/stc/csptr.h b/include/stc/csptr.h index 1729235e..e7dd2485 100644 --- a/include/stc/csptr.h +++ b/include/stc/csptr.h @@ -68,11 +68,11 @@ typedef long atomic_count_t; } #endif -#define forward_csptr(X, i_VAL) _csptr_types(csptr_##X, i_VAL) +#define forward_csptr(X, i_val) _csptr_types(csptr_##X, i_val) #define csptr_null {NULL, NULL} - defTypes( _csptr_types(Self, i_VAL); ) \ + defTypes( _csptr_types(Self, i_val); ) \ struct cx_memb(_rep_) {atomic_count_t cnt; cx_value_t val; }; \ \ STC_INLINE Self \ @@ -112,7 +112,7 @@ typedef long atomic_count_t; STC_INLINE void \ cx_memb(_del)(Self* self) { \ if (self->use_count && c_atomic_decrement(self->use_count) == 0) { \ - i_VALDEL(self->get); \ + i_valdel(self->get); \ if (self->get != &((struct cx_memb(_rep_)*)self->use_count)->val) c_free(self->get); \ c_free(self->use_count); \ } \ @@ -148,12 +148,12 @@ typedef long atomic_count_t; \ STC_INLINE int \ cx_memb(_compare)(const Self* x, const Self* y) { \ - return i_CMP(x->get, y->get); \ + return i_cmp(x->get, y->get); \ } \ \ STC_INLINE bool \ cx_memb(_equals)(const Self* x, const Self* y) { \ - return i_CMP(x->get, y->get) == 0; \ + return i_cmp(x->get, y->get) == 0; \ } \ struct stc_trailing_semicolon diff --git a/include/stc/csset.h b/include/stc/csset.h index a5e1499c..f275cbfd 100644 --- a/include/stc/csset.h +++ b/include/stc/csset.h @@ -43,7 +43,7 @@ int main(void) { } */ -#define i_CNT csset +#define i_cnt csset #define KEY_REF_csset(vp) (vp) #include "csmap.h" diff --git a/include/stc/cvec.h b/include/stc/cvec.h index b79116cb..b79191f9 100644 --- a/include/stc/cvec.h +++ b/include/stc/cvec.h @@ -32,14 +32,14 @@ struct MyStruct { cstr name; } typedef MyStruct; -#define i_VAL float +#define i_val float #include -#define i_VAL_str // special for cstr +#define i_val_str // special for cstr #include -#define f_TAG i32 // f: forward declared above; shorthand for i_FWD -#define i_VAL int +#define f_tag i32 // f: forward declared above; shorthand for i_fwd +#define i_val int #include int main() { @@ -67,24 +67,24 @@ struct cvec_Rep_ { size_t size, cap; void* data[]; }; #define cvec_rep_(self) c_container_of((self)->data, struct cvec_Rep_, data) #endif // CVEC_H_INCLUDED -#define i_MODULE cvec +#define i_module cvec #include "template.h" -#if !defined i_FWD - cx_deftypes(_c_cvec_types, Self, i_VAL); +#if !defined i_fwd + cx_deftypes(_c_cvec_types, Self, i_val); #endif -typedef i_VALRAW cx_rawvalue_t; +typedef i_valraw cx_rawvalue_t; STC_API Self cx_memb(_init)(void); STC_API Self cx_memb(_clone)(Self cx); STC_API void cx_memb(_del)(Self* self); STC_API void cx_memb(_clear)(Self* self); STC_API void cx_memb(_reserve)(Self* self, size_t cap); -STC_API void cx_memb(_resize)(Self* self, size_t size, i_VAL fill_val); +STC_API void cx_memb(_resize)(Self* self, size_t size, i_val fill_val); STC_API int cx_memb(_value_compare)(const cx_value_t* x, const cx_value_t* y); -STC_API cx_iter_t cx_memb(_find_in)(cx_iter_t it1, cx_iter_t it2, i_VALRAW raw); -STC_API cx_iter_t cx_memb(_bsearch_in)(cx_iter_t it1, cx_iter_t it2, i_VALRAW raw); -STC_API void cx_memb(_push_back)(Self* self, i_VAL value); +STC_API cx_iter_t cx_memb(_find_in)(cx_iter_t it1, cx_iter_t it2, i_valraw raw); +STC_API cx_iter_t cx_memb(_bsearch_in)(cx_iter_t it1, cx_iter_t it2, i_valraw raw); +STC_API void cx_memb(_push_back)(Self* self, i_val value); STC_API cx_iter_t cx_memb(_erase_range_p)(Self* self, cx_value_t* p1, cx_value_t* p2); STC_API cx_iter_t cx_memb(_insert_range_p)(Self* self, cx_value_t* pos, const cx_value_t* p1, const cx_value_t* p2, bool clone); @@ -94,18 +94,18 @@ STC_API cx_iter_t cx_memb(_emplace_range_p)(Self* self, cx_value_t* pos, STC_INLINE size_t cx_memb(_size)(Self cx) { return cvec_rep_(&cx)->size; } STC_INLINE size_t cx_memb(_capacity)(Self cx) { return cvec_rep_(&cx)->cap; } STC_INLINE bool cx_memb(_empty)(Self cx) { return !cvec_rep_(&cx)->size; } -STC_INLINE i_VAL cx_memb(_value_fromraw)(i_VALRAW raw) { return i_VALFROM(raw); } -STC_INLINE i_VALRAW cx_memb(_value_toraw)(cx_value_t* val) { return i_VALTO(val); } -STC_INLINE i_VAL cx_memb(_value_clone)(cx_value_t val) - { return i_VALFROM(i_VALTO(&val)); } +STC_INLINE i_val cx_memb(_value_fromraw)(i_valraw raw) { return i_valfrom(raw); } +STC_INLINE i_valraw cx_memb(_value_toraw)(cx_value_t* val) { return i_valto(val); } +STC_INLINE i_val cx_memb(_value_clone)(cx_value_t val) + { return i_valfrom(i_valto(&val)); } STC_INLINE void cx_memb(_swap)(Self* a, Self* b) {c_swap(Self, *a, *b); } STC_INLINE cx_value_t* cx_memb(_front)(const Self* self) { return self->data; } STC_INLINE cx_value_t* cx_memb(_back)(const Self* self) { return self->data + cvec_rep_(self)->size - 1; } -STC_INLINE void cx_memb(_emplace_back)(Self* self, i_VALRAW raw) - { cx_memb(_push_back)(self, i_VALFROM(raw)); } +STC_INLINE void cx_memb(_emplace_back)(Self* self, i_valraw raw) + { cx_memb(_push_back)(self, i_valfrom(raw)); } STC_INLINE void cx_memb(_pop_back)(Self* self) - { i_VALDEL(&self->data[--cvec_rep_(self)->size]); } + { i_valdel(&self->data[--cvec_rep_(self)->size]); } STC_INLINE cx_iter_t cx_memb(_begin)(const Self* self) { return c_make(cx_iter_t){self->data}; } STC_INLINE cx_iter_t cx_memb(_end)(const Self* self) @@ -115,7 +115,7 @@ STC_INLINE cx_iter_t cx_memb(_adv)(cx_iter_t it, intptr_t offs) {it.ref += of STC_INLINE size_t cx_memb(_idx)(Self cx, cx_iter_t it) { return it.ref - cx.data; } STC_INLINE Self -cx_memb(_with_size)(size_t size, i_VAL null_val) { +cx_memb(_with_size)(size_t size, i_val null_val) { Self cx = cx_memb(_init)(); cx_memb(_resize)(&cx, size, null_val); return cx; @@ -135,7 +135,7 @@ cx_memb(_shrink_to_fit)(Self *self) { } STC_INLINE cx_iter_t -cx_memb(_insert)(Self* self, size_t idx, i_VAL value) { +cx_memb(_insert)(Self* self, size_t idx, i_val value) { return cx_memb(_insert_range_p)(self, self->data + idx, &value, &value + 1, false); } STC_INLINE cx_iter_t @@ -143,12 +143,12 @@ cx_memb(_insert_n)(Self* self, size_t idx, const cx_value_t arr[], size_t n) { return cx_memb(_insert_range_p)(self, self->data + idx, arr, arr + n, false); } STC_INLINE cx_iter_t -cx_memb(_insert_at)(Self* self, cx_iter_t it, i_VAL value) { +cx_memb(_insert_at)(Self* self, cx_iter_t it, i_val value) { return cx_memb(_insert_range_p)(self, it.ref, &value, &value + 1, false); } STC_INLINE cx_iter_t -cx_memb(_emplace)(Self* self, size_t idx, i_VALRAW raw) { +cx_memb(_emplace)(Self* self, size_t idx, i_valraw raw) { return cx_memb(_emplace_range_p)(self, self->data + idx, &raw, &raw + 1); } STC_INLINE cx_iter_t @@ -156,7 +156,7 @@ cx_memb(_emplace_n)(Self* self, size_t idx, const cx_rawvalue_t arr[], size_t n) return cx_memb(_emplace_range_p)(self, self->data + idx, arr, arr + n); } STC_INLINE cx_iter_t -cx_memb(_emplace_at)(Self* self, cx_iter_t it, i_VALRAW raw) { +cx_memb(_emplace_at)(Self* self, cx_iter_t it, i_valraw raw) { return cx_memb(_emplace_range_p)(self, it.ref, &raw, &raw + 1); } STC_INLINE cx_iter_t @@ -192,19 +192,19 @@ cx_memb(_at)(const Self* self, size_t idx) { } STC_INLINE cx_iter_t -cx_memb(_find)(const Self* self, i_VALRAW raw) { +cx_memb(_find)(const Self* self, i_valraw raw) { return cx_memb(_find_in)(cx_memb(_begin)(self), cx_memb(_end)(self), raw); } STC_INLINE cx_value_t* -cx_memb(_get)(const Self* self, i_VALRAW raw) { +cx_memb(_get)(const Self* self, i_valraw raw) { cx_iter_t end = cx_memb(_end)(self); cx_value_t* val = cx_memb(_find_in)(cx_memb(_begin)(self), end, raw).ref; return val == end.ref ? NULL : val; } STC_INLINE cx_iter_t -cx_memb(_bsearch)(const Self* self, i_VALRAW raw) { +cx_memb(_bsearch)(const Self* self, i_valraw raw) { return cx_memb(_bsearch_in)(cx_memb(_begin)(self), cx_memb(_end)(self), raw); } STC_INLINE void @@ -219,7 +219,7 @@ cx_memb(_sort)(Self* self) { /* -------------------------- IMPLEMENTATION ------------------------- */ -#if !defined(STC_HEADER) || defined(STC_IMPLEMENTATION) || defined(i_IMP) +#if !defined(STC_HEADER) || defined(STC_IMPLEMENTATION) || defined(i_imp) #ifndef CVEC_H_INCLUDED #define CVEC_H_INCLUDED @@ -236,7 +236,7 @@ STC_DEF void cx_memb(_clear)(Self* self) { struct cvec_Rep_* rep = cvec_rep_(self); if (rep->cap) { for (cx_value_t *p = self->data, *q = p + rep->size; p != q; ++p) - i_VALDEL(p); + i_valdel(p); rep->size = 0; } } @@ -254,7 +254,7 @@ cx_memb(_reserve)(Self* self, size_t cap) { size_t len = rep->size, oldcap = rep->cap; if (cap > oldcap) { rep = (struct cvec_Rep_*) c_realloc(oldcap ? rep : NULL, - offsetof(struct cvec_Rep_, data) + cap*sizeof(i_VAL)); + offsetof(struct cvec_Rep_, data) + cap*sizeof(i_val)); self->data = (cx_value_t*) rep->data; rep->size = len; rep->cap = cap; @@ -262,17 +262,17 @@ cx_memb(_reserve)(Self* self, size_t cap) { } STC_DEF void -cx_memb(_resize)(Self* self, size_t len, i_VAL null_val) { +cx_memb(_resize)(Self* self, size_t len, i_val null_val) { cx_memb(_reserve)(self, len); struct cvec_Rep_* rep = cvec_rep_(self); size_t i, n = rep->size; - for (i = len; i < n; ++i) i_VALDEL(self->data + i); + for (i = len; i < n; ++i) i_valdel(self->data + i); for (i = n; i < len; ++i) self->data[i] = null_val; if (rep->cap) rep->size = len; } STC_DEF void -cx_memb(_push_back)(Self* self, i_VAL value) { +cx_memb(_push_back)(Self* self, i_val value) { size_t len = cvec_rep_(self)->size; if (len == cx_memb(_capacity)(*self)) cx_memb(_reserve)(self, (len*13 >> 3) + 4); @@ -295,7 +295,7 @@ cx_memb(_insert_space_)(Self* self, cx_value_t* pos, size_t len) { cx_memb(_reserve)(self, (size*13 >> 3) + len), pos = self->data + idx; cvec_rep_(self)->size += len; - memmove(pos + len, pos, (size - idx) * sizeof(i_VAL)); + memmove(pos + len, pos, (size - idx) * sizeof(i_val)); return pos; } @@ -304,7 +304,7 @@ cx_memb(_insert_range_p)(Self* self, cx_value_t* pos, const cx_value_t* p1, const cx_value_t* p2, bool clone) { pos = cx_memb(_insert_space_)(self, pos, p2 - p1); cx_iter_t it = {pos}; - if (clone) while (p1 != p2) *pos++ = i_VALFROM(i_VALTO(p1++)); + if (clone) while (p1 != p2) *pos++ = i_valfrom(i_valto(p1++)); else memcpy(pos, p1, (p2 - p1)*sizeof *p1); return it; } @@ -314,7 +314,7 @@ cx_memb(_emplace_range_p)(Self* self, cx_value_t* pos, const cx_rawvalue_t* p1, const cx_rawvalue_t* p2) { pos = cx_memb(_insert_space_)(self, pos, p2 - p1); cx_iter_t it = {pos}; - while (p1 != p2) *pos++ = i_VALFROM(*p1++); + while (p1 != p2) *pos++ = i_valfrom(*p1++); return it; } @@ -323,29 +323,29 @@ cx_memb(_erase_range_p)(Self* self, cx_value_t* p1, cx_value_t* p2) { intptr_t len = p2 - p1; if (len > 0) { cx_value_t* p = p1, *end = self->data + cvec_rep_(self)->size; - while (p != p2) i_VALDEL(p++); - memmove(p1, p2, (end - p2) * sizeof(i_VAL)); + while (p != p2) i_valdel(p++); + memmove(p1, p2, (end - p2) * sizeof(i_val)); cvec_rep_(self)->size -= len; } return c_make(cx_iter_t){.ref = p1}; } STC_DEF cx_iter_t -cx_memb(_find_in)(cx_iter_t i1, cx_iter_t i2, i_VALRAW raw) { +cx_memb(_find_in)(cx_iter_t i1, cx_iter_t i2, i_valraw raw) { for (; i1.ref != i2.ref; ++i1.ref) { - i_VALRAW r = i_VALTO(i1.ref); - if (i_CMP(&raw, &r) == 0) return i1; + i_valraw r = i_valto(i1.ref); + if (i_cmp(&raw, &r) == 0) return i1; } return i2; } STC_DEF cx_iter_t -cx_memb(_bsearch_in)(cx_iter_t i1, cx_iter_t i2, i_VALRAW raw) { +cx_memb(_bsearch_in)(cx_iter_t i1, cx_iter_t i2, i_valraw raw) { cx_iter_t mid, last = i2; while (i1.ref != i2.ref) { mid.ref = i1.ref + ((i2.ref - i1.ref)>>1); - int c; i_VALRAW m = i_VALTO(mid.ref); - if ((c = i_CMP(&raw, &m)) == 0) return mid; + int c; i_valraw m = i_valto(mid.ref); + if ((c = i_cmp(&raw, &m)) == 0) return mid; else if (c < 0) i2.ref = mid.ref; else i1.ref = mid.ref + 1; } @@ -354,9 +354,9 @@ cx_memb(_bsearch_in)(cx_iter_t i1, cx_iter_t i2, i_VALRAW raw) { STC_DEF int cx_memb(_value_compare)(const cx_value_t* x, const cx_value_t* y) { - i_VALRAW rx = i_VALTO(x); - i_VALRAW ry = i_VALTO(y); - return i_CMP(&rx, &ry); + i_valraw rx = i_valto(x); + i_valraw ry = i_valto(y); + return i_cmp(&rx, &ry); } #endif diff --git a/include/stc/template.h b/include/stc/template.h index 0aabed0b..cfa53a5c 100644 --- a/include/stc/template.h +++ b/include/stc/template.h @@ -20,13 +20,13 @@ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ -#ifndef i_TEMPLATE -#define i_TEMPLATE +#ifndef i_template +#define i_template #ifndef STC_TEMPLATE_H_INCLUDED #define STC_TEMPLATE_H_INCLUDED #define cx_memb(name) c_PASTE(Self, name) - #define Self c_PASTE3(i_MODULE, _, i_TAG) + #define Self c_PASTE3(i_module, _, i_tag) // typedef container types defined in forward.h #define cx_deftypes(macro, SELF, ...) macro(SELF, __VA_ARGS__) @@ -41,112 +41,112 @@ #define cx_node_t cx_memb(_node_t) #endif -#if defined f_TAG - #define i_TAG f_TAG - #define i_FWD +#if defined f_tag + #define i_tag f_tag + #define i_fwd #endif -#if defined i_KEY_str - #define i_KEY cstr - #define i_CMP c_rawstr_compare - #define i_EQU c_rawstr_equals - #define i_HASH c_rawstr_hash - #define i_KEYDEL cstr_del - #define i_KEYFROM cstr_from - #define i_KEYTO cstr_str - #define i_KEYRAW const char* +#if defined i_key_str + #define i_key cstr + #define i_cmp c_rawstr_compare + #define i_equ c_rawstr_equals + #define i_hash c_rawstr_hash + #define i_keydel cstr_del + #define i_keyfrom cstr_from + #define i_keyto cstr_str + #define i_keyraw const char* #endif -#if defined i_VAL_str - #define i_VAL cstr - #ifndef i_KEY - #define i_CMP c_rawstr_compare +#if defined i_val_str + #define i_val cstr + #ifndef i_key + #define i_cmp c_rawstr_compare #endif - #define i_VALDEL cstr_del - #define i_VALFROM cstr_from - #define i_VALTO cstr_str - #define i_VALRAW const char* + #define i_valdel cstr_del + #define i_valfrom cstr_from + #define i_valto cstr_str + #define i_valraw const char* #endif -#if defined i_KEY && !defined i_VAL - #define i_VAL i_KEY +#if defined i_key && !defined i_val + #define i_val i_key #endif -#if !defined i_TAG && defined i_KEY_str - #define i_TAG str -#elif !defined i_TAG && defined i_KEY - #define i_TAG i_KEY -#elif !defined i_TAG && defined i_VAL_str - #define i_TAG str -#elif !defined i_TAG && defined i_VAL - #define i_TAG i_VAL +#if !defined i_tag && defined i_key_str + #define i_tag str +#elif !defined i_tag && defined i_key + #define i_tag i_key +#elif !defined i_tag && defined i_val_str + #define i_tag str +#elif !defined i_tag && defined i_val + #define i_tag i_val #endif -#if (defined i_VALTO ^ defined i_VALRAW) || (defined i_VALRAW && !defined i_VALFROM) - #error if i_VALRAW defined, both i_VALFROM and i_VALTO must be defined +#if (defined i_valto ^ defined i_valraw) || (defined i_valraw && !defined i_valfrom) + #error if i_valraw defined, both i_valfrom and i_valto must be defined #endif -#if (defined i_KEYTO ^ defined i_KEYRAW) || (defined i_KEYRAW && !defined i_KEYFROM) - #error if i_KEYRAW defined, both i_KEYFROM and i_KEYTO must be defined +#if (defined i_keyto ^ defined i_keyraw) || (defined i_keyraw && !defined i_keyfrom) + #error if i_keyraw defined, both i_keyfrom and i_keyto must be defined #endif -#if defined i_KEY - #if !defined i_KEYFROM && defined i_KEYDEL - #define i_KEYFROM c_no_clone - #elif !defined i_KEYFROM - #define i_KEYFROM c_default_fromraw +#if defined i_key + #if !defined i_keyfrom && defined i_keydel + #define i_keyfrom c_no_clone + #elif !defined i_keyfrom + #define i_keyfrom c_default_fromraw #endif - #ifndef i_KEYRAW - #define i_KEYRAW i_KEY - #define i_KEYTO c_default_toraw + #ifndef i_keyraw + #define i_keyraw i_key + #define i_keyto c_default_toraw #endif - #if !defined i_EQU && defined i_CMP - #define i_EQU !i_CMP - #elif !defined i_EQU - #define i_EQU c_default_equals + #if !defined i_equ && defined i_cmp + #define i_equ !i_cmp + #elif !defined i_equ + #define i_equ c_default_equals #endif - #ifndef i_HASH - #define i_HASH c_default_hash + #ifndef i_hash + #define i_hash c_default_hash #endif #endif -#if !defined i_VALFROM && defined i_VALDEL - #define i_VALFROM c_no_clone -#elif !defined i_VALFROM - #define i_VALFROM c_default_fromraw +#if !defined i_valfrom && defined i_valdel + #define i_valfrom c_no_clone +#elif !defined i_valfrom + #define i_valfrom c_default_fromraw #endif -#ifndef i_VALRAW - #define i_VALRAW i_VAL - #define i_VALTO c_default_toraw +#ifndef i_valraw + #define i_valraw i_val + #define i_valto c_default_toraw #endif -#ifndef i_KEYDEL - #define i_KEYDEL c_default_del +#ifndef i_keydel + #define i_keydel c_default_del #endif -#ifndef i_VALDEL - #define i_VALDEL c_default_del +#ifndef i_valdel + #define i_valdel c_default_del #endif -#ifndef i_CMP - #define i_CMP c_default_compare +#ifndef i_cmp + #define i_cmp c_default_compare #endif #else // ------------------------------------------------------- -#undef i_MODULE -#undef i_TAG -#undef f_TAG -#undef i_IMP -#undef i_FWD -#undef i_CMP -#undef i_EQU -#undef i_HASH -#undef i_VAL -#undef i_VAL_str -#undef i_VALDEL -#undef i_VALFROM -#undef i_VALTO -#undef i_VALRAW -#undef i_KEY -#undef i_KEY_str -#undef i_KEYDEL -#undef i_KEYFROM -#undef i_KEYTO -#undef i_KEYRAW +#undef i_module +#undef i_tag +#undef f_tag +#undef i_imp +#undef i_fwd +#undef i_cmp +#undef i_equ +#undef i_hash +#undef i_val +#undef i_val_str +#undef i_valdel +#undef i_valfrom +#undef i_valto +#undef i_valraw +#undef i_key +#undef i_key_str +#undef i_keydel +#undef i_keyfrom +#undef i_keyto +#undef i_keyraw -#undef i_TEMPLATE +#undef i_template #endif diff --git a/include/stc/test_new_list.c b/include/stc/test_new_list.c index 83f6107c..764146b3 100644 --- a/include/stc/test_new_list.c +++ b/include/stc/test_new_list.c @@ -10,8 +10,8 @@ struct MyStruct { } typedef MyStruct; -#define f_TAG i32 -#define i_VAL int +#define f_tag i32 +#define i_val int #include "clist.h" struct Point { int x, y; } typedef Point; @@ -19,15 +19,15 @@ int point_compare(const Point* a, const Point* b) { int c = c_default_compare(&a->x, &b->x); return c ? c : c_default_compare(&a->y, &b->y); } -#define f_TAG pnt -#define i_VAL Point -#define i_CMP point_compare +#define f_tag pnt +#define i_val Point +#define i_cmp point_compare #include "clist.h" -#define i_VAL float +#define i_val float #include "clist.h" -#define i_VAL_str +#define i_val_str #include "clist.h" diff --git a/include/stc/test_new_map.c b/include/stc/test_new_map.c index 5dfca14e..b59bd145 100644 --- a/include/stc/test_new_map.c +++ b/include/stc/test_new_map.c @@ -9,8 +9,8 @@ struct MyStruct { } typedef MyStruct; -#define i_KEY int -#define i_VAL int +#define i_key int +#define i_val int #include "cmap.h" struct Point { int x, y; } typedef Point; @@ -18,17 +18,17 @@ int point_compare(const Point* a, const Point* b) { int c = c_default_compare(&a->x, &b->x); return c ? c : c_default_compare(&a->y, &b->y); } -#define f_TAG pnt // f=forward declared -#define i_KEY Point -#define i_VAL int -#define i_CMP point_compare +#define f_tag pnt // f=forward declared +#define i_key Point +#define i_val int +#define i_cmp point_compare #include "cmap.h" -#define i_KEY_str -#define i_VAL_str +#define i_key_str +#define i_val_str #include "cmap.h" -#define i_KEY_str +#define i_key_str #include "cset.h" diff --git a/include/stc/test_new_vec.c b/include/stc/test_new_vec.c index c64f633c..3cc770da 100644 --- a/include/stc/test_new_vec.c +++ b/include/stc/test_new_vec.c @@ -10,8 +10,8 @@ struct MyStruct { } typedef MyStruct; -#define f_TAG i32 -#define i_VAL int +#define f_tag i32 +#define i_val int #include "cvec.h" struct Point { int x, y; } typedef Point; @@ -19,15 +19,15 @@ int point_compare(const Point* a, const Point* b) { int c = c_default_compare(&a->x, &b->x); return c ? c : c_default_compare(&a->y, &b->y); } -#define f_TAG pnt -#define i_VAL Point -#define i_CMP point_compare +#define f_tag pnt +#define i_val Point +#define i_cmp point_compare #include "cvec.h" -#define i_VAL float +#define i_val float #include "cvec.h" -#define i_VAL_str +#define i_val_str #include "cvec.h" -- cgit v1.2.3