From a0899da505475f4f98e67027d13ffc8da155c201 Mon Sep 17 00:00:00 2001 From: Tyge Løvset Date: Fri, 29 Oct 2021 14:39:12 +0200 Subject: renamed cx_..._t to _cx_..._t, and Self to _cx_self --- benchmarks/others/old/clist.h | 252 +++++++++++++++++------------------ benchmarks/others/old/csmap.h | 302 +++++++++++++++++++++--------------------- 2 files changed, 277 insertions(+), 277 deletions(-) (limited to 'benchmarks') diff --git a/benchmarks/others/old/clist.h b/benchmarks/others/old/clist.h index 10d8092e..c10909d3 100644 --- a/benchmarks/others/old/clist.h +++ b/benchmarks/others/old/clist.h @@ -59,153 +59,153 @@ _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 _clist_node(_cx_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(_cx_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(_cx_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(_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 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 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); \ + STC_API _cx_self _cx_memb(_clone)(_cx_self lst); \ + STC_API void _cx_memb(_del)(_cx_self* self); \ + STC_API void _cx_memb(_push_back)(_cx_self* self, i_val value); \ + STC_API void _cx_memb(_push_front)(_cx_self* self, i_val value); \ + STC_API void _cx_memb(_emplace_items)(_cx_self *self, const _cx_rawvalue_t arr[], size_t n); \ + STC_API _cx_self _cx_memb(_split_after)(_cx_self* self, _cx_iter_t pos1, _cx_iter_t pos2); \ + STC_API void _cx_memb(_splice_after)(_cx_self* self, _cx_iter_t pos, _cx_self* other); \ + STC_DEF void _cx_memb(_splice_after_range)(_cx_self* self, _cx_iter_t pos, _cx_self* other, _cx_iter_t i1, _cx_iter_t i2); \ + STC_API _cx_iter_t _cx_memb(_find)(const _cx_self* self, i_valraw val); \ + STC_API _cx_iter_t _cx_memb(_find_before)(const _cx_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)(_cx_self* self); \ + STC_API size_t _cx_memb(_remove)(_cx_self* self, i_valraw val); \ + STC_API _cx_iter_t _cx_memb(_insert_after)(_cx_self* self, _cx_iter_t pos, i_val value); \ + STC_API _cx_iter_t _cx_memb(_erase_after)(_cx_self* self, _cx_iter_t pos); \ + STC_API _cx_iter_t _cx_memb(_erase_range_after)(_cx_self* self, _cx_iter_t pos, _cx_iter_t it2); \ + STC_API _cx_node_t* _cx_memb(_erase_after_)(_cx_self* self, _cx_node_t* node); \ \ - 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 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 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; } \ - STC_INLINE void cx_memb(_pop_front)(Self* self) { cx_memb(_erase_after_)(self, self->last); } \ - STC_INLINE void cx_memb(_splice_front)(Self* self, Self* other) \ - { cx_memb(_splice_after)(self, cx_memb(_before_begin)(self), other); } \ - STC_INLINE void cx_memb(_splice_back)(Self* self, Self* other) \ - { cx_memb(_splice_after)(self, cx_memb(_last)(self), other); } \ + STC_INLINE _cx_self _cx_memb(_init)(void) {_cx_self lst = {NULL}; return lst; } \ + STC_INLINE bool _cx_memb(_empty)(_cx_self lst) { return lst.last == NULL; } \ + STC_INLINE size_t _cx_memb(_count)(_cx_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 void _cx_memb(_clear)(_cx_self* self) { _cx_memb(_del)(self); } \ + STC_INLINE void _cx_memb(_emplace_back)(_cx_self* self, i_valraw raw) \ + { _cx_memb(_push_back)(self, i_valfrom(raw)); } \ + STC_INLINE void _cx_memb(_emplace_front)(_cx_self* self, i_valraw raw) \ + { _cx_memb(_push_front)(self, i_valfrom(raw)); } \ + STC_INLINE _cx_value_t* \ + _cx_memb(_front)(const _cx_self* self) { return &self->last->next->value; } \ + STC_INLINE _cx_value_t* \ + _cx_memb(_back)(const _cx_self* self) { return &self->last->value; } \ + STC_INLINE void _cx_memb(_pop_front)(_cx_self* self) { _cx_memb(_erase_after_)(self, self->last); } \ + STC_INLINE void _cx_memb(_splice_front)(_cx_self* self, _cx_self* other) \ + { _cx_memb(_splice_after)(self, _cx_memb(_before_begin)(self), other); } \ + STC_INLINE void _cx_memb(_splice_back)(_cx_self* self, _cx_self* other) \ + { _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)); \ + STC_INLINE _cx_iter_t \ + _cx_memb(_emplace_after)(_cx_self* self, _cx_iter_t pos, i_valraw raw) { \ + return _cx_memb(_insert_after)(self, pos, i_valfrom(raw)); \ } \ \ - STC_INLINE cx_iter_t \ - cx_memb(_before_begin)(const Self* self) { \ - cx_value_t *last = self->last ? &self->last->value : NULL; \ - cx_iter_t it = {&self->last, last, -1}; return it; \ + STC_INLINE _cx_iter_t \ + _cx_memb(_before_begin)(const _cx_self* self) { \ + _cx_value_t *last = self->last ? &self->last->value : NULL; \ + _cx_iter_t it = {&self->last, last, -1}; return it; \ } \ \ - STC_INLINE cx_iter_t \ - cx_memb(_begin)(const Self* self) { \ - cx_value_t* head = self->last ? &self->last->next->value : NULL; \ - cx_iter_t it = {&self->last, head, 0}; return it; \ + STC_INLINE _cx_iter_t \ + _cx_memb(_begin)(const _cx_self* self) { \ + _cx_value_t* head = self->last ? &self->last->next->value : NULL; \ + _cx_iter_t it = {&self->last, head, 0}; return it; \ } \ \ - STC_INLINE cx_iter_t \ - cx_memb(_last)(const Self* self) { \ - cx_value_t *last = self->last ? &self->last->value : NULL; \ - cx_iter_t it = {&self->last, last, 0}; return it; \ + STC_INLINE _cx_iter_t \ + _cx_memb(_last)(const _cx_self* self) { \ + _cx_value_t *last = self->last ? &self->last->value : NULL; \ + _cx_iter_t it = {&self->last, last, 0}; return it; \ } \ \ - STC_INLINE cx_iter_t \ - cx_memb(_end)(const Self* self) { \ - cx_iter_t it = {NULL, NULL}; return it; \ + STC_INLINE _cx_iter_t \ + _cx_memb(_end)(const _cx_self* self) { \ + _cx_iter_t it = {NULL, NULL}; return it; \ } \ \ STC_INLINE void \ - cx_memb(_next)(cx_iter_t* it) { \ - cx_node_t* node = _clist_node(Self, it->ref); \ + _cx_memb(_next)(_cx_iter_t* it) { \ + _cx_node_t* node = _clist_node(_cx_self, it->ref); \ it->ref = ((it->_state += node == *it->_last) == 1) ? NULL : &node->next->value; \ } \ \ - STC_INLINE cx_iter_t \ - cx_memb(_advance)(cx_iter_t it, size_t n) { \ - while (n-- && it.ref) cx_memb(_next)(&it); return it; \ + STC_INLINE _cx_iter_t \ + _cx_memb(_advance)(_cx_iter_t it, size_t n) { \ + 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(_cx_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(_cx_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)); \ + STC_DEF _cx_self \ + _cx_memb(_clone)(_cx_self lst) { \ + _cx_self out = _cx_memb(_init)(); \ + c_foreach_3 (i, _cx_self, lst) \ + _cx_memb(_emplace_back)(&out, i_valto(i.ref)); \ return out; \ } \ \ STC_DEF void \ - cx_memb(_del)(Self* self) { \ - while (self->last) cx_memb(_erase_after_)(self, self->last); \ + _cx_memb(_del)(_cx_self* self) { \ + while (self->last) _cx_memb(_erase_after_)(self, self->last); \ } \ \ STC_DEF void \ - cx_memb(_push_back)(Self* self, i_val value) { \ - _c_clist_insert_after(self, Self, self->last, value); \ + _cx_memb(_push_back)(_cx_self* self, i_val value) { \ + _c_clist_insert_after(self, _cx_self, self->last, value); \ self->last = entry; \ } \ STC_DEF void \ - cx_memb(_push_front)(Self* self, i_val value) { \ - _c_clist_insert_after(self, Self, self->last, value); \ + _cx_memb(_push_front)(_cx_self* self, i_val value) { \ + _c_clist_insert_after(self, _cx_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; \ pos.ref = &entry->value, pos._state = 0; return pos; \ } \ \ - STC_DEF cx_iter_t \ - cx_memb(_erase_after)(Self* self, cx_iter_t pos) { \ - cx_memb(_erase_after_)(self, _clist_node(Self, pos.ref)); \ - cx_memb(_next)(&pos); return pos; \ + STC_DEF _cx_iter_t \ + _cx_memb(_erase_after)(_cx_self* self, _cx_iter_t pos) { \ + _cx_memb(_erase_after_)(self, _clist_node(_cx_self, pos.ref)); \ + _cx_memb(_next)(&pos); return pos; \ } \ \ - STC_DEF cx_iter_t \ - cx_memb(_erase_range_after)(Self* self, cx_iter_t it1, cx_iter_t it2) { \ - cx_node_t* node = _clist_node(Self, it1.ref), *done = it2.ref ? _clist_node(Self, it2.ref) : NULL; \ + STC_DEF _cx_iter_t \ + _cx_memb(_erase_range_after)(_cx_self* self, _cx_iter_t it1, _cx_iter_t it2) { \ + _cx_node_t* node = _clist_node(_cx_self, it1.ref), *done = it2.ref ? _clist_node(_cx_self, it2.ref) : NULL; \ while (node && node->next != done) \ - node = cx_memb(_erase_after_)(self, node); \ - cx_memb(_next)(&it1); return it1; \ + node = _cx_memb(_erase_after_)(self, node); \ + _cx_memb(_next)(&it1); return it1; \ } \ \ - STC_DEF cx_iter_t \ - 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)) { \ + STC_DEF _cx_iter_t \ + _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; \ it1 = i; \ @@ -213,22 +213,22 @@ STC_API size_t _clist_count(const clist_VOID* self); it1.ref = NULL; return it1; \ } \ \ - STC_DEF cx_iter_t \ - 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); \ + STC_DEF _cx_iter_t \ + _cx_memb(_find_before)(const _cx_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_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); \ + STC_DEF _cx_iter_t \ + _cx_memb(_find)(const _cx_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; \ } \ \ - STC_DEF cx_node_t* \ - cx_memb(_erase_after_)(Self* self, cx_node_t* node) { \ - cx_node_t* del = node->next, *next = del->next; \ + STC_DEF _cx_node_t* \ + _cx_memb(_erase_after_)(_cx_self* self, _cx_node_t* node) { \ + _cx_node_t* del = node->next, *next = del->next; \ node->next = next; \ if (del == next) self->last = node = NULL; \ else if (self->last == del) self->last = node, node = NULL; \ @@ -237,35 +237,35 @@ STC_API size_t _clist_count(const clist_VOID* self); } \ \ STC_DEF size_t \ - cx_memb(_remove)(Self* self, i_valraw val) { \ + _cx_memb(_remove)(_cx_self* self, i_valraw val) { \ size_t n = 0; \ - cx_node_t* prev = self->last, *node; \ + _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) \ - prev = cx_memb(_erase_after_)(self, prev), ++n; \ + prev = _cx_memb(_erase_after_)(self, prev), ++n; \ else \ prev = (node == self->last ? NULL : node); \ } \ return n; \ } \ \ - STC_DEF Self \ - cx_memb(_split_after)(Self* self, cx_iter_t pos1, cx_iter_t pos2) { \ - cx_node_t *node1 = _clist_node(Self, pos1.ref), *next1 = node1->next, \ - *node2 = _clist_node(Self, pos2.ref); \ + STC_DEF _cx_self \ + _cx_memb(_split_after)(_cx_self* self, _cx_iter_t pos1, _cx_iter_t pos2) { \ + _cx_node_t *node1 = _clist_node(_cx_self, pos1.ref), *next1 = node1->next, \ + *node2 = _clist_node(_cx_self, pos2.ref); \ node1->next = node2->next, node2->next = next1; \ if (self->last == node2) self->last = node1; \ - Self lst = {node2}; return lst; \ + _cx_self lst = {node2}; return lst; \ } \ \ STC_DEF void \ - cx_memb(_splice_after)(Self* self, cx_iter_t pos, Self* other) { \ + _cx_memb(_splice_after)(_cx_self* self, _cx_iter_t pos, _cx_self* other) { \ if (!pos.ref) \ self->last = other->last; \ else if (other->last) { \ - cx_node_t *node = _clist_node(Self, pos.ref), *next = node->next; \ + _cx_node_t *node = _clist_node(_cx_self, pos.ref), *next = node->next; \ node->next = other->last->next; \ other->last->next = next; \ if (node == self->last && pos._state == 0) self->last = other->last; \ @@ -274,27 +274,27 @@ STC_API size_t _clist_count(const clist_VOID* self); } \ \ STC_DEF void \ - cx_memb(_splice_after_range)(Self* self, cx_iter_t pos, Self* other, cx_iter_t pos1, cx_iter_t pos2) { \ - Self tmp = cx_memb(_split_after)(other, pos1, pos2); \ - cx_memb(_splice_after)(self, pos, &tmp); \ + _cx_memb(_splice_after_range)(_cx_self* self, _cx_iter_t pos, _cx_self* other, _cx_iter_t pos1, _cx_iter_t pos2) { \ + _cx_self tmp = _cx_memb(_split_after)(other, pos1, pos2); \ + _cx_memb(_splice_after)(self, pos, &tmp); \ } \ \ 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); \ + _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); \ } \ \ STC_DEF void \ - cx_memb(_sort)(Self* self) { \ + _cx_memb(_sort)(_cx_self* self) { \ if (self->last) \ - self->last = (cx_node_t *) _clist_mergesort((clist_VOID_node_t *) self->last->next, cx_memb(_sort_cmp_)); \ + self->last = (_cx_node_t *) _clist_mergesort((clist_VOID_node_t *) self->last->next, _cx_memb(_sort_cmp_)); \ } -#define _c_clist_insert_after(self, Self, node, val) \ - cx_node_t *entry = c_new (cx_node_t); \ +#define _c_clist_insert_after(self, _cx_self, node, val) \ + _cx_node_t *entry = c_new (_cx_node_t); \ if (node) entry->next = node->next, node->next = entry; \ else entry->next = entry; \ entry->value = val @@ -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(_cx_self, i_val, i_cmp, i_valdel, i_valfrom, i_valto, i_valraw) #endif #endif diff --git a/benchmarks/others/old/csmap.h b/benchmarks/others/old/csmap.h index 4a380614..848e6170 100644 --- a/benchmarks/others/old/csmap.h +++ b/benchmarks/others/old/csmap.h @@ -52,71 +52,71 @@ int main(void) { #include #define KEY_REF_csmap_(vp) (&(vp)->first) -#define _c_aatree_complete_types(Self, C) \ - cx_MAP_ONLY( struct cx_value_t { \ - cx_key_t first; \ - cx_mapped_t second; \ +#define _c_aatree_complete_types(_cx_self, C) \ + cx_MAP_ONLY( struct _cx_value_t { \ + _cx_key_t first; \ + _cx_mapped_t second; \ }; ) \ - struct cx_node_t { \ - struct cx_node_t *link[2]; \ + struct _cx_node_t { \ + struct _cx_node_t *link[2]; \ uint8_t level; \ - cx_value_t value; \ + _cx_value_t value; \ } #ifndef cx_forwarded - _c_aatree_types(Self, C, i_key, i_val); + _c_aatree_types(_cx_self, C, i_key, i_val); #endif - _c_aatree_complete_types(Self, C); \ + _c_aatree_complete_types(_cx_self, C); \ \ - 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; \ + 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(_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); \ - STC_API cx_iter_t cx_memb(_erase_range)(Self* self, cx_iter_t it1, cx_iter_t it2); \ - 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 void cx_memb(_next)(cx_iter_t* it); \ + STC_API _cx_self _cx_memb(_init)(void); \ + STC_API _cx_value_t* _cx_memb(_find_it)(const _cx_self* self, i_keyraw rkey, _cx_iter_t* out); \ + STC_API _cx_iter_t _cx_memb(_lower_bound)(const _cx_self* self, i_keyraw rkey); \ + STC_API _cx_value_t* _cx_memb(_front)(const _cx_self* self); \ + STC_API _cx_value_t* _cx_memb(_back)(const _cx_self* self); \ + STC_API _cx_iter_t _cx_memb(_erase_at)(_cx_self* self, _cx_iter_t it); \ + STC_API _cx_iter_t _cx_memb(_erase_range)(_cx_self* self, _cx_iter_t it1, _cx_iter_t it2); \ + 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_)(_cx_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; } \ - STC_INLINE size_t cx_memb(_size)(Self cx) { return cx.size; } \ - STC_INLINE void cx_memb(_del)(Self* self) { cx_memb(_del_r_)(self->root); } \ - 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) \ - {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) \ - {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) \ - {cx_iter_t it; return cx_memb(_find_it)(self, rkey, &it); } \ + STC_INLINE bool _cx_memb(_empty)(_cx_self cx) { return cx.size == 0; } \ + STC_INLINE size_t _cx_memb(_size)(_cx_self cx) { return cx.size; } \ + STC_INLINE void _cx_memb(_del)(_cx_self* self) { _cx_memb(_del_r_)(self->root); } \ + STC_INLINE void _cx_memb(_clear)(_cx_self* self) { _cx_memb(_del)(self); *self = _cx_memb(_init)(); } \ + STC_INLINE void _cx_memb(_swap)(_cx_self* a, _cx_self* b) {c_swap(_cx_self, *a, *b); } \ + STC_INLINE _cx_self _cx_memb(_clone)(_cx_self cx) { return c_make(_cx_self){ _cx_memb(_clone_r_)(cx.root), cx.size}; } \ + STC_INLINE _cx_iter_t _cx_memb(_find)(const _cx_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 _cx_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 _cx_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) { \ + _cx_memb(_value_del)(_cx_value_t* val) { \ 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_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)); ) \ } \ \ - STC_INLINE cx_result_t \ - cx_memb(_emplace)(Self* self, i_keyraw rkey cx_MAP_ONLY(, i_valraw rmapped)) { \ - cx_result_t res = cx_memb(_insert_entry_)(self, rkey); \ + STC_INLINE _cx_result_t \ + _cx_memb(_emplace)(_cx_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);) \ @@ -125,72 +125,72 @@ int main(void) { } \ \ STC_INLINE void \ - cx_memb(_emplace_items)(Self* self, const cx_rawvalue_t arr[], size_t n) { \ - for (size_t i=0; isecond = 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)); \ + STC_INLINE _cx_result_t \ + _cx_memb(_insert_or_assign)(_cx_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); } \ res.ref->second = mapped; return res; \ } \ \ - STC_INLINE cx_result_t \ - 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(_put)(_cx_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_result_t res = cx_memb(_insert_entry_)(self, rkey); \ + STC_INLINE _cx_result_t \ + _cx_memb(_emplace_or_assign)(_cx_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; \ } \ \ - STC_INLINE cx_mapped_t* \ - cx_memb(_at)(const Self* self, i_keyraw rkey) { \ - cx_iter_t it; \ - return &cx_memb(_find_it)(self, rkey, &it)->second; \ + STC_INLINE _cx_mapped_t* \ + _cx_memb(_at)(const _cx_self* self, i_keyraw rkey) { \ + _cx_iter_t it; \ + return &_cx_memb(_find_it)(self, rkey, &it)->second; \ }) \ \ - STC_INLINE cx_iter_t \ - cx_memb(_begin)(const Self* self) { \ - cx_iter_t it = {NULL, 0, self->root}; \ - cx_memb(_next)(&it); return it; \ + STC_INLINE _cx_iter_t \ + _cx_memb(_begin)(const _cx_self* self) { \ + _cx_iter_t it = {NULL, 0, self->root}; \ + _cx_memb(_next)(&it); return it; \ } \ \ - STC_INLINE cx_iter_t \ - cx_memb(_end)(const Self* self) {\ - cx_iter_t it = {NULL}; return it; \ + STC_INLINE _cx_iter_t \ + _cx_memb(_end)(const _cx_self* self) {\ + _cx_iter_t it = {NULL}; return it; \ } \ \ STC_INLINE size_t \ - cx_memb(_erase)(Self* self, i_keyraw rkey) { \ + _cx_memb(_erase)(_cx_self* self, i_keyraw rkey) { \ int erased = 0; \ - self->root = cx_memb(_erase_r_)(self->root, &rkey, &erased); \ + self->root = _cx_memb(_erase_r_)(self->root, &rkey, &erased); \ self->size -= erased; return erased; \ } \ \ - STC_INLINE cx_iter_t \ - cx_memb(_advance)(cx_iter_t it, size_t n) { \ - while (n-- && it.ref) cx_memb(_next)(&it); \ + STC_INLINE _cx_iter_t \ + _cx_memb(_advance)(_cx_iter_t it, size_t n) { \ + while (n-- && it.ref) _cx_memb(_next)(&it); \ return it; \ } \ \ - _c_implement_aatree(Self, C, i_key, i_val, i_cmp, \ + _c_implement_aatree(_cx_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 @@ -203,35 +203,35 @@ _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, \ +#define _c_implement_aatree(_cx_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}; \ + STC_DEF _cx_self \ + _cx_memb(_init)(void) { \ + _cx_self cx = {(_cx_node_t *) &_aatree_sentinel, 0}; \ return cx; \ } \ \ - STC_DEF cx_value_t* \ - cx_memb(_front)(const Self* self) { \ - cx_node_t *tn = self->root; \ + STC_DEF _cx_value_t* \ + _cx_memb(_front)(const _cx_self* self) { \ + _cx_node_t *tn = self->root; \ while (tn->link[0]->level) tn = tn->link[0]; \ return &tn->value; \ } \ \ - STC_DEF cx_value_t* \ - cx_memb(_back)(const Self* self) { \ - cx_node_t *tn = self->root; \ + STC_DEF _cx_value_t* \ + _cx_memb(_back)(const _cx_self* self) { \ + _cx_node_t *tn = self->root; \ while (tn->link[1]->level) tn = tn->link[1]; \ return &tn->value; \ } \ \ - STC_DEF cx_value_t* \ - cx_memb(_find_it)(const Self* self, cx_rawkey_t rkey, cx_iter_t* out) { \ - cx_node_t *tn = self->root; \ + STC_DEF _cx_value_t* \ + _cx_memb(_find_it)(const _cx_self* self, _cx_rawkey_t rkey, _cx_iter_t* out) { \ + _cx_node_t *tn = self->root; \ out->_top = 0; \ while (tn->level) { \ - int c; cx_rawkey_t rx = i_keyto(cx_keyref(&tn->value)); \ + 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); } \ @@ -239,12 +239,12 @@ static csmap_SENTINEL_node_t _aatree_sentinel = {&_aatree_sentinel, &_aatree_sen return (out->ref = NULL); \ } \ \ - STC_DEF cx_iter_t \ - cx_memb(_lower_bound)(const Self* self, i_keyraw rkey) { \ - cx_iter_t it; \ - cx_memb(_find_it)(self, rkey, &it); \ + STC_DEF _cx_iter_t \ + _cx_memb(_lower_bound)(const _cx_self* self, i_keyraw rkey) { \ + _cx_iter_t it; \ + _cx_memb(_find_it)(self, rkey, &it); \ if (!it.ref && it._top) { \ - cx_node_t *tn = it._st[--it._top]; \ + _cx_node_t *tn = it._st[--it._top]; \ it._tn = tn->link[1]; \ it.ref = &tn->value; \ } \ @@ -252,8 +252,8 @@ static csmap_SENTINEL_node_t _aatree_sentinel = {&_aatree_sentinel, &_aatree_sen } \ \ STC_DEF void \ - cx_memb(_next)(cx_iter_t *it) { \ - cx_node_t *tn = it->_tn; \ + _cx_memb(_next)(_cx_iter_t *it) { \ + _cx_node_t *tn = it->_tn; \ if (it->_top || tn->level) { \ while (tn->level) { \ it->_st[it->_top++] = tn; \ @@ -266,10 +266,10 @@ static csmap_SENTINEL_node_t _aatree_sentinel = {&_aatree_sentinel, &_aatree_sen it->ref = NULL; \ } \ \ - static cx_node_t * \ - cx_memb(_skew_)(cx_node_t *tn) { \ + static _cx_node_t * \ + _cx_memb(_skew_)(_cx_node_t *tn) { \ if (tn && tn->link[0]->level == tn->level && tn->level) { \ - cx_node_t *tmp = tn->link[0]; \ + _cx_node_t *tmp = tn->link[0]; \ tn->link[0] = tmp->link[1]; \ tmp->link[1] = tn; \ tn = tmp; \ @@ -277,10 +277,10 @@ static csmap_SENTINEL_node_t _aatree_sentinel = {&_aatree_sentinel, &_aatree_sen return tn; \ } \ \ - static cx_node_t * \ - cx_memb(_split_)(cx_node_t *tn) { \ + static _cx_node_t * \ + _cx_memb(_split_)(_cx_node_t *tn) { \ if (tn->link[1]->link[1]->level == tn->level && tn->level) { \ - cx_node_t *tmp = tn->link[1]; \ + _cx_node_t *tmp = tn->link[1]; \ tn->link[1] = tmp->link[0]; \ tmp->link[0] = tn; \ tn = tmp; \ @@ -289,55 +289,55 @@ static csmap_SENTINEL_node_t _aatree_sentinel = {&_aatree_sentinel, &_aatree_sen return tn; \ } \ \ - static inline cx_node_t* \ - cx_memb(_insert_entry_i_)(cx_node_t* tn, const cx_rawkey_t* rkey, cx_result_t* res) { \ - cx_node_t *up[64], *tx = tn; \ + static inline _cx_node_t* \ + _cx_memb(_insert_entry_i_)(_cx_node_t* tn, const _cx_rawkey_t* rkey, _cx_result_t* res) { \ + _cx_node_t *up[64], *tx = tn; \ int c, top = 0, dir = 0; \ while (tx->level) { \ up[top++] = tx; \ - cx_rawkey_t r = i_keyto(cx_keyref(&tx->value)); \ + _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); \ + tn = c_new(_cx_node_t); \ res->ref = &tn->value, res->inserted = true; \ - tn->link[0] = tn->link[1] = (cx_node_t*) &_aatree_sentinel, tn->level = 1; \ + tn->link[0] = tn->link[1] = (_cx_node_t*) &_aatree_sentinel, tn->level = 1; \ if (top == 0) return tn; \ up[top - 1]->link[dir] = tn; \ while (top--) { \ if (top) dir = (up[top - 1]->link[1] == up[top]); \ - up[top] = cx_memb(_skew_)(up[top]); \ - up[top] = cx_memb(_split_)(up[top]); \ + up[top] = _cx_memb(_skew_)(up[top]); \ + up[top] = _cx_memb(_split_)(up[top]); \ if (top) up[top - 1]->link[dir] = up[top]; \ } \ return up[0]; \ } \ \ - STC_DEF cx_result_t \ - 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); \ + STC_DEF _cx_result_t \ + _cx_memb(_insert_entry_)(_cx_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; \ return res; \ } \ \ - STC_DEF cx_node_t* \ - cx_memb(_erase_r_)(cx_node_t *tn, const cx_rawkey_t* rkey, int *erased) { \ + STC_DEF _cx_node_t* \ + _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); \ + tn->link[c < 0] = _cx_memb(_erase_r_)(tn->link[c < 0], rkey, erased); \ else { \ - if (!*erased) { cx_memb(_value_del)(&tn->value); *erased = 1; } \ + if (!*erased) { _cx_memb(_value_del)(&tn->value); *erased = 1; } \ if (tn->link[0]->level && tn->link[1]->level) { \ tx = tn->link[0]; \ while (tx->link[1]->level) \ tx = tx->link[1]; \ tn->value = tx->value; \ raw = i_keyto(cx_keyref(&tn->value)); \ - tn->link[0] = cx_memb(_erase_r_)(tn->link[0], &raw, erased); \ + tn->link[0] = _cx_memb(_erase_r_)(tn->link[0], &raw, erased); \ } else { \ tx = tn; \ tn = tn->link[tn->link[0]->level == 0]; \ @@ -347,55 +347,55 @@ static csmap_SENTINEL_node_t _aatree_sentinel = {&_aatree_sentinel, &_aatree_sen if (tn->link[0]->level < tn->level - 1 || tn->link[1]->level < tn->level - 1) { \ if (tn->link[1]->level > --tn->level) \ tn->link[1]->level = tn->level; \ - tn = cx_memb(_skew_)(tn); \ - tx = tn->link[0] = cx_memb(_skew_)(tn->link[0]); \ - tx->link[0] = cx_memb(_skew_)(tx->link[0]); \ - tn = cx_memb(_split_)(tn); \ - tn->link[0] = cx_memb(_split_)(tn->link[0]); \ + tn = _cx_memb(_skew_)(tn); \ + tx = tn->link[0] = _cx_memb(_skew_)(tn->link[0]); \ + tx->link[0] = _cx_memb(_skew_)(tx->link[0]); \ + tn = _cx_memb(_split_)(tn); \ + tn->link[0] = _cx_memb(_split_)(tn->link[0]); \ } \ return tn; \ } \ - 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_memb(_next)(&it); \ + STC_DEF _cx_iter_t \ + _cx_memb(_erase_at)(_cx_self* self, _cx_iter_t it) { \ + _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)); \ - cx_memb(_erase)(self, raw); \ - if (it.ref) cx_memb(_find_it)(self, nxt, &it); \ + _cx_memb(_erase)(self, raw); \ + if (it.ref) _cx_memb(_find_it)(self, nxt, &it); \ return it; \ } \ \ - STC_DEF cx_iter_t \ - cx_memb(_erase_range)(Self* self, cx_iter_t it1, cx_iter_t it2) { \ - if (!it2.ref) { while (it1.ref) it1 = cx_memb(_erase_at)(self, it1); \ + STC_DEF _cx_iter_t \ + _cx_memb(_erase_range)(_cx_self* self, _cx_iter_t it1, _cx_iter_t it2) { \ + 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_key_t k1 = *cx_keyref(it1.ref), k2 = *cx_keyref(it2.ref); \ + _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(_next)(&it1); k1 = *cx_keyref(it1.ref); \ + _cx_memb(_erase)(self, r1); \ + _cx_memb(_find_it)(self, (r1 = i_keyto(&k1)), &it1); \ } \ } \ \ - STC_DEF cx_node_t* \ - cx_memb(_clone_r_)(cx_node_t *tn) { \ + STC_DEF _cx_node_t* \ + _cx_memb(_clone_r_)(_cx_node_t *tn) { \ if (! tn->level) return tn; \ - cx_node_t *cn = c_new(cx_node_t); \ - cn->link[0] = cx_memb(_clone_r_)(tn->link[0]); \ - cn->link[1] = cx_memb(_clone_r_)(tn->link[1]); \ + _cx_node_t *cn = c_new(_cx_node_t); \ + cn->link[0] = _cx_memb(_clone_r_)(tn->link[0]); \ + cn->link[1] = _cx_memb(_clone_r_)(tn->link[1]); \ cn->level = tn->level; \ - cx_memb(_value_clone)(&cn->value, &tn->value); \ + _cx_memb(_value_clone)(&cn->value, &tn->value); \ return cn; \ } \ \ STC_DEF void \ - cx_memb(_del_r_)(cx_node_t* tn) { \ + _cx_memb(_del_r_)(_cx_node_t* tn) { \ if (tn->level != 0) { \ - cx_memb(_del_r_)(tn->link[0]); \ - cx_memb(_del_r_)(tn->link[1]); \ - cx_memb(_value_del)(&tn->value); \ + _cx_memb(_del_r_)(tn->link[0]); \ + _cx_memb(_del_r_)(tn->link[1]); \ + _cx_memb(_value_del)(&tn->value); \ c_free(tn); \ } \ } -- cgit v1.2.3