From 7fa0eafd2c141368c0b554eef8ff8e57539db9b9 Mon Sep 17 00:00:00 2001 From: Leonardo Vencovsky Date: Tue, 26 May 2020 14:00:45 -0300 Subject: [PATCH] A lot of changes Changed include guards Removed struct cmc_flags, now using enum Token concatenation now uses CMC_ Every concatenation with SNAME now uses a special macro (this allows customization) Deleted some no longer needed test files Deleted some very old implementations of dev and sac collections --- src/cmc/bitset.h | 384 ++--- src/cmc/deque.h | 532 ++++--- src/cmc/hashbidimap.h | 918 ++++++------ src/cmc/hashmap.h | 2079 +++++++++++++------------- src/cmc/hashmultimap.h | 2582 +++++++++++++++++---------------- src/cmc/hashmultiset.h | 740 +++++----- src/cmc/hashset.h | 818 ++++++----- src/cmc/heap.h | 468 +++--- src/cmc/intervalheap.h | 527 +++---- src/cmc/linkedlist.h | 702 ++++----- src/cmc/list.h | 614 ++++---- src/cmc/queue.h | 461 +++--- src/cmc/sortedlist.h | 553 +++---- src/cmc/stack.h | 445 +++--- src/cmc/treemap.h | 517 +++---- src/cmc/treeset.h | 818 ++++++----- src/cor/alloc.h | 3 +- src/cor/core.h | 32 +- src/cor/flags.h | 28 +- src/dev/deque.h | 654 --------- src/ext/cmc/deque.h | 24 +- src/ext/cmc/hashbidimap.h | 0 src/ext/cmc/hashmap.h | 114 +- src/sac/queue.h | 357 ----- src/sac/stack.h | 327 ----- src/utl/assert.h | 6 +- src/utl/foreach.h | 22 +- src/utl/futils.h | 6 +- src/utl/log.h | 6 +- src/utl/mutex.h | 50 +- src/utl/test.h | 6 +- src/utl/thread.h | 32 +- src/utl/timer.h | 6 +- tests/contains.c | 260 ---- tests/foreach.c | 286 ---- tests/iterators.c | 139 -- tests/main/src/bitset.c | 36 +- tests/main/src/deque.c | 83 +- tests/main/src/hashbidimap.c | 102 +- tests/main/src/hashmap.c | 110 +- tests/main/src/hashmultimap.c | 96 +- tests/main/src/hashmultiset.c | 69 +- tests/main/src/hashset.c | 82 +- tests/main/src/heap.c | 42 +- tests/main/src/intervalheap.c | 65 +- tests/main/src/linkedlist.c | 84 +- tests/main/src/list.c | 102 +- tests/main/src/queue.c | 43 +- tests/main/src/sortedlist.c | 56 +- tests/main/src/stack.c | 42 +- tests/main/src/treemap.c | 65 +- tests/main/src/treeset.c | 47 +- tests/main/unt/bitset.c | 20 +- tests/main/unt/deque.c | 258 ++-- tests/main/unt/hashbidimap.c | 114 +- tests/main/unt/hashmap.c | 208 +-- tests/main/unt/hashmultimap.c | 98 +- tests/main/unt/hashmultiset.c | 88 +- tests/main/unt/hashset.c | 44 +- tests/main/unt/heap.c | 36 +- tests/main/unt/intervalheap.c | 90 +- tests/main/unt/linkedlist.c | 112 +- tests/main/unt/list.c | 122 +- tests/main/unt/queue.c | 44 +- tests/main/unt/sortedlist.c | 66 +- tests/main/unt/stack.c | 44 +- tests/main/unt/treemap.c | 68 +- tests/main/unt/treeset.c | 48 +- 68 files changed, 8188 insertions(+), 9912 deletions(-) delete mode 100644 src/dev/deque.h create mode 100644 src/ext/cmc/hashbidimap.h delete mode 100644 src/sac/queue.h delete mode 100644 src/sac/stack.h delete mode 100644 tests/contains.c delete mode 100644 tests/foreach.c delete mode 100644 tests/iterators.c diff --git a/src/cmc/bitset.h b/src/cmc/bitset.h index a4369ac..4045633 100644 --- a/src/cmc/bitset.h +++ b/src/cmc/bitset.h @@ -28,8 +28,8 @@ * as there is enough memory. */ -#ifndef CMC_BITSET_H -#define CMC_BITSET_H +#ifndef CMC_CMC_BITSET_H +#define CMC_CMC_BITSET_H /* ------------------------------------------------------------------------- * Core functionalities of the C Macro Collections Library @@ -45,135 +45,143 @@ * BitSet specific * ------------------------------------------------------------------------- */ /* to_string format */ -static const char *cmc_string_fmt_bitset = "struct %s " - "at %p { " - "buffer:%p, " - "capacity:%" PRIuMAX ", " - "flag:%d, " - "alloc:%p, " - "callbacks:%p }"; +static const char *cmc_cmc_string_fmt_bitset = "struct %s " + "at %p { " + "buffer:%p, " + "capacity:%" PRIuMAX ", " + "flag:%d, " + "alloc:%p, " + "callbacks:%p }"; -#define CMC_GENERATE_BITSET(PFX, SNAME) \ - CMC_GENERATE_BITSET_HEADER(PFX, SNAME) \ - CMC_GENERATE_BITSET_SOURCE(PFX, SNAME) +/** + * Core BitSet implementation + */ +#define CMC_CMC_BITSET_CORE(BODY) \ + CMC_CMC_BITSET_CORE_HEADER(BODY) \ + CMC_CMC_BITSET_CORE_SOURCE(BODY) -#define CMC_WRAPGEN_BITSET_HEADER(PFX, SNAME, K, V) \ - CMC_GENERATE_BITSET_HEADER(PFX, SNAME) +#define CMC_CMC_BITSET_CORE_HEADER(BODY) \ + CMC_CMC_BITSET_CORE_HEADER_(CMC_PARAM_PFX(BODY), CMC_PARAM_SNAME(BODY)) -#define CMC_WRAPGEN_BITSET_SOURCE(PFX, SNAME, K, V) \ - CMC_GENERATE_BITSET_SOURCE(PFX, SNAME) +#define CMC_CMC_BITSET_CORE_SOURCE(BODY) \ + CMC_CMC_BITSET_CORE_SOURCE_(CMC_PARAM_PFX(BODY), CMC_PARAM_SNAME(BODY)) /* ------------------------------------------------------------------------- * Header * ------------------------------------------------------------------------- */ -#define CMC_GENERATE_BITSET_HEADER(PFX, SNAME) \ - \ - /* BitSet Structure */ \ - struct SNAME \ - { \ - /* Dynamic Array of Bits */ \ - cmc_bitset_word *buffer; \ - \ - /* Current array capacity */ \ - size_t capacity; \ - \ - /* Flags indicating errors or success */ \ - int flag; \ - \ - /* Custom allocation functions */ \ - struct cmc_alloc_node *alloc; \ - \ - /* Custom callback functions */ \ - struct cmc_callbacks *callbacks; \ - }; \ - \ - /* BitSet Iterator */ \ - struct SNAME##_iter \ - { \ - /* Target bitset */ \ - struct SNAME *target; \ - \ - /* Cursor's position (index) */ \ - cmc_bitset_word cursor; \ - \ - /* If the iterator has reached the start of the iteration */ \ - bool start; \ - \ - /* If the iterator has reached the end of the iteration */ \ - bool end; \ - }; \ - \ - /* Collection Functions */ \ - /* Collection Allocation and Deallocation */ \ - struct SNAME *PFX##_new(size_t n_bits); \ - struct SNAME *PFX##_new_custom(size_t n_bits, \ - struct cmc_alloc_node *alloc, \ - struct cmc_callbacks *callbacks); \ - struct SNAME PFX##_init(size_t n_bits); \ - struct SNAME PFX##_init_custom(size_t n_bits, \ - struct cmc_alloc_node *alloc, \ - struct cmc_callbacks *callbacks); \ - void PFX##_free(struct SNAME *_bitset_); \ - void PFX##_release(struct SNAME _bitset_); \ - void PFX##_customize(struct SNAME *_bitset_, struct cmc_alloc_node *alloc, \ - struct cmc_callbacks *callbacks); \ - /* Collection Input and Output */ \ - bool PFX##_set(struct SNAME *_bitset_, size_t bit_index); \ - bool PFX##_set_range(struct SNAME *_bitset_, size_t from, size_t to); \ - bool PFX##_clear(struct SNAME *_bitset_, size_t bit_index); \ - bool PFX##_clear_range(struct SNAME *_bitset_, size_t from, size_t to); \ - bool PFX##_flip(struct SNAME *_bitset_, size_t bit_index); \ - bool PFX##_flip_range(struct SNAME *_bitset_, size_t from, size_t to); \ - bool PFX##_put(struct SNAME *_bitset_, size_t bit_index, bool state); \ - bool PFX##_put_range(struct SNAME *_bitset_, size_t from, size_t to, \ - bool state); \ - bool PFX##_set_all(struct SNAME *_bitset_); \ - bool PFX##_clear_all(struct SNAME *_bitset_); \ - bool PFX##_flip_all(struct SNAME *_bitset_); \ - /* Element Access */ \ - bool PFX##_get(struct SNAME *_bitset_, size_t bit_index); \ - /* Collection State */ \ - /* Collection Utility */ \ - bool PFX##_resize(struct SNAME *_bitset_, size_t n_bits); \ - \ - /* Iterator Functions */ \ - /* Iterator Initialization */ \ - /* Iterator State */ \ - /* Iterator Movement */ \ - /* Iterator Access */ \ - \ - /* Utility Methods */ \ - /* Translates a bit index to a word index */ \ - static inline size_t PFX##_bit_to_index(size_t idx) \ - { \ - /* Calculate how many shifts based on the size of cmc_bitset_word */ \ - static const size_t shift = \ - ((sizeof(cmc_bitset_word) * 8) >> 6) > 0 \ - ? 6 \ - : ((sizeof(cmc_bitset_word) * 8) >> 5) > 0 \ - ? 5 \ - : ((sizeof(cmc_bitset_word) * 8) >> 4) > 0 ? 4 : 3; \ - \ - return idx >> shift; \ +#define CMC_CMC_BITSET_CORE_HEADER_(PFX, SNAME) \ + \ + /* BitSet Structure */ \ + struct SNAME \ + { \ + /* Dynamic Array of Bits */ \ + cmc_bitset_word *buffer; \ + \ + /* Current array capacity */ \ + size_t capacity; \ + \ + /* Flags indicating errors or success */ \ + int flag; \ + \ + /* Custom allocation functions */ \ + struct cmc_alloc_node *alloc; \ + \ + /* Custom callback functions */ \ + struct cmc_callbacks *callbacks; \ + }; \ + \ + /* BitSet Iterator */ \ + struct CMC_DEF_ITER(SNAME) \ + { \ + /* Target bitset */ \ + struct SNAME *target; \ + \ + /* Cursor's position (index) */ \ + cmc_bitset_word cursor; \ + \ + /* If the iterator has reached the start of the iteration */ \ + bool start; \ + \ + /* If the iterator has reached the end of the iteration */ \ + bool end; \ + }; \ + \ + /* Collection Functions */ \ + /* Collection Allocation and Deallocation */ \ + struct SNAME *CMC_(PFX, _new)(size_t n_bits); \ + struct SNAME *CMC_(PFX, _new_custom)(size_t n_bits, \ + struct cmc_alloc_node * alloc, \ + struct cmc_callbacks * callbacks); \ + struct SNAME CMC_(PFX, _init)(size_t n_bits); \ + struct SNAME CMC_(PFX, _init_custom)(size_t n_bits, \ + struct cmc_alloc_node * alloc, \ + struct cmc_callbacks * callbacks); \ + void CMC_(PFX, _free)(struct SNAME * _bitset_); \ + void CMC_(PFX, _release)(struct SNAME _bitset_); \ + void CMC_(PFX, _customize)(struct SNAME * _bitset_, \ + struct cmc_alloc_node * alloc, \ + struct cmc_callbacks * callbacks); \ + /* Collection Input and Output */ \ + bool CMC_(PFX, _set)(struct SNAME * _bitset_, size_t bit_index); \ + bool CMC_(PFX, _set_range)(struct SNAME * _bitset_, size_t from, \ + size_t to); \ + bool CMC_(PFX, _clear)(struct SNAME * _bitset_, size_t bit_index); \ + bool CMC_(PFX, _clear_range)(struct SNAME * _bitset_, size_t from, \ + size_t to); \ + bool CMC_(PFX, _flip)(struct SNAME * _bitset_, size_t bit_index); \ + bool CMC_(PFX, _flip_range)(struct SNAME * _bitset_, size_t from, \ + size_t to); \ + bool CMC_(PFX, _put)(struct SNAME * _bitset_, size_t bit_index, \ + bool state); \ + bool CMC_(PFX, _put_range)(struct SNAME * _bitset_, size_t from, \ + size_t to, bool state); \ + bool CMC_(PFX, _set_all)(struct SNAME * _bitset_); \ + bool CMC_(PFX, _clear_all)(struct SNAME * _bitset_); \ + bool CMC_(PFX, _flip_all)(struct SNAME * _bitset_); \ + /* Element Access */ \ + bool CMC_(PFX, _get)(struct SNAME * _bitset_, size_t bit_index); \ + /* Collection State */ \ + /* Collection Utility */ \ + bool CMC_(PFX, _resize)(struct SNAME * _bitset_, size_t n_bits); \ + \ + /* Iterator Functions */ \ + /* Iterator Initialization */ \ + /* Iterator State */ \ + /* Iterator Movement */ \ + /* Iterator Access */ \ + \ + /* Utility Methods */ \ + /* Translates a bit index to a word index */ \ + static inline size_t CMC_(PFX, _bit_to_index)(size_t idx) \ + { \ + /* Calculate how many shifts based on the size of cmc_bitset_word */ \ + static const size_t shift = \ + ((sizeof(cmc_bitset_word) * 8) >> 6) > 0 \ + ? 6 \ + : ((sizeof(cmc_bitset_word) * 8) >> 5) > 0 \ + ? 5 \ + : ((sizeof(cmc_bitset_word) * 8) >> 4) > 0 ? 4 : 3; \ + \ + return idx >> shift; \ } /* ------------------------------------------------------------------------- * Source * ------------------------------------------------------------------------- */ -#define CMC_GENERATE_BITSET_SOURCE(PFX, SNAME) \ +#define CMC_CMC_BITSET_CORE_SOURCE_(PFX, SNAME) \ \ /* Implementation Detail Functions */ \ - bool PFX##_impl_resize(struct SNAME *_bitset_, size_t n_bits, \ - bool do_resize); \ + bool CMC_(PFX, _impl_resize)(struct SNAME * _bitset_, size_t n_bits, \ + bool do_resize); \ \ - struct SNAME *PFX##_new(size_t n_bits) \ + struct SNAME *CMC_(PFX, _new)(size_t n_bits) \ { \ - return PFX##_new_custom(n_bits, NULL, NULL); \ + return CMC_(PFX, _new_custom)(n_bits, NULL, NULL); \ } \ \ - struct SNAME *PFX##_new_custom(size_t n_bits, \ - struct cmc_alloc_node *alloc, \ - struct cmc_callbacks *callbacks) \ + struct SNAME *CMC_(PFX, _new_custom)(size_t n_bits, \ + struct cmc_alloc_node * alloc, \ + struct cmc_callbacks * callbacks) \ { \ if (n_bits < 1) \ return NULL; \ @@ -181,7 +189,7 @@ static const char *cmc_string_fmt_bitset = "struct %s " if (!alloc) \ alloc = &cmc_alloc_node_default; \ \ - size_t capacity = PFX##_bit_to_index(n_bits - 1) + 1; \ + size_t capacity = CMC_(PFX, _bit_to_index)(n_bits - 1) + 1; \ \ struct SNAME *_bitset_ = alloc->malloc(sizeof(struct SNAME)); \ \ @@ -197,21 +205,21 @@ static const char *cmc_string_fmt_bitset = "struct %s " } \ \ _bitset_->capacity = capacity; \ - _bitset_->flag = cmc_flags.OK; \ + _bitset_->flag = CMC_FLAG_OK; \ _bitset_->alloc = alloc; \ _bitset_->callbacks = callbacks; \ \ return _bitset_; \ } \ \ - struct SNAME PFX##_init(size_t n_bits) \ + struct SNAME CMC_(PFX, _init)(size_t n_bits) \ { \ - return PFX##_init_custom(n_bits, NULL, NULL); \ + return CMC_(PFX, _init_custom)(n_bits, NULL, NULL); \ } \ \ - struct SNAME PFX##_init_custom(size_t n_bits, \ - struct cmc_alloc_node *alloc, \ - struct cmc_callbacks *callbacks) \ + struct SNAME CMC_(PFX, _init_custom)(size_t n_bits, \ + struct cmc_alloc_node * alloc, \ + struct cmc_callbacks * callbacks) \ { \ struct SNAME _bitset_ = { 0 }; \ \ @@ -221,7 +229,7 @@ static const char *cmc_string_fmt_bitset = "struct %s " if (!alloc) \ alloc = &cmc_alloc_node_default; \ \ - size_t capacity = PFX##_bit_to_index(n_bits - 1) + 1; \ + size_t capacity = CMC_(PFX, _bit_to_index)(n_bits - 1) + 1; \ \ _bitset_.buffer = alloc->calloc(capacity, sizeof(cmc_bitset_word)); \ \ @@ -229,26 +237,27 @@ static const char *cmc_string_fmt_bitset = "struct %s " return _bitset_; \ \ _bitset_.capacity = capacity; \ - _bitset_.flag = cmc_flags.OK; \ + _bitset_.flag = CMC_FLAG_OK; \ _bitset_.alloc = alloc; \ _bitset_.callbacks = callbacks; \ \ return _bitset_; \ } \ \ - void PFX##_free(struct SNAME *_bitset_) \ + void CMC_(PFX, _free)(struct SNAME * _bitset_) \ { \ free(_bitset_->buffer); \ free(_bitset_); \ } \ \ - void PFX##_release(struct SNAME _bitset_) \ + void CMC_(PFX, _release)(struct SNAME _bitset_) \ { \ free(_bitset_.buffer); \ } \ \ - void PFX##_customize(struct SNAME *_bitset_, struct cmc_alloc_node *alloc, \ - struct cmc_callbacks *callbacks) \ + void CMC_(PFX, _customize)(struct SNAME * _bitset_, \ + struct cmc_alloc_node * alloc, \ + struct cmc_callbacks * callbacks) \ { \ if (!alloc) \ _bitset_->alloc = &cmc_alloc_node_default; \ @@ -257,22 +266,22 @@ static const char *cmc_string_fmt_bitset = "struct %s " \ _bitset_->callbacks = callbacks; \ \ - _bitset_->flag = cmc_flags.OK; \ + _bitset_->flag = CMC_FLAG_OK; \ } \ \ - bool PFX##_set(struct SNAME *_bitset_, size_t bit_index) \ + bool CMC_(PFX, _set)(struct SNAME * _bitset_, size_t bit_index) \ { \ - if (!PFX##_impl_resize(_bitset_, bit_index + 1, false)) \ + if (!CMC_(PFX, _impl_resize)(_bitset_, bit_index + 1, false)) \ return false; \ \ /* How many bits in a word */ \ const cmc_bitset_word bits = sizeof(cmc_bitset_word) * CHAR_BIT; \ \ - size_t i = PFX##_bit_to_index(bit_index); \ + size_t i = CMC_(PFX, _bit_to_index)(bit_index); \ \ _bitset_->buffer[i] |= ((cmc_bitset_word)1) << (bit_index % bits); \ \ - _bitset_->flag = cmc_flags.OK; \ + _bitset_->flag = CMC_FLAG_OK; \ \ if (_bitset_->callbacks && _bitset_->callbacks->create) \ _bitset_->callbacks->create(); \ @@ -280,19 +289,20 @@ static const char *cmc_string_fmt_bitset = "struct %s " return true; \ } \ \ - bool PFX##_set_range(struct SNAME *_bitset_, size_t from, size_t to) \ + bool CMC_(PFX, _set_range)(struct SNAME * _bitset_, size_t from, \ + size_t to) \ { \ if (to < from) \ { \ - _bitset_->flag = cmc_flags.INVALID; \ + _bitset_->flag = CMC_FLAG_INVALID; \ return false; \ } \ \ - if (!PFX##_impl_resize(_bitset_, to + 1, false)) \ + if (!CMC_(PFX, _impl_resize)(_bitset_, to + 1, false)) \ return false; \ \ - size_t start_index = PFX##_bit_to_index(from); \ - size_t end_index = PFX##_bit_to_index(to); \ + size_t start_index = CMC_(PFX, _bit_to_index)(from); \ + size_t end_index = CMC_(PFX, _bit_to_index)(to); \ \ /* How many bits in a word */ \ const cmc_bitset_word bits = sizeof(cmc_bitset_word) * CHAR_BIT; \ @@ -320,7 +330,7 @@ static const char *cmc_string_fmt_bitset = "struct %s " _bitset_->buffer[end_index] |= end_mask; \ } \ \ - _bitset_->flag = cmc_flags.OK; \ + _bitset_->flag = CMC_FLAG_OK; \ \ if (_bitset_->callbacks && _bitset_->callbacks->create) \ _bitset_->callbacks->create(); \ @@ -328,19 +338,19 @@ static const char *cmc_string_fmt_bitset = "struct %s " return true; \ } \ \ - bool PFX##_clear(struct SNAME *_bitset_, size_t bit_index) \ + bool CMC_(PFX, _clear)(struct SNAME * _bitset_, size_t bit_index) \ { \ - if (!PFX##_impl_resize(_bitset_, bit_index + 1, false)) \ + if (!CMC_(PFX, _impl_resize)(_bitset_, bit_index + 1, false)) \ return false; \ \ /* How many bits in a word */ \ const cmc_bitset_word bits = sizeof(cmc_bitset_word) * CHAR_BIT; \ \ - size_t i = PFX##_bit_to_index(bit_index); \ + size_t i = CMC_(PFX, _bit_to_index)(bit_index); \ \ _bitset_->buffer[i] &= ~(((cmc_bitset_word)1) << (bit_index % bits)); \ \ - _bitset_->flag = cmc_flags.OK; \ + _bitset_->flag = CMC_FLAG_OK; \ \ if (_bitset_->callbacks && _bitset_->callbacks->delete) \ _bitset_->callbacks->delete (); \ @@ -348,19 +358,20 @@ static const char *cmc_string_fmt_bitset = "struct %s " return true; \ } \ \ - bool PFX##_clear_range(struct SNAME *_bitset_, size_t from, size_t to) \ + bool CMC_(PFX, _clear_range)(struct SNAME * _bitset_, size_t from, \ + size_t to) \ { \ if (to < from) \ { \ - _bitset_->flag = cmc_flags.INVALID; \ + _bitset_->flag = CMC_FLAG_INVALID; \ return false; \ } \ \ - if (!PFX##_impl_resize(_bitset_, to + 1, false)) \ + if (!CMC_(PFX, _impl_resize)(_bitset_, to + 1, false)) \ return false; \ \ - size_t start_index = PFX##_bit_to_index(from); \ - size_t end_index = PFX##_bit_to_index(to); \ + size_t start_index = CMC_(PFX, _bit_to_index)(from); \ + size_t end_index = CMC_(PFX, _bit_to_index)(to); \ \ /* How many bits in a word */ \ const cmc_bitset_word bits = sizeof(cmc_bitset_word) * CHAR_BIT; \ @@ -388,7 +399,7 @@ static const char *cmc_string_fmt_bitset = "struct %s " _bitset_->buffer[end_index] &= ~end_mask; \ } \ \ - _bitset_->flag = cmc_flags.OK; \ + _bitset_->flag = CMC_FLAG_OK; \ \ if (_bitset_->callbacks && _bitset_->callbacks->delete) \ _bitset_->callbacks->delete (); \ @@ -396,19 +407,19 @@ static const char *cmc_string_fmt_bitset = "struct %s " return true; \ } \ \ - bool PFX##_flip(struct SNAME *_bitset_, size_t bit_index) \ + bool CMC_(PFX, _flip)(struct SNAME * _bitset_, size_t bit_index) \ { \ - if (!PFX##_impl_resize(_bitset_, bit_index + 1, false)) \ + if (!CMC_(PFX, _impl_resize)(_bitset_, bit_index + 1, false)) \ return false; \ \ /* How many bits in a word */ \ const cmc_bitset_word bits = sizeof(cmc_bitset_word) * CHAR_BIT; \ \ - size_t i = PFX##_bit_to_index(bit_index); \ + size_t i = CMC_(PFX, _bit_to_index)(bit_index); \ \ _bitset_->buffer[i] ^= ((cmc_bitset_word)1) << (bit_index % bits); \ \ - _bitset_->flag = cmc_flags.OK; \ + _bitset_->flag = CMC_FLAG_OK; \ \ if (_bitset_->callbacks && _bitset_->callbacks->update) \ _bitset_->callbacks->update(); \ @@ -416,19 +427,20 @@ static const char *cmc_string_fmt_bitset = "struct %s " return true; \ } \ \ - bool PFX##_flip_range(struct SNAME *_bitset_, size_t from, size_t to) \ + bool CMC_(PFX, _flip_range)(struct SNAME * _bitset_, size_t from, \ + size_t to) \ { \ if (to < from) \ { \ - _bitset_->flag = cmc_flags.INVALID; \ + _bitset_->flag = CMC_FLAG_INVALID; \ return false; \ } \ \ - if (!PFX##_impl_resize(_bitset_, to + 1, false)) \ + if (!CMC_(PFX, _impl_resize)(_bitset_, to + 1, false)) \ return false; \ \ - size_t start_index = PFX##_bit_to_index(from); \ - size_t end_index = PFX##_bit_to_index(to); \ + size_t start_index = CMC_(PFX, _bit_to_index)(from); \ + size_t end_index = CMC_(PFX, _bit_to_index)(to); \ \ /* How many bits in a word */ \ const cmc_bitset_word bits = sizeof(cmc_bitset_word) * CHAR_BIT; \ @@ -456,7 +468,7 @@ static const char *cmc_string_fmt_bitset = "struct %s " _bitset_->buffer[end_index] ^= end_mask; \ } \ \ - _bitset_->flag = cmc_flags.OK; \ + _bitset_->flag = CMC_FLAG_OK; \ \ if (_bitset_->callbacks && _bitset_->callbacks->update) \ _bitset_->callbacks->update(); \ @@ -464,29 +476,30 @@ static const char *cmc_string_fmt_bitset = "struct %s " return true; \ } \ \ - bool PFX##_put(struct SNAME *_bitset_, size_t bit_index, bool state) \ - { \ - if (state) \ - return PFX##_set(_bitset_, bit_index); \ - else \ - return PFX##_clear(_bitset_, bit_index); \ - } \ - \ - bool PFX##_put_range(struct SNAME *_bitset_, size_t from, size_t to, \ + bool CMC_(PFX, _put)(struct SNAME * _bitset_, size_t bit_index, \ bool state) \ { \ if (state) \ - return PFX##_set_range(_bitset_, from, to); \ + return CMC_(PFX, _set)(_bitset_, bit_index); \ else \ - return PFX##_clear_range(_bitset_, from, to); \ + return CMC_(PFX, _clear)(_bitset_, bit_index); \ } \ \ - bool PFX##_set_all(struct SNAME *_bitset_) \ + bool CMC_(PFX, _put_range)(struct SNAME * _bitset_, size_t from, \ + size_t to, bool state) \ + { \ + if (state) \ + return CMC_(PFX, _set_range)(_bitset_, from, to); \ + else \ + return CMC_(PFX, _clear_range)(_bitset_, from, to); \ + } \ + \ + bool CMC_(PFX, _set_all)(struct SNAME * _bitset_) \ { \ for (size_t i = 0; i < _bitset_->capacity; i++) \ _bitset_->buffer[i] = ~((cmc_bitset_word)0); \ \ - _bitset_->flag = cmc_flags.OK; \ + _bitset_->flag = CMC_FLAG_OK; \ \ if (_bitset_->callbacks && _bitset_->callbacks->create) \ _bitset_->callbacks->create(); \ @@ -494,12 +507,12 @@ static const char *cmc_string_fmt_bitset = "struct %s " return true; \ } \ \ - bool PFX##_clear_all(struct SNAME *_bitset_) \ + bool CMC_(PFX, _clear_all)(struct SNAME * _bitset_) \ { \ for (size_t i = 0; i < _bitset_->capacity; i++) \ _bitset_->buffer[i] = 0; \ \ - _bitset_->flag = cmc_flags.OK; \ + _bitset_->flag = CMC_FLAG_OK; \ \ if (_bitset_->callbacks && _bitset_->callbacks->delete) \ _bitset_->callbacks->delete (); \ @@ -507,12 +520,12 @@ static const char *cmc_string_fmt_bitset = "struct %s " return true; \ } \ \ - bool PFX##_flip_all(struct SNAME *_bitset_) \ + bool CMC_(PFX, _flip_all)(struct SNAME * _bitset_) \ { \ for (size_t i = 0; i < _bitset_->capacity; i++) \ _bitset_->buffer[i] ^= ~((cmc_bitset_word)0); \ \ - _bitset_->flag = cmc_flags.OK; \ + _bitset_->flag = CMC_FLAG_OK; \ \ if (_bitset_->callbacks && _bitset_->callbacks->create) \ _bitset_->callbacks->create(); \ @@ -520,35 +533,36 @@ static const char *cmc_string_fmt_bitset = "struct %s " return true; \ } \ \ - bool PFX##_get(struct SNAME *_bitset_, size_t bit_index) \ + bool CMC_(PFX, _get)(struct SNAME * _bitset_, size_t bit_index) \ { \ /* How many bits in a word */ \ const cmc_bitset_word bits = sizeof(cmc_bitset_word) * CHAR_BIT; \ \ - cmc_bitset_word w = _bitset_->buffer[PFX##_bit_to_index(bit_index)]; \ + cmc_bitset_word w = \ + _bitset_->buffer[CMC_(PFX, _bit_to_index)(bit_index)]; \ \ return w & ((cmc_bitset_word)1 << (bit_index % bits)); \ } \ \ - bool PFX##_resize(struct SNAME *_bitset_, size_t n_bits) \ + bool CMC_(PFX, _resize)(struct SNAME * _bitset_, size_t n_bits) \ { \ - return PFX##_impl_resize(_bitset_, n_bits, true); \ + return CMC_(PFX, _impl_resize)(_bitset_, n_bits, true); \ } \ \ /* When do_resize is false, then we just want to assure that the bitset */ \ /* can accommodate n_bits */ \ - bool PFX##_impl_resize(struct SNAME *_bitset_, size_t n_bits, \ - bool do_resize) \ + bool CMC_(PFX, _impl_resize)(struct SNAME * _bitset_, size_t n_bits, \ + bool do_resize) \ { \ if (n_bits == 0) \ { \ - _bitset_->flag = cmc_flags.INVALID; \ + _bitset_->flag = CMC_FLAG_INVALID; \ return false; \ } \ \ /* -1 because n_bits is 1-based and we need to pass a 0-based index */ \ /* +1 to have a 1-based result */ \ - size_t words = PFX##_bit_to_index(n_bits - 1) + 1; \ + size_t words = CMC_(PFX, _bit_to_index)(n_bits - 1) + 1; \ \ /* Be sure we are not always shrinking when we just want to make */ \ /* sure that we have enough size for n_bits */ \ @@ -560,7 +574,7 @@ static const char *cmc_string_fmt_bitset = "struct %s " \ if (!new_buffer) \ { \ - _bitset_->flag = cmc_flags.ALLOC; \ + _bitset_->flag = CMC_FLAG_ALLOC; \ return false; \ } \ \ @@ -576,9 +590,9 @@ static const char *cmc_string_fmt_bitset = "struct %s " if (_bitset_->callbacks && _bitset_->callbacks->resize) \ _bitset_->callbacks->resize(); \ \ - _bitset_->flag = cmc_flags.OK; \ + _bitset_->flag = CMC_FLAG_OK; \ \ return true; \ } -#endif /* CMC_BITSET_H */ +#endif /* CMC_CMC_BITSET_H */ diff --git a/src/cmc/deque.h b/src/cmc/deque.h index bea757e..5b6dffa 100644 --- a/src/cmc/deque.h +++ b/src/cmc/deque.h @@ -28,8 +28,8 @@ * would take O(N) due to the need to shift all elements in the deque. */ -#ifndef CMC_DEQUE_H -#define CMC_DEQUE_H +#ifndef CMC_CMC_DEQUE_H +#define CMC_CMC_DEQUE_H /* ------------------------------------------------------------------------- * Core functionalities of the C Macro Collections Library @@ -40,177 +40,184 @@ * Deque Specific * ------------------------------------------------------------------------- */ /* to_string format */ -static const char *cmc_string_fmt_deque = "struct %s<%s> " - "at %p { " - "buffer:%p, " - "capacity:%" PRIuMAX ", " - "count:%" PRIuMAX ", " - "front:%" PRIuMAX ", " - "back:%" PRIuMAX ", " - "flag:%d, " - "f_val:%p, " - "alloc:%p, " - "callbacks:%p }"; +static const char *cmc_cmc_string_fmt_deque = "struct %s<%s> " + "at %p { " + "buffer:%p, " + "capacity:%" PRIuMAX ", " + "count:%" PRIuMAX ", " + "front:%" PRIuMAX ", " + "back:%" PRIuMAX ", " + "flag:%d, " + "f_val:%p, " + "alloc:%p, " + "callbacks:%p }"; -#define CMC_GENERATE_DEQUE(PFX, SNAME, V) \ - CMC_GENERATE_DEQUE_HEADER(PFX, SNAME, V) \ - CMC_GENERATE_DEQUE_SOURCE(PFX, SNAME, V) +/** + * Core Deque implementation + */ +#define CMC_CMC_DEQUE_CORE(BODY) \ + CMC_CMC_DEQUE_CORE_HEADER(BODY) \ + CMC_CMC_DEQUE_CORE_SOURCE(BODY) -#define CMC_WRAPGEN_DEQUE_HEADER(PFX, SNAME, K, V) \ - CMC_GENERATE_DEQUE_HEADER(PFX, SNAME, V) +#define CMC_CMC_DEQUE_CORE_HEADER(BODY) \ + CMC_CMC_DEQUE_CORE_HEADER_(CMC_PARAM_PFX(BODY), CMC_PARAM_SNAME(BODY), \ + CMC_PARAM_V(BODY)) -#define CMC_WRAPGEN_DEQUE_SOURCE(PFX, SNAME, K, V) \ - CMC_GENERATE_DEQUE_SOURCE(PFX, SNAME, V) +#define CMC_CMC_DEQUE_CORE_SOURCE(BODY) \ + CMC_CMC_DEQUE_CORE_SOURCE_(CMC_PARAM_PFX(BODY), CMC_PARAM_SNAME(BODY), \ + CMC_PARAM_V(BODY)) /* ------------------------------------------------------------------------- * Header * ------------------------------------------------------------------------- */ -#define CMC_GENERATE_DEQUE_HEADER(PFX, SNAME, V) \ - \ - /* Deque Structure */ \ - struct SNAME \ - { \ - /* Dynamic circular array of elements */ \ - V *buffer; \ - \ - /* Current circular array capacity */ \ - size_t capacity; \ - \ - /* Current amount of elements */ \ - size_t count; \ - \ - /* Index representing the front of the deque */ \ - size_t front; \ - \ - /* Index representing the back of the deque */ \ - size_t back; \ - \ - /* Flags indicating errors or success */ \ - int flag; \ - \ - struct SNAME##_fval *f_val; \ - \ - /* Custom allocation functions */ \ - struct cmc_alloc_node *alloc; \ - \ - /* Custom callback functions */ \ - struct cmc_callbacks *callbacks; \ - }; \ - \ - struct SNAME##_fval \ - { \ - /* Comparator function */ \ - int (*cmp)(V, V); \ - \ - /* Copy function */ \ - V (*cpy)(V); \ - \ - /* To string function */ \ - bool (*str)(FILE *, V); \ - \ - /* Free from memory function */ \ - void (*free)(V); \ - \ - /* Hash function */ \ - size_t (*hash)(V); \ - \ - /* Priority function */ \ - int (*pri)(V, V); \ - }; \ - \ - /* Deque Iterator */ \ - struct SNAME##_iter \ - { \ - /* Target deque */ \ - struct SNAME *target; \ - \ - /* Cursor's position (index) */ \ - size_t cursor; \ - \ - /* Keeps track of relative index to the iteration of elements */ \ - size_t index; \ - \ - /* If the iterator has reached the start of the iteration */ \ - bool start; \ - \ - /* If the iterator has reached the end of the iteration */ \ - bool end; \ - }; \ - \ - /* Collection Functions */ \ - /* Collection Allocation and Deallocation */ \ - struct SNAME *PFX##_new(size_t capacity, struct SNAME##_fval *f_val); \ - struct SNAME *PFX##_new_custom( \ - size_t capacity, struct SNAME##_fval *f_val, \ - struct cmc_alloc_node *alloc, struct cmc_callbacks *callbacks); \ - struct SNAME PFX##_init(size_t capacity, struct SNAME##_fval *f_val); \ - struct SNAME PFX##_init_custom( \ - size_t capacity, struct SNAME##_fval *f_val, \ - struct cmc_alloc_node *alloc, struct cmc_callbacks *callbacks); \ - void PFX##_clear(struct SNAME *_deque_); \ - void PFX##_free(struct SNAME *_deque_); \ - void PFX##_release(struct SNAME _deque_); \ - /* Customization of Allocation and Callbacks */ \ - void PFX##_customize(struct SNAME *_deque_, struct cmc_alloc_node *alloc, \ - struct cmc_callbacks *callbacks); \ - /* Collection Input and Output */ \ - bool PFX##_push_front(struct SNAME *_deque_, V value); \ - bool PFX##_push_back(struct SNAME *_deque_, V value); \ - bool PFX##_pop_front(struct SNAME *_deque_); \ - bool PFX##_pop_back(struct SNAME *_deque_); \ - /* Element Access */ \ - V PFX##_front(struct SNAME *_deque_); \ - V PFX##_back(struct SNAME *_deque_); \ - /* Collection State */ \ - bool PFX##_contains(struct SNAME *_deque_, V value); \ - bool PFX##_empty(struct SNAME *_deque_); \ - bool PFX##_full(struct SNAME *_deque_); \ - size_t PFX##_count(struct SNAME *_deque_); \ - size_t PFX##_capacity(struct SNAME *_deque_); \ - int PFX##_flag(struct SNAME *_deque_); \ - /* Collection Utility */ \ - bool PFX##_resize(struct SNAME *_deque_, size_t capacity); \ - struct SNAME *PFX##_copy_of(struct SNAME *_deque_); \ - bool PFX##_equals(struct SNAME *_deque1_, struct SNAME *_deque2_); \ - struct cmc_string PFX##_to_string(struct SNAME *_deque_); \ - bool PFX##_print(struct SNAME *_deque_, FILE *fptr); \ - \ - /* Iterator Functions */ \ - /* Iterator Initialization */ \ - struct SNAME##_iter PFX##_iter_start(struct SNAME *target); \ - struct SNAME##_iter PFX##_iter_end(struct SNAME *target); \ - /* Iterator State */ \ - bool PFX##_iter_at_start(struct SNAME##_iter *iter); \ - bool PFX##_iter_at_end(struct SNAME##_iter *iter); \ - /* Iterator Movement */ \ - bool PFX##_iter_to_start(struct SNAME##_iter *iter); \ - bool PFX##_iter_to_end(struct SNAME##_iter *iter); \ - bool PFX##_iter_next(struct SNAME##_iter *iter); \ - bool PFX##_iter_prev(struct SNAME##_iter *iter); \ - bool PFX##_iter_advance(struct SNAME##_iter *iter, size_t steps); \ - bool PFX##_iter_rewind(struct SNAME##_iter *iter, size_t steps); \ - bool PFX##_iter_go_to(struct SNAME##_iter *iter, size_t index); \ - /* Iterator Access */ \ - V PFX##_iter_value(struct SNAME##_iter *iter); \ - V *PFX##_iter_rvalue(struct SNAME##_iter *iter); \ - size_t PFX##_iter_index(struct SNAME##_iter *iter); +#define CMC_CMC_DEQUE_CORE_HEADER_(PFX, SNAME, V) \ + \ + /* Deque Structure */ \ + struct SNAME \ + { \ + /* Dynamic circular array of elements */ \ + V *buffer; \ + \ + /* Current circular array capacity */ \ + size_t capacity; \ + \ + /* Current amount of elements */ \ + size_t count; \ + \ + /* Index representing the front of the deque */ \ + size_t front; \ + \ + /* Index representing the back of the deque */ \ + size_t back; \ + \ + /* Flags indicating errors or success */ \ + int flag; \ + \ + struct CMC_DEF_FVAL(SNAME) * f_val; \ + \ + /* Custom allocation functions */ \ + struct cmc_alloc_node *alloc; \ + \ + /* Custom callback functions */ \ + struct cmc_callbacks *callbacks; \ + }; \ + \ + struct CMC_DEF_FVAL(SNAME) \ + { \ + /* Comparator function */ \ + int (*cmp)(V, V); \ + \ + /* Copy function */ \ + V (*cpy)(V); \ + \ + /* To string function */ \ + bool (*str)(FILE *, V); \ + \ + /* Free from memory function */ \ + void (*free)(V); \ + \ + /* Hash function */ \ + size_t (*hash)(V); \ + \ + /* Priority function */ \ + int (*pri)(V, V); \ + }; \ + \ + /* Deque Iterator */ \ + struct CMC_DEF_ITER(SNAME) \ + { \ + /* Target deque */ \ + struct SNAME *target; \ + \ + /* Cursor's position (index) */ \ + size_t cursor; \ + \ + /* Keeps track of relative index to the iteration of elements */ \ + size_t index; \ + \ + /* If the iterator has reached the start of the iteration */ \ + bool start; \ + \ + /* If the iterator has reached the end of the iteration */ \ + bool end; \ + }; \ + \ + /* Collection Functions */ \ + /* Collection Allocation and Deallocation */ \ + struct SNAME *CMC_(PFX, _new)(size_t capacity, \ + struct CMC_DEF_FVAL(SNAME) * f_val); \ + struct SNAME *CMC_(PFX, _new_custom)( \ + size_t capacity, struct CMC_DEF_FVAL(SNAME) * f_val, \ + struct cmc_alloc_node * alloc, struct cmc_callbacks * callbacks); \ + void CMC_(PFX, _clear)(struct SNAME * _deque_); \ + void CMC_(PFX, _free)(struct SNAME * _deque_); \ + void CMC_(PFX, _release)(struct SNAME _deque_); \ + /* Customization of Allocation and Callbacks */ \ + void CMC_(PFX, _customize)(struct SNAME * _deque_, \ + struct cmc_alloc_node * alloc, \ + struct cmc_callbacks * callbacks); \ + /* Collection Input and Output */ \ + bool CMC_(PFX, _push_front)(struct SNAME * _deque_, V value); \ + bool CMC_(PFX, _push_back)(struct SNAME * _deque_, V value); \ + bool CMC_(PFX, _pop_front)(struct SNAME * _deque_); \ + bool CMC_(PFX, _pop_back)(struct SNAME * _deque_); \ + /* Element Access */ \ + V CMC_(PFX, _front)(struct SNAME * _deque_); \ + V CMC_(PFX, _back)(struct SNAME * _deque_); \ + /* Collection State */ \ + bool CMC_(PFX, _contains)(struct SNAME * _deque_, V value); \ + bool CMC_(PFX, _empty)(struct SNAME * _deque_); \ + bool CMC_(PFX, _full)(struct SNAME * _deque_); \ + size_t CMC_(PFX, _count)(struct SNAME * _deque_); \ + size_t CMC_(PFX, _capacity)(struct SNAME * _deque_); \ + int CMC_(PFX, _flag)(struct SNAME * _deque_); \ + /* Collection Utility */ \ + bool CMC_(PFX, _resize)(struct SNAME * _deque_, size_t capacity); \ + struct SNAME *CMC_(PFX, _copy_of)(struct SNAME * _deque_); \ + bool CMC_(PFX, _equals)(struct SNAME * _deque1_, struct SNAME * _deque2_); \ + struct cmc_string CMC_(PFX, _to_string)(struct SNAME * _deque_); \ + bool CMC_(PFX, _print)(struct SNAME * _deque_, FILE * fptr); \ + \ + /* Iterator Functions */ \ + /* Iterator Initialization */ \ + struct CMC_DEF_ITER(SNAME) CMC_(PFX, _iter_start)(struct SNAME * target); \ + struct CMC_DEF_ITER(SNAME) CMC_(PFX, _iter_end)(struct SNAME * target); \ + /* Iterator State */ \ + bool CMC_(PFX, _iter_at_start)(struct CMC_DEF_ITER(SNAME) * iter); \ + bool CMC_(PFX, _iter_at_end)(struct CMC_DEF_ITER(SNAME) * iter); \ + /* Iterator Movement */ \ + bool CMC_(PFX, _iter_to_start)(struct CMC_DEF_ITER(SNAME) * iter); \ + bool CMC_(PFX, _iter_to_end)(struct CMC_DEF_ITER(SNAME) * iter); \ + bool CMC_(PFX, _iter_next)(struct CMC_DEF_ITER(SNAME) * iter); \ + bool CMC_(PFX, _iter_prev)(struct CMC_DEF_ITER(SNAME) * iter); \ + bool CMC_(PFX, _iter_advance)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t steps); \ + bool CMC_(PFX, _iter_rewind)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t steps); \ + bool CMC_(PFX, _iter_go_to)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t index); \ + /* Iterator Access */ \ + V CMC_(PFX, _iter_value)(struct CMC_DEF_ITER(SNAME) * iter); \ + V *CMC_(PFX, _iter_rvalue)(struct CMC_DEF_ITER(SNAME) * iter); \ + size_t CMC_(PFX, _iter_index)(struct CMC_DEF_ITER(SNAME) * iter); /* ------------------------------------------------------------------------- * Source * ------------------------------------------------------------------------- */ -#define CMC_GENERATE_DEQUE_SOURCE(PFX, SNAME, V) \ +#define CMC_CMC_DEQUE_CORE_SOURCE_(PFX, SNAME, V) \ \ /* Implementation Detail Functions */ \ /* None */ \ \ - struct SNAME *PFX##_new(size_t capacity, struct SNAME##_fval *f_val) \ + struct SNAME *CMC_(PFX, _new)(size_t capacity, \ + struct CMC_DEF_FVAL(SNAME) * f_val) \ { \ - return PFX##_new_custom(capacity, f_val, NULL, NULL); \ + return CMC_(PFX, _new_custom)(capacity, f_val, NULL, NULL); \ } \ \ - struct SNAME *PFX##_new_custom( \ - size_t capacity, struct SNAME##_fval *f_val, \ - struct cmc_alloc_node *alloc, struct cmc_callbacks *callbacks) \ + struct SNAME *CMC_(PFX, _new_custom)( \ + size_t capacity, struct CMC_DEF_FVAL(SNAME) * f_val, \ + struct cmc_alloc_node * alloc, struct cmc_callbacks * callbacks) \ { \ if (capacity < 1) \ return NULL; \ @@ -238,7 +245,7 @@ static const char *cmc_string_fmt_deque = "struct %s<%s> " _deque_->count = 0; \ _deque_->front = 0; \ _deque_->back = 0; \ - _deque_->flag = cmc_flags.OK; \ + _deque_->flag = CMC_FLAG_OK; \ _deque_->f_val = f_val; \ _deque_->alloc = alloc; \ _deque_->callbacks = callbacks; \ @@ -246,44 +253,7 @@ static const char *cmc_string_fmt_deque = "struct %s<%s> " return _deque_; \ } \ \ - struct SNAME PFX##_init(size_t capacity, struct SNAME##_fval *f_val) \ - { \ - return PFX##_init_custom(capacity, f_val, NULL, NULL); \ - } \ - \ - struct SNAME PFX##_init_custom( \ - size_t capacity, struct SNAME##_fval *f_val, \ - struct cmc_alloc_node *alloc, struct cmc_callbacks *callbacks) \ - { \ - struct SNAME _deque_ = { 0 }; \ - \ - if (capacity < 1) \ - return _deque_; \ - \ - if (!f_val) \ - return _deque_; \ - \ - if (!alloc) \ - alloc = &cmc_alloc_node_default; \ - \ - _deque_.buffer = alloc->calloc(capacity, sizeof(V)); \ - \ - if (!_deque_.buffer) \ - return _deque_; \ - \ - _deque_.capacity = capacity; \ - _deque_.count = 0; \ - _deque_.front = 0; \ - _deque_.back = 0; \ - _deque_.flag = cmc_flags.OK; \ - _deque_.f_val = f_val; \ - _deque_.alloc = alloc; \ - _deque_.callbacks = callbacks; \ - \ - return _deque_; \ - } \ - \ - void PFX##_clear(struct SNAME *_deque_) \ + void CMC_(PFX, _clear)(struct SNAME * _deque_) \ { \ if (_deque_->f_val->free) \ { \ @@ -301,10 +271,10 @@ static const char *cmc_string_fmt_deque = "struct %s<%s> " _deque_->front = 0; \ _deque_->back = 0; \ \ - _deque_->flag = cmc_flags.OK; \ + _deque_->flag = CMC_FLAG_OK; \ } \ \ - void PFX##_free(struct SNAME *_deque_) \ + void CMC_(PFX, _free)(struct SNAME * _deque_) \ { \ if (_deque_->f_val->free) \ { \ @@ -320,7 +290,7 @@ static const char *cmc_string_fmt_deque = "struct %s<%s> " _deque_->alloc->free(_deque_); \ } \ \ - void PFX##_release(struct SNAME _deque_) \ + void CMC_(PFX, _release)(struct SNAME _deque_) \ { \ if (_deque_.f_val->free) \ { \ @@ -335,8 +305,9 @@ static const char *cmc_string_fmt_deque = "struct %s<%s> " _deque_.alloc->free(_deque_.buffer); \ } \ \ - void PFX##_customize(struct SNAME *_deque_, struct cmc_alloc_node *alloc, \ - struct cmc_callbacks *callbacks) \ + void CMC_(PFX, _customize)(struct SNAME * _deque_, \ + struct cmc_alloc_node * alloc, \ + struct cmc_callbacks * callbacks) \ { \ if (!alloc) \ _deque_->alloc = &cmc_alloc_node_default; \ @@ -345,14 +316,14 @@ static const char *cmc_string_fmt_deque = "struct %s<%s> " \ _deque_->callbacks = callbacks; \ \ - _deque_->flag = cmc_flags.OK; \ + _deque_->flag = CMC_FLAG_OK; \ } \ \ - bool PFX##_push_front(struct SNAME *_deque_, V value) \ + bool CMC_(PFX, _push_front)(struct SNAME * _deque_, V value) \ { \ - if (PFX##_full(_deque_)) \ + if (CMC_(PFX, _full)(_deque_)) \ { \ - if (!PFX##_resize(_deque_, _deque_->capacity * 2)) \ + if (!CMC_(PFX, _resize)(_deque_, _deque_->capacity * 2)) \ return false; \ } \ \ @@ -362,7 +333,7 @@ static const char *cmc_string_fmt_deque = "struct %s<%s> " _deque_->buffer[_deque_->front] = value; \ \ _deque_->count++; \ - _deque_->flag = cmc_flags.OK; \ + _deque_->flag = CMC_FLAG_OK; \ \ if (_deque_->callbacks && _deque_->callbacks->create) \ _deque_->callbacks->create(); \ @@ -370,11 +341,11 @@ static const char *cmc_string_fmt_deque = "struct %s<%s> " return true; \ } \ \ - bool PFX##_push_back(struct SNAME *_deque_, V value) \ + bool CMC_(PFX, _push_back)(struct SNAME * _deque_, V value) \ { \ - if (PFX##_full(_deque_)) \ + if (CMC_(PFX, _full)(_deque_)) \ { \ - if (!PFX##_resize(_deque_, _deque_->capacity * 2)) \ + if (!CMC_(PFX, _resize)(_deque_, _deque_->capacity * 2)) \ return false; \ } \ \ @@ -384,7 +355,7 @@ static const char *cmc_string_fmt_deque = "struct %s<%s> " (_deque_->back == _deque_->capacity - 1) ? 0 : _deque_->back + 1; \ \ _deque_->count++; \ - _deque_->flag = cmc_flags.OK; \ + _deque_->flag = CMC_FLAG_OK; \ \ if (_deque_->callbacks && _deque_->callbacks->create) \ _deque_->callbacks->create(); \ @@ -392,11 +363,11 @@ static const char *cmc_string_fmt_deque = "struct %s<%s> " return true; \ } \ \ - bool PFX##_pop_front(struct SNAME *_deque_) \ + bool CMC_(PFX, _pop_front)(struct SNAME * _deque_) \ { \ - if (PFX##_empty(_deque_)) \ + if (CMC_(PFX, _empty)(_deque_)) \ { \ - _deque_->flag = cmc_flags.EMPTY; \ + _deque_->flag = CMC_FLAG_EMPTY; \ return false; \ } \ \ @@ -407,7 +378,7 @@ static const char *cmc_string_fmt_deque = "struct %s<%s> " : _deque_->front + 1; \ \ _deque_->count--; \ - _deque_->flag = cmc_flags.OK; \ + _deque_->flag = CMC_FLAG_OK; \ \ if (_deque_->callbacks && _deque_->callbacks->delete) \ _deque_->callbacks->delete (); \ @@ -415,11 +386,11 @@ static const char *cmc_string_fmt_deque = "struct %s<%s> " return true; \ } \ \ - bool PFX##_pop_back(struct SNAME *_deque_) \ + bool CMC_(PFX, _pop_back)(struct SNAME * _deque_) \ { \ - if (PFX##_empty(_deque_)) \ + if (CMC_(PFX, _empty)(_deque_)) \ { \ - _deque_->flag = cmc_flags.EMPTY; \ + _deque_->flag = CMC_FLAG_EMPTY; \ return false; \ } \ \ @@ -429,7 +400,7 @@ static const char *cmc_string_fmt_deque = "struct %s<%s> " _deque_->buffer[_deque_->back] = (V){ 0 }; \ \ _deque_->count--; \ - _deque_->flag = cmc_flags.OK; \ + _deque_->flag = CMC_FLAG_OK; \ \ if (_deque_->callbacks && _deque_->callbacks->delete) \ _deque_->callbacks->delete (); \ @@ -437,15 +408,15 @@ static const char *cmc_string_fmt_deque = "struct %s<%s> " return true; \ } \ \ - V PFX##_front(struct SNAME *_deque_) \ + V CMC_(PFX, _front)(struct SNAME * _deque_) \ { \ - if (PFX##_empty(_deque_)) \ + if (CMC_(PFX, _empty)(_deque_)) \ { \ - _deque_->flag = cmc_flags.EMPTY; \ + _deque_->flag = CMC_FLAG_EMPTY; \ return (V){ 0 }; \ } \ \ - _deque_->flag = cmc_flags.OK; \ + _deque_->flag = CMC_FLAG_OK; \ \ if (_deque_->callbacks && _deque_->callbacks->read) \ _deque_->callbacks->read(); \ @@ -453,15 +424,15 @@ static const char *cmc_string_fmt_deque = "struct %s<%s> " return _deque_->buffer[_deque_->front]; \ } \ \ - V PFX##_back(struct SNAME *_deque_) \ + V CMC_(PFX, _back)(struct SNAME * _deque_) \ { \ - if (PFX##_empty(_deque_)) \ + if (CMC_(PFX, _empty)(_deque_)) \ { \ - _deque_->flag = cmc_flags.EMPTY; \ + _deque_->flag = CMC_FLAG_EMPTY; \ return (V){ 0 }; \ } \ \ - _deque_->flag = cmc_flags.OK; \ + _deque_->flag = CMC_FLAG_OK; \ \ if (_deque_->callbacks && _deque_->callbacks->read) \ _deque_->callbacks->read(); \ @@ -470,9 +441,9 @@ static const char *cmc_string_fmt_deque = "struct %s<%s> " : _deque_->back - 1]; \ } \ \ - bool PFX##_contains(struct SNAME *_deque_, V value) \ + bool CMC_(PFX, _contains)(struct SNAME * _deque_, V value) \ { \ - _deque_->flag = cmc_flags.OK; \ + _deque_->flag = CMC_FLAG_OK; \ \ bool result = false; \ \ @@ -493,41 +464,41 @@ static const char *cmc_string_fmt_deque = "struct %s<%s> " return result; \ } \ \ - bool PFX##_empty(struct SNAME *_deque_) \ + bool CMC_(PFX, _empty)(struct SNAME * _deque_) \ { \ return _deque_->count == 0; \ } \ \ - bool PFX##_full(struct SNAME *_deque_) \ + bool CMC_(PFX, _full)(struct SNAME * _deque_) \ { \ return _deque_->count >= _deque_->capacity; \ } \ \ - size_t PFX##_count(struct SNAME *_deque_) \ + size_t CMC_(PFX, _count)(struct SNAME * _deque_) \ { \ return _deque_->count; \ } \ \ - size_t PFX##_capacity(struct SNAME *_deque_) \ + size_t CMC_(PFX, _capacity)(struct SNAME * _deque_) \ { \ return _deque_->capacity; \ } \ \ - int PFX##_flag(struct SNAME *_deque_) \ + int CMC_(PFX, _flag)(struct SNAME * _deque_) \ { \ return _deque_->flag; \ } \ \ - bool PFX##_resize(struct SNAME *_deque_, size_t capacity) \ + bool CMC_(PFX, _resize)(struct SNAME * _deque_, size_t capacity) \ { \ - _deque_->flag = cmc_flags.OK; \ + _deque_->flag = CMC_FLAG_OK; \ \ if (_deque_->capacity == capacity) \ goto success; \ \ if (capacity < _deque_->count) \ { \ - _deque_->flag = cmc_flags.INVALID; \ + _deque_->flag = CMC_FLAG_INVALID; \ return false; \ } \ \ @@ -535,7 +506,7 @@ static const char *cmc_string_fmt_deque = "struct %s<%s> " \ if (!new_buffer) \ { \ - _deque_->flag = cmc_flags.ALLOC; \ + _deque_->flag = CMC_FLAG_ALLOC; \ return false; \ } \ \ @@ -561,15 +532,15 @@ static const char *cmc_string_fmt_deque = "struct %s<%s> " return true; \ } \ \ - struct SNAME *PFX##_copy_of(struct SNAME *_deque_) \ + struct SNAME *CMC_(PFX, _copy_of)(struct SNAME * _deque_) \ { \ struct SNAME *result = \ - PFX##_new_custom(_deque_->capacity, _deque_->f_val, \ - _deque_->alloc, _deque_->callbacks); \ + CMC_(PFX, _new_custom)(_deque_->capacity, _deque_->f_val, \ + _deque_->alloc, _deque_->callbacks); \ \ if (!result) \ { \ - _deque_->flag = cmc_flags.ERROR; \ + _deque_->flag = CMC_FLAG_ERROR; \ return NULL; \ } \ \ @@ -596,15 +567,15 @@ static const char *cmc_string_fmt_deque = "struct %s<%s> " result->front = 0; \ result->back = _deque_->count; \ \ - _deque_->flag = cmc_flags.OK; \ + _deque_->flag = CMC_FLAG_OK; \ \ return result; \ } \ \ - bool PFX##_equals(struct SNAME *_deque1_, struct SNAME *_deque2_) \ + bool CMC_(PFX, _equals)(struct SNAME * _deque1_, struct SNAME * _deque2_) \ { \ - _deque1_->flag = cmc_flags.OK; \ - _deque2_->flag = cmc_flags.OK; \ + _deque1_->flag = CMC_FLAG_OK; \ + _deque2_->flag = CMC_FLAG_OK; \ \ if (_deque1_->count != _deque2_->count) \ return false; \ @@ -624,20 +595,20 @@ static const char *cmc_string_fmt_deque = "struct %s<%s> " return true; \ } \ \ - struct cmc_string PFX##_to_string(struct SNAME *_deque_) \ + struct cmc_string CMC_(PFX, _to_string)(struct SNAME * _deque_) \ { \ struct cmc_string str; \ struct SNAME *d_ = _deque_; \ \ int n = \ - snprintf(str.s, cmc_string_len, cmc_string_fmt_deque, #SNAME, #V, \ - d_, d_->buffer, d_->capacity, d_->count, d_->front, \ + snprintf(str.s, cmc_string_len, cmc_cmc_string_fmt_deque, #SNAME, \ + #V, d_, d_->buffer, d_->capacity, d_->count, d_->front, \ d_->back, d_->flag, d_->f_val, d_->alloc, d_->callbacks); \ \ return n >= 0 ? str : (struct cmc_string){ 0 }; \ } \ \ - bool PFX##_print(struct SNAME *_deque_, FILE *fptr) \ + bool CMC_(PFX, _print)(struct SNAME * _deque_, FILE * fptr) \ { \ for (size_t i = _deque_->front, j = 0; j < _deque_->count; j++) \ { \ @@ -650,26 +621,26 @@ static const char *cmc_string_fmt_deque = "struct %s<%s> " return true; \ } \ \ - struct SNAME##_iter PFX##_iter_start(struct SNAME *target) \ + struct CMC_DEF_ITER(SNAME) CMC_(PFX, _iter_start)(struct SNAME * target) \ { \ - struct SNAME##_iter iter; \ + struct CMC_DEF_ITER(SNAME) iter; \ \ iter.target = target; \ iter.cursor = target->front; \ iter.index = 0; \ iter.start = true; \ - iter.end = PFX##_empty(target); \ + iter.end = CMC_(PFX, _empty)(target); \ \ return iter; \ } \ \ - struct SNAME##_iter PFX##_iter_end(struct SNAME *target) \ + struct CMC_DEF_ITER(SNAME) CMC_(PFX, _iter_end)(struct SNAME * target) \ { \ - struct SNAME##_iter iter; \ + struct CMC_DEF_ITER(SNAME) iter; \ \ iter.target = target; \ \ - if (!PFX##_empty(target)) \ + if (!CMC_(PFX, _empty)(target)) \ { \ if (iter.target->back == 0) \ iter.cursor = iter.target->capacity - 1; \ @@ -684,25 +655,25 @@ static const char *cmc_string_fmt_deque = "struct %s<%s> " iter.index = 0; \ } \ \ - iter.start = PFX##_empty(target); \ + iter.start = CMC_(PFX, _empty)(target); \ iter.end = true; \ \ return iter; \ } \ \ - bool PFX##_iter_at_start(struct SNAME##_iter *iter) \ + bool CMC_(PFX, _iter_at_start)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ - return PFX##_empty(iter->target) || iter->start; \ + return CMC_(PFX, _empty)(iter->target) || iter->start; \ } \ \ - bool PFX##_iter_at_end(struct SNAME##_iter *iter) \ + bool CMC_(PFX, _iter_at_end)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ - return PFX##_empty(iter->target) || iter->end; \ + return CMC_(PFX, _empty)(iter->target) || iter->end; \ } \ \ - bool PFX##_iter_to_start(struct SNAME##_iter *iter) \ + bool CMC_(PFX, _iter_to_start)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ - if (!PFX##_empty(iter->target)) \ + if (!CMC_(PFX, _empty)(iter->target)) \ { \ iter->cursor = iter->target->front; \ iter->index = 0; \ @@ -715,9 +686,9 @@ static const char *cmc_string_fmt_deque = "struct %s<%s> " return false; \ } \ \ - bool PFX##_iter_to_end(struct SNAME##_iter *iter) \ + bool CMC_(PFX, _iter_to_end)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ - if (!PFX##_empty(iter->target)) \ + if (!CMC_(PFX, _empty)(iter->target)) \ { \ if (iter->target->back == 0) \ iter->cursor = iter->target->capacity - 1; \ @@ -735,7 +706,7 @@ static const char *cmc_string_fmt_deque = "struct %s<%s> " return false; \ } \ \ - bool PFX##_iter_next(struct SNAME##_iter *iter) \ + bool CMC_(PFX, _iter_next)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ if (iter->end) \ return false; \ @@ -746,7 +717,7 @@ static const char *cmc_string_fmt_deque = "struct %s<%s> " return false; \ } \ \ - iter->start = PFX##_empty(iter->target); \ + iter->start = CMC_(PFX, _empty)(iter->target); \ \ iter->cursor = (iter->cursor + 1) % (iter->target->capacity); \ iter->index++; \ @@ -754,7 +725,7 @@ static const char *cmc_string_fmt_deque = "struct %s<%s> " return true; \ } \ \ - bool PFX##_iter_prev(struct SNAME##_iter *iter) \ + bool CMC_(PFX, _iter_prev)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ if (iter->start) \ return false; \ @@ -765,7 +736,7 @@ static const char *cmc_string_fmt_deque = "struct %s<%s> " return false; \ } \ \ - iter->end = PFX##_empty(iter->target); \ + iter->end = CMC_(PFX, _empty)(iter->target); \ \ iter->cursor = (iter->cursor == 0) ? iter->target->capacity - 1 \ : iter->cursor - 1; \ @@ -775,7 +746,8 @@ static const char *cmc_string_fmt_deque = "struct %s<%s> " } \ \ /* Returns true only if the iterator moved */ \ - bool PFX##_iter_advance(struct SNAME##_iter *iter, size_t steps) \ + bool CMC_(PFX, _iter_advance)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t steps) \ { \ if (iter->end) \ return false; \ @@ -789,7 +761,7 @@ static const char *cmc_string_fmt_deque = "struct %s<%s> " if (steps == 0 || iter->index + steps >= iter->target->count) \ return false; \ \ - iter->start = PFX##_empty(iter->target); \ + iter->start = CMC_(PFX, _empty)(iter->target); \ \ iter->index += steps; \ iter->cursor = (iter->cursor + steps) % iter->target->capacity; \ @@ -798,7 +770,8 @@ static const char *cmc_string_fmt_deque = "struct %s<%s> " } \ \ /* Returns true only if the iterator moved */ \ - bool PFX##_iter_rewind(struct SNAME##_iter *iter, size_t steps) \ + bool CMC_(PFX, _iter_rewind)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t steps) \ { \ if (iter->start) \ return false; \ @@ -812,7 +785,7 @@ static const char *cmc_string_fmt_deque = "struct %s<%s> " if (steps == 0 || iter->index < steps) \ return false; \ \ - iter->end = PFX##_empty(iter->target); \ + iter->end = CMC_(PFX, _empty)(iter->target); \ \ iter->index -= steps; \ \ @@ -827,38 +800,39 @@ static const char *cmc_string_fmt_deque = "struct %s<%s> " \ /* Returns true only if the iterator was able to be positioned at the */ \ /* given index */ \ - bool PFX##_iter_go_to(struct SNAME##_iter *iter, size_t index) \ + bool CMC_(PFX, _iter_go_to)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t index) \ { \ if (index >= iter->target->count) \ return false; \ \ if (iter->index > index) \ - return PFX##_iter_rewind(iter, iter->index - index); \ + return CMC_(PFX, _iter_rewind)(iter, iter->index - index); \ else if (iter->index < index) \ - return PFX##_iter_advance(iter, index - iter->index); \ + return CMC_(PFX, _iter_advance)(iter, index - iter->index); \ \ return true; \ } \ \ - V PFX##_iter_value(struct SNAME##_iter *iter) \ + V CMC_(PFX, _iter_value)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ - if (PFX##_empty(iter->target)) \ + if (CMC_(PFX, _empty)(iter->target)) \ return (V){ 0 }; \ \ return iter->target->buffer[iter->cursor]; \ } \ \ - V *PFX##_iter_rvalue(struct SNAME##_iter *iter) \ + V *CMC_(PFX, _iter_rvalue)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ - if (PFX##_empty(iter->target)) \ + if (CMC_(PFX, _empty)(iter->target)) \ return NULL; \ \ return &(iter->target->buffer[iter->cursor]); \ } \ \ - size_t PFX##_iter_index(struct SNAME##_iter *iter) \ + size_t CMC_(PFX, _iter_index)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ return iter->index; \ } -#endif /* CMC_DEQUE_H */ +#endif /* CMC_CMC_DEQUE_H */ diff --git a/src/cmc/hashbidimap.h b/src/cmc/hashbidimap.h index a0885e8..00006d6 100644 --- a/src/cmc/hashbidimap.h +++ b/src/cmc/hashbidimap.h @@ -23,8 +23,8 @@ * the key and the value. */ -#ifndef CMC_HASHBIDIMAP_H -#define CMC_HASHBIDIMAP_H +#ifndef CMC_CMC_HASHBIDIMAP_H +#define CMC_CMC_HASHBIDIMAP_H /* ------------------------------------------------------------------------- * Core functionalities of the C Macro Collections Library @@ -40,248 +40,264 @@ * HashBidimap Specific * ------------------------------------------------------------------------- */ /* to_string format */ -static const char *cmc_string_fmt_hashbidimap = "struct %s<%s, %s> " - "at %p { " - "buffer:%p, " - "capacity:%" PRIuMAX ", " - "count:%" PRIuMAX ", " - "load:%lf, " - "flag:%d, " - "f_key:%p, " - "f_val:%p, " - "alloc:%p, " - "callbacks:%p }"; +static const char *cmc_cmc_string_fmt_hashbidimap = "struct %s<%s, %s> " + "at %p { " + "buffer:%p, " + "capacity:%" PRIuMAX ", " + "count:%" PRIuMAX ", " + "load:%lf, " + "flag:%d, " + "f_key:%p, " + "f_val:%p, " + "alloc:%p, " + "callbacks:%p }"; -#define CMC_GENERATE_HASHBIDIMAP(PFX, SNAME, K, V) \ - CMC_GENERATE_HASHBIDIMAP_HEADER(PFX, SNAME, K, V) \ - CMC_GENERATE_HASHBIDIMAP_SOURCE(PFX, SNAME, K, V) +/** + * Core HashBidiMap implementation + */ +#define CMC_CMC_HASHBIDIMAP_CORE(BODY) \ + CMC_CMC_HASHBIDIMAP_CORE_HEADER(BODY) \ + CMC_CMC_HASHBIDIMAP_CORE_SOURCE(BODY) -#define CMC_WRAPGEN_HASHBIDIMAP_HEADER(PFX, SNAME, K, V) \ - CMC_GENERATE_HASHBIDIMAP_HEADER(PFX, SNAME, K, V) +#define CMC_CMC_HASHBIDIMAP_CORE_HEADER(BODY) \ + CMC_CMC_HASHBIDIMAP_CORE_HEADER_(CMC_PARAM_PFX(BODY), \ + CMC_PARAM_SNAME(BODY), CMC_PARAM_K(BODY), \ + CMC_PARAM_V(BODY)) -#define CMC_WRAPGEN_HASHBIDIMAP_SOURCE(PFX, SNAME, K, V) \ - CMC_GENERATE_HASHBIDIMAP_SOURCE(PFX, SNAME, K, V) +#define CMC_CMC_HASHBIDIMAP_CORE_SOURCE(BODY) \ + CMC_CMC_HASHBIDIMAP_CORE_SOURCE_(CMC_PARAM_PFX(BODY), \ + CMC_PARAM_SNAME(BODY), CMC_PARAM_K(BODY), \ + CMC_PARAM_V(BODY)) /* ------------------------------------------------------------------------- * Header * ------------------------------------------------------------------------- */ -#define CMC_GENERATE_HASHBIDIMAP_HEADER(PFX, SNAME, K, V) \ - \ - /* HashBidiMap Structure */ \ - struct SNAME \ - { \ - /* Array 0 is K -> V and array 1 is V -> K */ \ - struct SNAME##_entry *(*buffer)[2]; \ - \ - /* Current arrays capacity */ \ - size_t capacity; \ - \ - /* Current amount of keys */ \ - size_t count; \ - \ - /* Load factor in range (0.0, 1.0) */ \ - double load; \ - \ - /* Flags indicating errors or success */ \ - int flag; \ - \ - /* Key function table */ \ - struct SNAME##_fkey *f_key; \ - \ - /* Value function table */ \ - struct SNAME##_fval *f_val; \ - \ - /* Custom allocation functions */ \ - struct cmc_alloc_node *alloc; \ - \ - /* Custom callback functions */ \ - struct cmc_callbacks *callbacks; \ - \ - /* Methods */ \ - /* Returns an iterator to the start of the hashbidimap */ \ - struct SNAME##_iter (*it_start)(struct SNAME *); \ - \ - /* Returns an iterator to the end of the hashbidimap */ \ - struct SNAME##_iter (*it_end)(struct SNAME *); \ - }; \ - \ - /* HashBidiMap Entry */ \ - struct SNAME##_entry \ - { \ - /* Entry Key */ \ - K key; \ - \ - /* Entry Value */ \ - V value; \ - \ - /* The distance of this node to its original position */ \ - /* dist[0] is relative to K -> V */ \ - /* dist[1] is relative to V -> K */ \ - size_t dist[2]; \ - \ - /* References to this node in the hashbidimap buffer. Used to */ \ - /* prevent searching for this node twice for update() and */ \ - /* remove(). Increases memory overhead but reduces execution time */ \ - /* ref[0] is relative to K -> V */ \ - /* ref[1] is relative to V -> K */ \ - struct SNAME##_entry **ref[2]; \ - }; \ - \ - /* Key struct function table */ \ - struct SNAME##_fkey \ - { \ - /* Comparator function */ \ - int (*cmp)(K, K); \ - \ - /* Copy function */ \ - K (*cpy)(K); \ - \ - /* To string function */ \ - bool (*str)(FILE *, K); \ - \ - /* Free from memory function */ \ - void (*free)(K); \ - \ - /* Hash function */ \ - size_t (*hash)(K); \ - \ - /* Priority function */ \ - int (*pri)(K, K); \ - }; \ - \ - /* Value struct function table */ \ - struct SNAME##_fval \ - { \ - /* Comparator function */ \ - int (*cmp)(V, V); \ - \ - /* Copy function */ \ - V (*cpy)(V); \ - \ - /* To string function */ \ - bool (*str)(FILE *, V); \ - \ - /* Free from memory function */ \ - void (*free)(V); \ - \ - /* Hash function */ \ - size_t (*hash)(V); \ - \ - /* Priority function */ \ - int (*pri)(V, V); \ - }; \ - \ - /* HashBidiMap Iterator */ \ - struct SNAME##_iter \ - { \ - /* Target hashbidimap */ \ - struct SNAME *target; \ - \ - /* Cursor's position (index) */ \ - size_t cursor; \ - \ - /* Keeps track of relative index to the iteration of elements */ \ - size_t index; \ - \ - /* The index of the first element */ \ - size_t first; \ - \ - /* The index of the last element */ \ - size_t last; \ - \ - /* If the iterator has reached the start of the iteration */ \ - bool start; \ - \ - /* If the iterator has reached the end of the iteration */ \ - bool end; \ - }; \ - \ - /* Collection Functions */ \ - /* Collection Allocation and Deallocation */ \ - struct SNAME *PFX##_new(size_t capacity, double load, \ - struct SNAME##_fkey *f_key, \ - struct SNAME##_fval *f_val); \ - struct SNAME *PFX##_new_custom( \ - size_t capacity, double load, struct SNAME##_fkey *f_key, \ - struct SNAME##_fval *f_val, struct cmc_alloc_node *alloc, \ - struct cmc_callbacks *callbacks); \ - void PFX##_clear(struct SNAME *_map_); \ - void PFX##_free(struct SNAME *_map_); \ - /* Customization of Allocation and Callbacks */ \ - void PFX##_customize(struct SNAME *_map_, struct cmc_alloc_node *alloc, \ - struct cmc_callbacks *callbacks); \ - /* Collection Input and Output */ \ - bool PFX##_insert(struct SNAME *_map_, K key, V value); \ - bool PFX##_update_key(struct SNAME *_map_, V val, K new_key); \ - bool PFX##_update_val(struct SNAME *_map_, K key, V new_val); \ - bool PFX##_remove_by_key(struct SNAME *_map_, K key, K *out_key, \ - V *out_val); \ - bool PFX##_remove_by_val(struct SNAME *_map_, V val, K *out_key, \ - V *out_val); \ - /* Element Access */ \ - K PFX##_get_key(struct SNAME *_map_, V val); \ - V PFX##_get_val(struct SNAME *_map_, K key); \ - /* Collection State */ \ - bool PFX##_contains_key(struct SNAME *_map_, K key); \ - bool PFX##_contains_val(struct SNAME *_map_, V val); \ - bool PFX##_empty(struct SNAME *_map_); \ - bool PFX##_full(struct SNAME *_map_); \ - size_t PFX##_count(struct SNAME *_map_); \ - size_t PFX##_capacity(struct SNAME *_map_); \ - double PFX##_load(struct SNAME *_map_); \ - int PFX##_flag(struct SNAME *_map_); \ - /* Collection Utility */ \ - bool PFX##_resize(struct SNAME *_map_, size_t capacity); \ - struct SNAME *PFX##_copy_of(struct SNAME *_map_); \ - bool PFX##_equals(struct SNAME *_map1_, struct SNAME *_map2_); \ - struct cmc_string PFX##_to_string(struct SNAME *_map_); \ - bool PFX##_print(struct SNAME *_map_, FILE *fptr); \ - \ - /* Iterator Functions */ \ - /* Iterator Allocation and Deallocation */ \ - struct SNAME##_iter *PFX##_iter_new(struct SNAME *target); \ - void PFX##_iter_free(struct SNAME##_iter *iter); \ - /* Iterator Initialization */ \ - void PFX##_iter_init(struct SNAME##_iter *iter, struct SNAME *target); \ - /* Iterator State */ \ - bool PFX##_iter_start(struct SNAME##_iter *iter); \ - bool PFX##_iter_end(struct SNAME##_iter *iter); \ - /* Iterator Movement */ \ - void PFX##_iter_to_start(struct SNAME##_iter *iter); \ - void PFX##_iter_to_end(struct SNAME##_iter *iter); \ - bool PFX##_iter_next(struct SNAME##_iter *iter); \ - bool PFX##_iter_prev(struct SNAME##_iter *iter); \ - bool PFX##_iter_advance(struct SNAME##_iter *iter, size_t steps); \ - bool PFX##_iter_rewind(struct SNAME##_iter *iter, size_t steps); \ - bool PFX##_iter_go_to(struct SNAME##_iter *iter, size_t index); \ - /* Iterator Access */ \ - K PFX##_iter_key(struct SNAME##_iter *iter); \ - V PFX##_iter_value(struct SNAME##_iter *iter); \ - size_t PFX##_iter_index(struct SNAME##_iter *iter); +#define CMC_CMC_HASHBIDIMAP_CORE_HEADER_(PFX, SNAME, K, V) \ + \ + /* HashBidiMap Structure */ \ + struct SNAME \ + { \ + /* Array 0 is K -> V and array 1 is V -> K */ \ + struct CMC_DEF_ENTRY(SNAME) * (*buffer)[2]; \ + \ + /* Current arrays capacity */ \ + size_t capacity; \ + \ + /* Current amount of keys */ \ + size_t count; \ + \ + /* Load factor in range (0.0, 1.0) */ \ + double load; \ + \ + /* Flags indicating errors or success */ \ + int flag; \ + \ + /* Key function table */ \ + struct CMC_DEF_FKEY(SNAME) * f_key; \ + \ + /* Value function table */ \ + struct CMC_DEF_FVAL(SNAME) * f_val; \ + \ + /* Custom allocation functions */ \ + struct cmc_alloc_node *alloc; \ + \ + /* Custom callback functions */ \ + struct cmc_callbacks *callbacks; \ + \ + /* Methods */ \ + /* Returns an iterator to the start of the hashbidimap */ \ + struct CMC_DEF_ITER(SNAME) (*it_start)(struct SNAME *); \ + \ + /* Returns an iterator to the end of the hashbidimap */ \ + struct CMC_DEF_ITER(SNAME) (*it_end)(struct SNAME *); \ + }; \ + \ + /* HashBidiMap Entry */ \ + struct CMC_DEF_ENTRY(SNAME) \ + { \ + /* Entry Key */ \ + K key; \ + \ + /* Entry Value */ \ + V value; \ + \ + /* The distance of this node to its original position */ \ + /* dist[0] is relative to K -> V */ \ + /* dist[1] is relative to V -> K */ \ + size_t dist[2]; \ + \ + /* References to this node in the hashbidimap buffer. Used to */ \ + /* prevent searching for this node twice for update() and */ \ + /* remove(). Increases memory overhead but reduces execution time */ \ + /* ref[0] is relative to K -> V */ \ + /* ref[1] is relative to V -> K */ \ + struct CMC_DEF_ENTRY(SNAME) * *ref[2]; \ + }; \ + \ + /* Key struct function table */ \ + struct CMC_DEF_FKEY(SNAME) \ + { \ + /* Comparator function */ \ + int (*cmp)(K, K); \ + \ + /* Copy function */ \ + K (*cpy)(K); \ + \ + /* To string function */ \ + bool (*str)(FILE *, K); \ + \ + /* Free from memory function */ \ + void (*free)(K); \ + \ + /* Hash function */ \ + size_t (*hash)(K); \ + \ + /* Priority function */ \ + int (*pri)(K, K); \ + }; \ + \ + /* Value struct function table */ \ + struct CMC_DEF_FVAL(SNAME) \ + { \ + /* Comparator function */ \ + int (*cmp)(V, V); \ + \ + /* Copy function */ \ + V (*cpy)(V); \ + \ + /* To string function */ \ + bool (*str)(FILE *, V); \ + \ + /* Free from memory function */ \ + void (*free)(V); \ + \ + /* Hash function */ \ + size_t (*hash)(V); \ + \ + /* Priority function */ \ + int (*pri)(V, V); \ + }; \ + \ + /* HashBidiMap Iterator */ \ + struct CMC_DEF_ITER(SNAME) \ + { \ + /* Target hashbidimap */ \ + struct SNAME *target; \ + \ + /* Cursor's position (index) */ \ + size_t cursor; \ + \ + /* Keeps track of relative index to the iteration of elements */ \ + size_t index; \ + \ + /* The index of the first element */ \ + size_t first; \ + \ + /* The index of the last element */ \ + size_t last; \ + \ + /* If the iterator has reached the start of the iteration */ \ + bool start; \ + \ + /* If the iterator has reached the end of the iteration */ \ + bool end; \ + }; \ + \ + /* Collection Functions */ \ + /* Collection Allocation and Deallocation */ \ + struct SNAME *CMC_(PFX, _new)(size_t capacity, double load, \ + struct CMC_DEF_FKEY(SNAME) * f_key, \ + struct CMC_DEF_FVAL(SNAME) * f_val); \ + struct SNAME *CMC_(PFX, _new_custom)( \ + size_t capacity, double load, struct CMC_DEF_FKEY(SNAME) * f_key, \ + struct CMC_DEF_FVAL(SNAME) * f_val, struct cmc_alloc_node * alloc, \ + struct cmc_callbacks * callbacks); \ + void CMC_(PFX, _clear)(struct SNAME * _map_); \ + void CMC_(PFX, _free)(struct SNAME * _map_); \ + /* Customization of Allocation and Callbacks */ \ + void CMC_(PFX, _customize)(struct SNAME * _map_, \ + struct cmc_alloc_node * alloc, \ + struct cmc_callbacks * callbacks); \ + /* Collection Input and Output */ \ + bool CMC_(PFX, _insert)(struct SNAME * _map_, K key, V value); \ + bool CMC_(PFX, _update_key)(struct SNAME * _map_, V val, K new_key); \ + bool CMC_(PFX, _update_val)(struct SNAME * _map_, K key, V new_val); \ + bool CMC_(PFX, _remove_by_key)(struct SNAME * _map_, K key, K * out_key, \ + V * out_val); \ + bool CMC_(PFX, _remove_by_val)(struct SNAME * _map_, V val, K * out_key, \ + V * out_val); \ + /* Element Access */ \ + K CMC_(PFX, _get_key)(struct SNAME * _map_, V val); \ + V CMC_(PFX, _get_val)(struct SNAME * _map_, K key); \ + /* Collection State */ \ + bool CMC_(PFX, _contains_key)(struct SNAME * _map_, K key); \ + bool CMC_(PFX, _contains_val)(struct SNAME * _map_, V val); \ + bool CMC_(PFX, _empty)(struct SNAME * _map_); \ + bool CMC_(PFX, _full)(struct SNAME * _map_); \ + size_t CMC_(PFX, _count)(struct SNAME * _map_); \ + size_t CMC_(PFX, _capacity)(struct SNAME * _map_); \ + double CMC_(PFX, _load)(struct SNAME * _map_); \ + int CMC_(PFX, _flag)(struct SNAME * _map_); \ + /* Collection Utility */ \ + bool CMC_(PFX, _resize)(struct SNAME * _map_, size_t capacity); \ + struct SNAME *CMC_(PFX, _copy_of)(struct SNAME * _map_); \ + bool CMC_(PFX, _equals)(struct SNAME * _map1_, struct SNAME * _map2_); \ + struct cmc_string CMC_(PFX, _to_string)(struct SNAME * _map_); \ + bool CMC_(PFX, _print)(struct SNAME * _map_, FILE * fptr); \ + \ + /* Iterator Functions */ \ + /* Iterator Allocation and Deallocation */ \ + struct CMC_DEF_ITER(SNAME) * CMC_(PFX, _iter_new)(struct SNAME * target); \ + void CMC_(PFX, _iter_free)(struct CMC_DEF_ITER(SNAME) * iter); \ + /* Iterator Initialization */ \ + void CMC_(PFX, _iter_init)(struct CMC_DEF_ITER(SNAME) * iter, \ + struct SNAME * target); \ + /* Iterator State */ \ + bool CMC_(PFX, _iter_start)(struct CMC_DEF_ITER(SNAME) * iter); \ + bool CMC_(PFX, _iter_end)(struct CMC_DEF_ITER(SNAME) * iter); \ + /* Iterator Movement */ \ + void CMC_(PFX, _iter_to_start)(struct CMC_DEF_ITER(SNAME) * iter); \ + void CMC_(PFX, _iter_to_end)(struct CMC_DEF_ITER(SNAME) * iter); \ + bool CMC_(PFX, _iter_next)(struct CMC_DEF_ITER(SNAME) * iter); \ + bool CMC_(PFX, _iter_prev)(struct CMC_DEF_ITER(SNAME) * iter); \ + bool CMC_(PFX, _iter_advance)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t steps); \ + bool CMC_(PFX, _iter_rewind)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t steps); \ + bool CMC_(PFX, _iter_go_to)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t index); \ + /* Iterator Access */ \ + K CMC_(PFX, _iter_key)(struct CMC_DEF_ITER(SNAME) * iter); \ + V CMC_(PFX, _iter_value)(struct CMC_DEF_ITER(SNAME) * iter); \ + size_t CMC_(PFX, _iter_index)(struct CMC_DEF_ITER(SNAME) * iter); /* ------------------------------------------------------------------------- * Source * ------------------------------------------------------------------------- */ -#define CMC_GENERATE_HASHBIDIMAP_SOURCE(PFX, SNAME, K, V) \ +#define CMC_CMC_HASHBIDIMAP_CORE_SOURCE_(PFX, SNAME, K, V) \ \ /* Implementation Detail Functions */ \ - static struct SNAME##_entry *PFX##_impl_new_entry(struct SNAME *_map_, \ - K key, V value); \ - static struct SNAME##_entry **PFX##_impl_get_entry_by_key( \ - struct SNAME *_map_, K key); \ - static struct SNAME##_entry **PFX##_impl_get_entry_by_val( \ - struct SNAME *_map_, V val); \ - static struct SNAME##_entry **PFX##_impl_add_entry_to_key( \ - struct SNAME *_map_, struct SNAME##_entry *entry); \ - static struct SNAME##_entry **PFX##_impl_add_entry_to_val( \ - struct SNAME *_map_, struct SNAME##_entry *entry); \ - static size_t PFX##_impl_calculate_size(size_t required); \ - static struct SNAME##_iter PFX##_impl_it_start(struct SNAME *_map_); \ - static struct SNAME##_iter PFX##_impl_it_end(struct SNAME *_map_); \ + static struct CMC_DEF_ENTRY(SNAME) * \ + CMC_(PFX, _impl_new_entry)(struct SNAME * _map_, K key, V value); \ + static struct CMC_DEF_ENTRY(SNAME) * \ + *CMC_(PFX, _impl_get_entry_by_key)(struct SNAME * _map_, K key); \ + static struct CMC_DEF_ENTRY(SNAME) * \ + *CMC_(PFX, _impl_get_entry_by_val)(struct SNAME * _map_, V val); \ + static struct CMC_DEF_ENTRY(SNAME) * \ + *CMC_(PFX, _impl_add_entry_to_key)( \ + struct SNAME * _map_, struct CMC_DEF_ENTRY(SNAME) * entry); \ + static struct CMC_DEF_ENTRY(SNAME) * \ + *CMC_(PFX, _impl_add_entry_to_val)( \ + struct SNAME * _map_, struct CMC_DEF_ENTRY(SNAME) * entry); \ + static size_t CMC_(PFX, _impl_calculate_size)(size_t required); \ + static struct CMC_DEF_ITER(SNAME) \ + CMC_(PFX, _impl_it_start)(struct SNAME * _map_); \ + static struct CMC_DEF_ITER(SNAME) \ + CMC_(PFX, _impl_it_end)(struct SNAME * _map_); \ \ - struct SNAME *PFX##_new(size_t capacity, double load, \ - struct SNAME##_fkey *f_key, \ - struct SNAME##_fval *f_val) \ + struct SNAME *CMC_(PFX, _new)(size_t capacity, double load, \ + struct CMC_DEF_FKEY(SNAME) * f_key, \ + struct CMC_DEF_FVAL(SNAME) * f_val) \ { \ struct cmc_alloc_node *alloc = &cmc_alloc_node_default; \ \ @@ -295,15 +311,16 @@ static const char *cmc_string_fmt_hashbidimap = "struct %s<%s, %s> " if (!f_key || !f_val) \ return NULL; \ \ - size_t real_capacity = PFX##_impl_calculate_size(capacity / load); \ + size_t real_capacity = \ + CMC_(PFX, _impl_calculate_size)(capacity / load); \ \ struct SNAME *_map_ = alloc->malloc(sizeof(struct SNAME)); \ \ if (!_map_) \ return NULL; \ \ - _map_->buffer = \ - alloc->calloc(real_capacity, sizeof(struct SNAME##_entry *[2])); \ + _map_->buffer = alloc->calloc( \ + real_capacity, sizeof(struct CMC_DEF_ENTRY(SNAME) *[2])); \ \ if (!_map_->buffer) \ { \ @@ -315,21 +332,21 @@ static const char *cmc_string_fmt_hashbidimap = "struct %s<%s, %s> " _map_->count = 0; \ _map_->capacity = real_capacity; \ _map_->load = load; \ - _map_->flag = cmc_flags.OK; \ + _map_->flag = CMC_FLAG_OK; \ _map_->f_key = f_key; \ _map_->f_val = f_val; \ _map_->alloc = alloc; \ _map_->callbacks = NULL; \ - _map_->it_start = PFX##_impl_it_start; \ - _map_->it_end = PFX##_impl_it_end; \ + _map_->it_start = CMC_(PFX, _impl_it_start); \ + _map_->it_end = CMC_(PFX, _impl_it_end); \ \ return _map_; \ } \ \ - struct SNAME *PFX##_new_custom( \ - size_t capacity, double load, struct SNAME##_fkey *f_key, \ - struct SNAME##_fval *f_val, struct cmc_alloc_node *alloc, \ - struct cmc_callbacks *callbacks) \ + struct SNAME *CMC_(PFX, _new_custom)( \ + size_t capacity, double load, struct CMC_DEF_FKEY(SNAME) * f_key, \ + struct CMC_DEF_FVAL(SNAME) * f_val, struct cmc_alloc_node * alloc, \ + struct cmc_callbacks * callbacks) \ { \ if (capacity == 0 || load <= 0 || load >= 1) \ return NULL; \ @@ -341,7 +358,8 @@ static const char *cmc_string_fmt_hashbidimap = "struct %s<%s, %s> " if (!f_key || !f_val) \ return NULL; \ \ - size_t real_capacity = PFX##_impl_calculate_size(capacity / load); \ + size_t real_capacity = \ + CMC_(PFX, _impl_calculate_size)(capacity / load); \ \ if (!alloc) \ alloc = &cmc_alloc_node_default; \ @@ -351,8 +369,8 @@ static const char *cmc_string_fmt_hashbidimap = "struct %s<%s, %s> " if (!_map_) \ return NULL; \ \ - _map_->buffer = \ - alloc->calloc(real_capacity, sizeof(struct SNAME##_entry *[2])); \ + _map_->buffer = alloc->calloc( \ + real_capacity, sizeof(struct CMC_DEF_ENTRY(SNAME) *[2])); \ \ if (!_map_->buffer) \ { \ @@ -364,23 +382,23 @@ static const char *cmc_string_fmt_hashbidimap = "struct %s<%s, %s> " _map_->count = 0; \ _map_->capacity = real_capacity; \ _map_->load = load; \ - _map_->flag = cmc_flags.OK; \ + _map_->flag = CMC_FLAG_OK; \ _map_->f_key = f_key; \ _map_->f_val = f_val; \ - _map_->flag = cmc_flags.OK; \ + _map_->flag = CMC_FLAG_OK; \ _map_->alloc = alloc; \ _map_->callbacks = callbacks; \ - _map_->it_start = PFX##_impl_it_start; \ - _map_->it_end = PFX##_impl_it_end; \ + _map_->it_start = CMC_(PFX, _impl_it_start); \ + _map_->it_end = CMC_(PFX, _impl_it_end); \ \ return _map_; \ } \ \ - void PFX##_clear(struct SNAME *_map_) \ + void CMC_(PFX, _clear)(struct SNAME * _map_) \ { \ for (size_t i = 0; i < _map_->capacity; i++) \ { \ - struct SNAME##_entry *entry = _map_->buffer[i][0]; \ + struct CMC_DEF_ENTRY(SNAME) *entry = _map_->buffer[i][0]; \ \ if (entry && entry != CMC_ENTRY_DELETED) \ { \ @@ -397,19 +415,20 @@ static const char *cmc_string_fmt_hashbidimap = "struct %s<%s, %s> " } \ \ _map_->count = 0; \ - _map_->flag = cmc_flags.OK; \ + _map_->flag = CMC_FLAG_OK; \ } \ \ - void PFX##_free(struct SNAME *_map_) \ + void CMC_(PFX, _free)(struct SNAME * _map_) \ { \ - PFX##_clear(_map_); \ + CMC_(PFX, _clear)(_map_); \ \ _map_->alloc->free(_map_->buffer); \ _map_->alloc->free(_map_); \ } \ \ - void PFX##_customize(struct SNAME *_map_, struct cmc_alloc_node *alloc, \ - struct cmc_callbacks *callbacks) \ + void CMC_(PFX, _customize)(struct SNAME * _map_, \ + struct cmc_alloc_node * alloc, \ + struct cmc_callbacks * callbacks) \ { \ if (!alloc) \ _map_->alloc = &cmc_alloc_node_default; \ @@ -418,30 +437,31 @@ static const char *cmc_string_fmt_hashbidimap = "struct %s<%s, %s> " \ _map_->callbacks = callbacks; \ \ - _map_->flag = cmc_flags.OK; \ + _map_->flag = CMC_FLAG_OK; \ } \ \ - bool PFX##_insert(struct SNAME *_map_, K key, V value) \ + bool CMC_(PFX, _insert)(struct SNAME * _map_, K key, V value) \ { \ - if (PFX##_full(_map_)) \ + if (CMC_(PFX, _full)(_map_)) \ { \ - if (!PFX##_resize(_map_, _map_->capacity + 1)) \ + if (!CMC_(PFX, _resize)(_map_, _map_->capacity + 1)) \ return false; \ } \ \ - if (PFX##_impl_get_entry_by_key(_map_, key) != NULL || \ - PFX##_impl_get_entry_by_val(_map_, value) != NULL) \ + if (CMC_(PFX, _impl_get_entry_by_key)(_map_, key) != NULL || \ + CMC_(PFX, _impl_get_entry_by_val)(_map_, value) != NULL) \ { \ - _map_->flag = cmc_flags.DUPLICATE; \ + _map_->flag = CMC_FLAG_DUPLICATE; \ return false; \ } \ \ - struct SNAME##_entry *entry = PFX##_impl_new_entry(_map_, key, value); \ + struct CMC_DEF_ENTRY(SNAME) *entry = \ + CMC_(PFX, _impl_new_entry)(_map_, key, value); \ \ - struct SNAME##_entry **key_entry = \ - PFX##_impl_add_entry_to_key(_map_, entry); \ - struct SNAME##_entry **val_entry = \ - PFX##_impl_add_entry_to_val(_map_, entry); \ + struct CMC_DEF_ENTRY(SNAME) **key_entry = \ + CMC_(PFX, _impl_add_entry_to_key)(_map_, entry); \ + struct CMC_DEF_ENTRY(SNAME) **val_entry = \ + CMC_(PFX, _impl_add_entry_to_val)(_map_, entry); \ \ if (!key_entry || !val_entry) \ { \ @@ -452,13 +472,13 @@ static const char *cmc_string_fmt_hashbidimap = "struct %s<%s, %s> " \ _map_->alloc->free(entry); \ \ - _map_->flag = cmc_flags.ERROR; \ + _map_->flag = CMC_FLAG_ERROR; \ \ return false; \ } \ \ _map_->count++; \ - _map_->flag = cmc_flags.OK; \ + _map_->flag = CMC_FLAG_OK; \ \ if (_map_->callbacks && _map_->callbacks->create) \ _map_->callbacks->create(); \ @@ -466,21 +486,21 @@ static const char *cmc_string_fmt_hashbidimap = "struct %s<%s, %s> " return true; \ } \ \ - bool PFX##_update_key(struct SNAME *_map_, V val, K new_key) \ + bool CMC_(PFX, _update_key)(struct SNAME * _map_, V val, K new_key) \ { \ - if (PFX##_empty(_map_)) \ + if (CMC_(PFX, _empty)(_map_)) \ { \ - _map_->flag = cmc_flags.EMPTY; \ + _map_->flag = CMC_FLAG_EMPTY; \ return false; \ } \ \ - struct SNAME##_entry **key_entry, **val_entry; \ + struct CMC_DEF_ENTRY(SNAME) * *key_entry, **val_entry; \ \ - val_entry = PFX##_impl_get_entry_by_val(_map_, val); \ + val_entry = CMC_(PFX, _impl_get_entry_by_val)(_map_, val); \ \ if (!val_entry) \ { \ - _map_->flag = cmc_flags.NOT_FOUND; \ + _map_->flag = CMC_FLAG_NOT_FOUND; \ return false; \ } \ \ @@ -488,9 +508,9 @@ static const char *cmc_string_fmt_hashbidimap = "struct %s<%s, %s> " if (_map_->f_key->cmp(new_key, (*val_entry)->key) == 0) \ goto success; \ \ - if (PFX##_impl_get_entry_by_key(_map_, new_key) != NULL) \ + if (CMC_(PFX, _impl_get_entry_by_key)(_map_, new_key) != NULL) \ { \ - _map_->flag = cmc_flags.DUPLICATE; \ + _map_->flag = CMC_FLAG_DUPLICATE; \ return false; \ } \ \ @@ -499,30 +519,30 @@ static const char *cmc_string_fmt_hashbidimap = "struct %s<%s, %s> " if (!key_entry || *key_entry != *val_entry) \ { \ /* Should never happen */ \ - _map_->flag = cmc_flags.ERROR; \ + _map_->flag = CMC_FLAG_ERROR; \ return false; \ } \ \ /* Remove entry from key buffer and add it again with new key */ \ - struct SNAME##_entry *to_add = *key_entry; \ + struct CMC_DEF_ENTRY(SNAME) *to_add = *key_entry; \ K tmp_key = to_add->key; \ to_add->key = new_key; \ \ *key_entry = CMC_ENTRY_DELETED; \ \ - if (!PFX##_impl_add_entry_to_key(_map_, to_add)) \ + if (!CMC_(PFX, _impl_add_entry_to_key)(_map_, to_add)) \ { \ /* Revert changes */ \ to_add->key = tmp_key; \ *key_entry = to_add; \ \ - _map_->flag = cmc_flags.ERROR; \ + _map_->flag = CMC_FLAG_ERROR; \ return false; \ } \ \ success: \ \ - _map_->flag = cmc_flags.OK; \ + _map_->flag = CMC_FLAG_OK; \ \ if (_map_->callbacks && _map_->callbacks->update) \ _map_->callbacks->update(); \ @@ -530,21 +550,21 @@ static const char *cmc_string_fmt_hashbidimap = "struct %s<%s, %s> " return true; \ } \ \ - bool PFX##_update_val(struct SNAME *_map_, K key, V new_val) \ + bool CMC_(PFX, _update_val)(struct SNAME * _map_, K key, V new_val) \ { \ - if (PFX##_empty(_map_)) \ + if (CMC_(PFX, _empty)(_map_)) \ { \ - _map_->flag = cmc_flags.EMPTY; \ + _map_->flag = CMC_FLAG_EMPTY; \ return false; \ } \ \ - struct SNAME##_entry **key_entry, **val_entry; \ + struct CMC_DEF_ENTRY(SNAME) * *key_entry, **val_entry; \ \ - key_entry = PFX##_impl_get_entry_by_key(_map_, key); \ + key_entry = CMC_(PFX, _impl_get_entry_by_key)(_map_, key); \ \ if (!key_entry) \ { \ - _map_->flag = cmc_flags.NOT_FOUND; \ + _map_->flag = CMC_FLAG_NOT_FOUND; \ return false; \ } \ \ @@ -552,9 +572,9 @@ static const char *cmc_string_fmt_hashbidimap = "struct %s<%s, %s> " if (_map_->f_key->cmp(new_val, (*key_entry)->value) == 0) \ goto success; \ \ - if (PFX##_impl_get_entry_by_val(_map_, new_val) != NULL) \ + if (CMC_(PFX, _impl_get_entry_by_val)(_map_, new_val) != NULL) \ { \ - _map_->flag = cmc_flags.DUPLICATE; \ + _map_->flag = CMC_FLAG_DUPLICATE; \ return false; \ } \ \ @@ -563,31 +583,31 @@ static const char *cmc_string_fmt_hashbidimap = "struct %s<%s, %s> " if (!val_entry || *val_entry != *key_entry) \ { \ /* Should never happen */ \ - _map_->flag = cmc_flags.ERROR; \ + _map_->flag = CMC_FLAG_ERROR; \ return false; \ } \ \ /* Remove entry from value buffer and add it again with new value */ \ - struct SNAME##_entry *to_add = *val_entry; \ + struct CMC_DEF_ENTRY(SNAME) *to_add = *val_entry; \ V tmp_val = to_add->value; \ to_add->value = new_val; \ \ *val_entry = CMC_ENTRY_DELETED; \ \ - if (!PFX##_impl_add_entry_to_val(_map_, to_add)) \ + if (!CMC_(PFX, _impl_add_entry_to_val)(_map_, to_add)) \ { \ /* Revert changes */ \ to_add->value = tmp_val; \ *val_entry = to_add; \ \ - _map_->flag = cmc_flags.ERROR; \ + _map_->flag = CMC_FLAG_ERROR; \ \ return false; \ } \ \ success: \ \ - _map_->flag = cmc_flags.OK; \ + _map_->flag = CMC_FLAG_OK; \ \ if (_map_->callbacks && _map_->callbacks->update) \ _map_->callbacks->update(); \ @@ -595,22 +615,22 @@ static const char *cmc_string_fmt_hashbidimap = "struct %s<%s, %s> " return true; \ } \ \ - bool PFX##_remove_by_key(struct SNAME *_map_, K key, K *out_key, \ - V *out_val) \ + bool CMC_(PFX, _remove_by_key)(struct SNAME * _map_, K key, K * out_key, \ + V * out_val) \ { \ - if (PFX##_empty(_map_)) \ + if (CMC_(PFX, _empty)(_map_)) \ { \ - _map_->flag = cmc_flags.EMPTY; \ + _map_->flag = CMC_FLAG_EMPTY; \ return false; \ } \ \ - struct SNAME##_entry **key_entry, **val_entry; \ + struct CMC_DEF_ENTRY(SNAME) * *key_entry, **val_entry; \ \ - key_entry = PFX##_impl_get_entry_by_key(_map_, key); \ + key_entry = CMC_(PFX, _impl_get_entry_by_key)(_map_, key); \ \ if (!key_entry) \ { \ - _map_->flag = cmc_flags.NOT_FOUND; \ + _map_->flag = CMC_FLAG_NOT_FOUND; \ return false; \ } \ \ @@ -619,7 +639,7 @@ static const char *cmc_string_fmt_hashbidimap = "struct %s<%s, %s> " if (!val_entry || *val_entry != *key_entry) \ { \ /* Should never happen */ \ - _map_->flag = cmc_flags.ERROR; \ + _map_->flag = CMC_FLAG_ERROR; \ return false; \ } \ \ @@ -634,7 +654,7 @@ static const char *cmc_string_fmt_hashbidimap = "struct %s<%s, %s> " *val_entry = CMC_ENTRY_DELETED; \ \ _map_->count--; \ - _map_->flag = cmc_flags.OK; \ + _map_->flag = CMC_FLAG_OK; \ \ if (_map_->callbacks && _map_->callbacks->delete) \ _map_->callbacks->delete (); \ @@ -642,22 +662,22 @@ static const char *cmc_string_fmt_hashbidimap = "struct %s<%s, %s> " return true; \ } \ \ - bool PFX##_remove_by_val(struct SNAME *_map_, V val, K *out_key, \ - V *out_val) \ + bool CMC_(PFX, _remove_by_val)(struct SNAME * _map_, V val, K * out_key, \ + V * out_val) \ { \ - if (PFX##_empty(_map_)) \ + if (CMC_(PFX, _empty)(_map_)) \ { \ - _map_->flag = cmc_flags.EMPTY; \ + _map_->flag = CMC_FLAG_EMPTY; \ return false; \ } \ \ - struct SNAME##_entry **key_entry, **val_entry; \ + struct CMC_DEF_ENTRY(SNAME) * *key_entry, **val_entry; \ \ - val_entry = PFX##_impl_get_entry_by_val(_map_, val); \ + val_entry = CMC_(PFX, _impl_get_entry_by_val)(_map_, val); \ \ if (!val_entry) \ { \ - _map_->flag = cmc_flags.NOT_FOUND; \ + _map_->flag = CMC_FLAG_NOT_FOUND; \ return false; \ } \ \ @@ -666,7 +686,7 @@ static const char *cmc_string_fmt_hashbidimap = "struct %s<%s, %s> " if (!key_entry || *key_entry != *val_entry) \ { \ /* Should never happen */ \ - _map_->flag = cmc_flags.ERROR; \ + _map_->flag = CMC_FLAG_ERROR; \ return false; \ } \ \ @@ -681,7 +701,7 @@ static const char *cmc_string_fmt_hashbidimap = "struct %s<%s, %s> " *val_entry = CMC_ENTRY_DELETED; \ \ _map_->count--; \ - _map_->flag = cmc_flags.OK; \ + _map_->flag = CMC_FLAG_OK; \ \ if (_map_->callbacks && _map_->callbacks->delete) \ _map_->callbacks->delete (); \ @@ -689,18 +709,18 @@ static const char *cmc_string_fmt_hashbidimap = "struct %s<%s, %s> " return true; \ } \ \ - K PFX##_get_key(struct SNAME *_map_, V val) \ + K CMC_(PFX, _get_key)(struct SNAME * _map_, V val) \ { \ - struct SNAME##_entry **entry = \ - PFX##_impl_get_entry_by_val(_map_, val); \ + struct CMC_DEF_ENTRY(SNAME) **entry = \ + CMC_(PFX, _impl_get_entry_by_val)(_map_, val); \ \ if (!entry) \ { \ - _map_->flag = cmc_flags.NOT_FOUND; \ + _map_->flag = CMC_FLAG_NOT_FOUND; \ return (V){ 0 }; \ } \ \ - _map_->flag = cmc_flags.OK; \ + _map_->flag = CMC_FLAG_OK; \ \ if (_map_->callbacks && _map_->callbacks->read) \ _map_->callbacks->read(); \ @@ -708,18 +728,18 @@ static const char *cmc_string_fmt_hashbidimap = "struct %s<%s, %s> " return (*entry)->key; \ } \ \ - V PFX##_get_val(struct SNAME *_map_, K key) \ + V CMC_(PFX, _get_val)(struct SNAME * _map_, K key) \ { \ - struct SNAME##_entry **entry = \ - PFX##_impl_get_entry_by_key(_map_, key); \ + struct CMC_DEF_ENTRY(SNAME) **entry = \ + CMC_(PFX, _impl_get_entry_by_key)(_map_, key); \ \ if (!entry) \ { \ - _map_->flag = cmc_flags.NOT_FOUND; \ + _map_->flag = CMC_FLAG_NOT_FOUND; \ return (V){ 0 }; \ } \ \ - _map_->flag = cmc_flags.OK; \ + _map_->flag = CMC_FLAG_OK; \ \ if (_map_->callbacks && _map_->callbacks->read) \ _map_->callbacks->read(); \ @@ -727,11 +747,11 @@ static const char *cmc_string_fmt_hashbidimap = "struct %s<%s, %s> " return (*entry)->value; \ } \ \ - bool PFX##_contains_key(struct SNAME *_map_, K key) \ + bool CMC_(PFX, _contains_key)(struct SNAME * _map_, K key) \ { \ - _map_->flag = cmc_flags.OK; \ + _map_->flag = CMC_FLAG_OK; \ \ - bool result = PFX##_impl_get_entry_by_key(_map_, key) != NULL; \ + bool result = CMC_(PFX, _impl_get_entry_by_key)(_map_, key) != NULL; \ \ if (_map_->callbacks && _map_->callbacks->read) \ _map_->callbacks->read(); \ @@ -739,11 +759,11 @@ static const char *cmc_string_fmt_hashbidimap = "struct %s<%s, %s> " return result; \ } \ \ - bool PFX##_contains_val(struct SNAME *_map_, V val) \ + bool CMC_(PFX, _contains_val)(struct SNAME * _map_, V val) \ { \ - _map_->flag = cmc_flags.OK; \ + _map_->flag = CMC_FLAG_OK; \ \ - bool result = PFX##_impl_get_entry_by_val(_map_, val) != NULL; \ + bool result = CMC_(PFX, _impl_get_entry_by_val)(_map_, val) != NULL; \ \ if (_map_->callbacks && _map_->callbacks->read) \ _map_->callbacks->read(); \ @@ -751,39 +771,39 @@ static const char *cmc_string_fmt_hashbidimap = "struct %s<%s, %s> " return result; \ } \ \ - bool PFX##_empty(struct SNAME *_map_) \ + bool CMC_(PFX, _empty)(struct SNAME * _map_) \ { \ return _map_->count == 0; \ } \ \ - bool PFX##_full(struct SNAME *_map_) \ + bool CMC_(PFX, _full)(struct SNAME * _map_) \ { \ return (double)_map_->capacity * _map_->load <= (double)_map_->count; \ } \ \ - size_t PFX##_count(struct SNAME *_map_) \ + size_t CMC_(PFX, _count)(struct SNAME * _map_) \ { \ return _map_->count; \ } \ \ - size_t PFX##_capacity(struct SNAME *_map_) \ + size_t CMC_(PFX, _capacity)(struct SNAME * _map_) \ { \ return _map_->capacity; \ } \ \ - double PFX##_load(struct SNAME *_map_) \ + double CMC_(PFX, _load)(struct SNAME * _map_) \ { \ return _map_->load; \ } \ \ - int PFX##_flag(struct SNAME *_map_) \ + int CMC_(PFX, _flag)(struct SNAME * _map_) \ { \ return _map_->flag; \ } \ \ - bool PFX##_resize(struct SNAME *_map_, size_t capacity) \ + bool CMC_(PFX, _resize)(struct SNAME * _map_, size_t capacity) \ { \ - _map_->flag = cmc_flags.OK; \ + _map_->flag = CMC_FLAG_OK; \ \ if (_map_->capacity == capacity) \ goto success; \ @@ -794,52 +814,52 @@ static const char *cmc_string_fmt_hashbidimap = "struct %s<%s, %s> " /* Prevent integer overflow */ \ if (capacity >= UINTMAX_MAX * _map_->load) \ { \ - _map_->flag = cmc_flags.ERROR; \ + _map_->flag = CMC_FLAG_ERROR; \ return false; \ } \ \ /* Calculate required capacity based on the prime numbers */ \ - size_t new_cap = PFX##_impl_calculate_size(capacity); \ + size_t new_cap = CMC_(PFX, _impl_calculate_size)(capacity); \ \ /* Not possible to shrink with current available prime numbers */ \ if (new_cap < _map_->count / _map_->load) \ { \ - _map_->flag = cmc_flags.INVALID; \ + _map_->flag = CMC_FLAG_INVALID; \ return false; \ } \ \ /* No callbacks since _new_map_ is just a temporary hashtable */ \ struct SNAME *_new_map_ = \ - PFX##_new_custom(capacity, _map_->load, _map_->f_key, \ - _map_->f_val, _map_->alloc, NULL); \ + CMC_(PFX, _new_custom)(capacity, _map_->load, _map_->f_key, \ + _map_->f_val, _map_->alloc, NULL); \ \ if (!_new_map_) \ { \ - _map_->flag = cmc_flags.ALLOC; \ + _map_->flag = CMC_FLAG_ALLOC; \ return false; \ } \ \ for (size_t i = 0; i < _map_->capacity; i++) \ { \ - struct SNAME##_entry *scan = _map_->buffer[i][0]; \ + struct CMC_DEF_ENTRY(SNAME) *scan = _map_->buffer[i][0]; \ \ if (scan && scan != CMC_ENTRY_DELETED) \ { \ - struct SNAME##_entry **e1 = \ - PFX##_impl_add_entry_to_key(_new_map_, scan); \ - struct SNAME##_entry **e2 = \ - PFX##_impl_add_entry_to_val(_new_map_, scan); \ + struct CMC_DEF_ENTRY(SNAME) **e1 = \ + CMC_(PFX, _impl_add_entry_to_key)(_new_map_, scan); \ + struct CMC_DEF_ENTRY(SNAME) **e2 = \ + CMC_(PFX, _impl_add_entry_to_val)(_new_map_, scan); \ \ if (!e1 || !e2) \ { \ /* Prevent the map from freeing the data */ \ - _new_map_->f_key = &(struct SNAME##_fkey){ NULL }; \ - _new_map_->f_val = &(struct SNAME##_fval){ NULL }; \ + _new_map_->f_key = &(struct CMC_DEF_FKEY(SNAME)){ NULL }; \ + _new_map_->f_val = &(struct CMC_DEF_FVAL(SNAME)){ NULL }; \ \ _map_->alloc->free(_new_map_->buffer); \ _map_->alloc->free(_new_map_); \ \ - _map_->flag = cmc_flags.ERROR; \ + _map_->flag = CMC_FLAG_ERROR; \ \ return false; \ } \ @@ -851,18 +871,18 @@ static const char *cmc_string_fmt_hashbidimap = "struct %s<%s, %s> " if (_map_->count != _new_map_->count) \ { \ /* Prevent the map from freeing the data */ \ - _new_map_->f_key = &(struct SNAME##_fkey){ NULL }; \ - _new_map_->f_val = &(struct SNAME##_fval){ NULL }; \ + _new_map_->f_key = &(struct CMC_DEF_FKEY(SNAME)){ NULL }; \ + _new_map_->f_val = &(struct CMC_DEF_FVAL(SNAME)){ NULL }; \ \ _map_->alloc->free(_new_map_->buffer); \ _map_->alloc->free(_new_map_); \ \ - _map_->flag = cmc_flags.ERROR; \ + _map_->flag = CMC_FLAG_ERROR; \ \ return false; \ } \ \ - struct SNAME##_entry *(*tmp_buff)[2] = _map_->buffer; \ + struct CMC_DEF_ENTRY(SNAME) * (*tmp_buff)[2] = _map_->buffer; \ \ _map_->buffer = _new_map_->buffer; \ _map_->capacity = _new_map_->capacity; \ @@ -878,22 +898,22 @@ static const char *cmc_string_fmt_hashbidimap = "struct %s<%s, %s> " return true; \ } \ \ - struct SNAME *PFX##_copy_of(struct SNAME *_map_) \ + struct SNAME *CMC_(PFX, _copy_of)(struct SNAME * _map_) \ { \ /* TODO this function can be optimized */ \ - struct SNAME *result = PFX##_new_custom( \ + struct SNAME *result = CMC_(PFX, _new_custom)( \ _map_->capacity * _map_->load, _map_->load, _map_->f_key, \ _map_->f_val, _map_->alloc, _map_->callbacks); \ \ if (!result) \ { \ - _map_->flag = cmc_flags.ERROR; \ + _map_->flag = CMC_FLAG_ERROR; \ return NULL; \ } \ \ for (size_t i = 0; i < _map_->capacity; i++) \ { \ - struct SNAME##_entry *scan = _map_->buffer[i][0]; \ + struct CMC_DEF_ENTRY(SNAME) *scan = _map_->buffer[i][0]; \ \ if (scan && scan != CMC_ENTRY_DELETED) \ { \ @@ -911,25 +931,25 @@ static const char *cmc_string_fmt_hashbidimap = "struct %s<%s, %s> " tmp_val = scan->value; \ \ /* TODO treat the possible errors */ \ - struct SNAME##_entry *entry = \ - PFX##_impl_new_entry(result, tmp_key, tmp_val); \ + struct CMC_DEF_ENTRY(SNAME) *entry = \ + CMC_(PFX, _impl_new_entry)(result, tmp_key, tmp_val); \ \ - PFX##_impl_add_entry_to_key(result, entry); \ - PFX##_impl_add_entry_to_val(result, entry); \ + CMC_(PFX, _impl_add_entry_to_key)(result, entry); \ + CMC_(PFX, _impl_add_entry_to_val)(result, entry); \ \ result->count++; \ } \ } \ \ - _map_->flag = cmc_flags.OK; \ + _map_->flag = CMC_FLAG_OK; \ \ return result; \ } \ \ - bool PFX##_equals(struct SNAME *_map1_, struct SNAME *_map2_) \ + bool CMC_(PFX, _equals)(struct SNAME * _map1_, struct SNAME * _map2_) \ { \ - _map1_->flag = cmc_flags.OK; \ - _map2_->flag = cmc_flags.OK; \ + _map1_->flag = CMC_FLAG_OK; \ + _map2_->flag = CMC_FLAG_OK; \ \ if (_map1_->count != _map2_->count) \ return false; \ @@ -950,12 +970,12 @@ static const char *cmc_string_fmt_hashbidimap = "struct %s<%s, %s> " \ for (size_t i = 0; i < _mapA_->capacity; i++) \ { \ - struct SNAME##_entry *scan = _mapA_->buffer[i][0]; \ + struct CMC_DEF_ENTRY(SNAME) *scan = _mapA_->buffer[i][0]; \ \ if (scan && scan != CMC_ENTRY_DELETED) \ { \ - struct SNAME##_entry **entry_B = \ - PFX##_impl_get_entry_by_key(_mapB_, scan->key); \ + struct CMC_DEF_ENTRY(SNAME) **entry_B = \ + CMC_(PFX, _impl_get_entry_by_key)(_mapB_, scan->key); \ \ if (!entry_B) \ return false; \ @@ -968,24 +988,24 @@ static const char *cmc_string_fmt_hashbidimap = "struct %s<%s, %s> " return true; \ } \ \ - struct cmc_string PFX##_to_string(struct SNAME *_map_) \ + struct cmc_string CMC_(PFX, _to_string)(struct SNAME * _map_) \ { \ struct cmc_string str; \ struct SNAME *m_ = _map_; \ \ - int n = snprintf(str.s, cmc_string_len, cmc_string_fmt_hashbidimap, \ - #SNAME, #K, #V, m_, m_->buffer, m_->capacity, \ - m_->count, m_->load, m_->flag, m_->f_key, m_->f_val, \ - m_->alloc, m_->callbacks); \ + int n = snprintf( \ + str.s, cmc_string_len, cmc_cmc_string_fmt_hashbidimap, #SNAME, #K, \ + #V, m_, m_->buffer, m_->capacity, m_->count, m_->load, m_->flag, \ + m_->f_key, m_->f_val, m_->alloc, m_->callbacks); \ \ return n >= 0 ? str : (struct cmc_string){ 0 }; \ } \ \ - bool PFX##_print(struct SNAME *_map_, FILE *fptr) \ + bool CMC_(PFX, _print)(struct SNAME * _map_, FILE * fptr) \ { \ for (size_t i = 0; i < _map_->capacity; i++) \ { \ - struct SNAME##_entry *target = _map_->buffer[i][0]; \ + struct CMC_DEF_ENTRY(SNAME) *target = _map_->buffer[i][0]; \ \ if (target && target != CMC_ENTRY_DELETED) \ { \ @@ -998,37 +1018,38 @@ static const char *cmc_string_fmt_hashbidimap = "struct %s<%s, %s> " return true; \ } \ \ - struct SNAME##_iter *PFX##_iter_new(struct SNAME *target) \ + struct CMC_DEF_ITER(SNAME) * CMC_(PFX, _iter_new)(struct SNAME * target) \ { \ - struct SNAME##_iter *iter = \ - target->alloc->malloc(sizeof(struct SNAME##_iter)); \ + struct CMC_DEF_ITER(SNAME) *iter = \ + target->alloc->malloc(sizeof(struct CMC_DEF_ITER(SNAME))); \ \ if (!iter) \ return NULL; \ \ - PFX##_iter_init(iter, target); \ + CMC_(PFX, _iter_init)(iter, target); \ \ return iter; \ } \ \ - void PFX##_iter_free(struct SNAME##_iter *iter) \ + void CMC_(PFX, _iter_free)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ iter->target->alloc->free(iter); \ } \ \ - void PFX##_iter_init(struct SNAME##_iter *iter, struct SNAME *target) \ + void CMC_(PFX, _iter_init)(struct CMC_DEF_ITER(SNAME) * iter, \ + struct SNAME * target) \ { \ - memset(iter, 0, sizeof(struct SNAME##_iter)); \ + memset(iter, 0, sizeof(struct CMC_DEF_ITER(SNAME))); \ \ iter->target = target; \ iter->start = true; \ - iter->end = PFX##_empty(target); \ + iter->end = CMC_(PFX, _empty)(target); \ \ - if (!PFX##_empty(target)) \ + if (!CMC_(PFX, _empty)(target)) \ { \ for (size_t i = 0; i < target->capacity; i++) \ { \ - struct SNAME##_entry *tmp = target->buffer[i][0]; \ + struct CMC_DEF_ENTRY(SNAME) *tmp = target->buffer[i][0]; \ \ if (tmp != NULL && tmp != CMC_ENTRY_DELETED) \ { \ @@ -1041,7 +1062,7 @@ static const char *cmc_string_fmt_hashbidimap = "struct %s<%s, %s> " \ for (size_t i = target->capacity; i > 0; i--) \ { \ - struct SNAME##_entry *tmp = target->buffer[i - 1][0]; \ + struct CMC_DEF_ENTRY(SNAME) *tmp = target->buffer[i - 1][0]; \ \ if (tmp != NULL && tmp != CMC_ENTRY_DELETED) \ { \ @@ -1052,19 +1073,19 @@ static const char *cmc_string_fmt_hashbidimap = "struct %s<%s, %s> " } \ } \ \ - bool PFX##_iter_start(struct SNAME##_iter *iter) \ + bool CMC_(PFX, _iter_start)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ - return PFX##_empty(iter->target) || iter->start; \ + return CMC_(PFX, _empty)(iter->target) || iter->start; \ } \ \ - bool PFX##_iter_end(struct SNAME##_iter *iter) \ + bool CMC_(PFX, _iter_end)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ - return PFX##_empty(iter->target) || iter->end; \ + return CMC_(PFX, _empty)(iter->target) || iter->end; \ } \ \ - void PFX##_iter_to_start(struct SNAME##_iter *iter) \ + void CMC_(PFX, _iter_to_start)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ - if (!PFX##_empty(iter->target)) \ + if (!CMC_(PFX, _empty)(iter->target)) \ { \ iter->cursor = iter->first; \ iter->index = 0; \ @@ -1073,9 +1094,9 @@ static const char *cmc_string_fmt_hashbidimap = "struct %s<%s, %s> " } \ } \ \ - void PFX##_iter_to_end(struct SNAME##_iter *iter) \ + void CMC_(PFX, _iter_to_end)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ - if (!PFX##_empty(iter->target)) \ + if (!CMC_(PFX, _empty)(iter->target)) \ { \ iter->cursor = iter->last; \ iter->index = iter->target->count - 1; \ @@ -1084,7 +1105,7 @@ static const char *cmc_string_fmt_hashbidimap = "struct %s<%s, %s> " } \ } \ \ - bool PFX##_iter_next(struct SNAME##_iter *iter) \ + bool CMC_(PFX, _iter_next)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ if (iter->end) \ return false; \ @@ -1095,9 +1116,10 @@ static const char *cmc_string_fmt_hashbidimap = "struct %s<%s, %s> " return false; \ } \ \ - iter->start = PFX##_empty(iter->target); \ + iter->start = CMC_(PFX, _empty)(iter->target); \ \ - struct SNAME##_entry *scan = iter->target->buffer[iter->cursor][0]; \ + struct CMC_DEF_ENTRY(SNAME) *scan = \ + iter->target->buffer[iter->cursor][0]; \ \ iter->index++; \ \ @@ -1113,7 +1135,7 @@ static const char *cmc_string_fmt_hashbidimap = "struct %s<%s, %s> " return true; \ } \ \ - bool PFX##_iter_prev(struct SNAME##_iter *iter) \ + bool CMC_(PFX, _iter_prev)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ if (iter->start) \ return false; \ @@ -1124,9 +1146,10 @@ static const char *cmc_string_fmt_hashbidimap = "struct %s<%s, %s> " return false; \ } \ \ - iter->end = PFX##_empty(iter->target); \ + iter->end = CMC_(PFX, _empty)(iter->target); \ \ - struct SNAME##_entry *scan = iter->target->buffer[iter->cursor][0]; \ + struct CMC_DEF_ENTRY(SNAME) *scan = \ + iter->target->buffer[iter->cursor][0]; \ \ iter->index--; \ \ @@ -1143,7 +1166,8 @@ static const char *cmc_string_fmt_hashbidimap = "struct %s<%s, %s> " } \ \ /* Returns true only if the iterator moved */ \ - bool PFX##_iter_advance(struct SNAME##_iter *iter, size_t steps) \ + bool CMC_(PFX, _iter_advance)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t steps) \ { \ if (iter->end) \ return false; \ @@ -1158,13 +1182,14 @@ static const char *cmc_string_fmt_hashbidimap = "struct %s<%s, %s> " return false; \ \ for (size_t i = 0; i < steps; i++) \ - PFX##_iter_next(iter); \ + CMC_(PFX, _iter_next)(iter); \ \ return true; \ } \ \ /* Returns true only if the iterator moved */ \ - bool PFX##_iter_rewind(struct SNAME##_iter *iter, size_t steps) \ + bool CMC_(PFX, _iter_rewind)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t steps) \ { \ if (iter->start) \ return false; \ @@ -1179,58 +1204,59 @@ static const char *cmc_string_fmt_hashbidimap = "struct %s<%s, %s> " return false; \ \ for (size_t i = 0; i < steps; i++) \ - PFX##_iter_prev(iter); \ + CMC_(PFX, _iter_prev)(iter); \ \ return true; \ } \ \ /* Returns true only if the iterator was able to be positioned at */ \ /* the given index */ \ - bool PFX##_iter_go_to(struct SNAME##_iter *iter, size_t index) \ + bool CMC_(PFX, _iter_go_to)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t index) \ { \ if (index >= iter->target->count) \ return false; \ \ if (iter->index > index) \ - return PFX##_iter_rewind(iter, iter->index - index); \ + return CMC_(PFX, _iter_rewind)(iter, iter->index - index); \ else if (iter->index < index) \ - return PFX##_iter_advance(iter, index - iter->index); \ + return CMC_(PFX, _iter_advance)(iter, index - iter->index); \ \ return true; \ } \ \ - K PFX##_iter_key(struct SNAME##_iter *iter) \ + K CMC_(PFX, _iter_key)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ - if (PFX##_empty(iter->target)) \ + if (CMC_(PFX, _empty)(iter->target)) \ { \ - iter->target->flag = cmc_flags.EMPTY; \ + iter->target->flag = CMC_FLAG_EMPTY; \ return (K){ 0 }; \ } \ \ return iter->target->buffer[iter->cursor][0]->key; \ } \ \ - V PFX##_iter_value(struct SNAME##_iter *iter) \ + V CMC_(PFX, _iter_value)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ - if (PFX##_empty(iter->target)) \ + if (CMC_(PFX, _empty)(iter->target)) \ { \ - iter->target->flag = cmc_flags.EMPTY; \ + iter->target->flag = CMC_FLAG_EMPTY; \ return (V){ 0 }; \ } \ \ return iter->target->buffer[iter->cursor][0]->value; \ } \ \ - size_t PFX##_iter_index(struct SNAME##_iter *iter) \ + size_t CMC_(PFX, _iter_index)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ return iter->index; \ } \ \ - static struct SNAME##_entry *PFX##_impl_new_entry(struct SNAME *_map_, \ - K key, V value) \ + static struct CMC_DEF_ENTRY(SNAME) * \ + CMC_(PFX, _impl_new_entry)(struct SNAME * _map_, K key, V value) \ { \ - struct SNAME##_entry *entry = \ - _map_->alloc->malloc(sizeof(struct SNAME##_entry)); \ + struct CMC_DEF_ENTRY(SNAME) *entry = \ + _map_->alloc->malloc(sizeof(struct CMC_DEF_ENTRY(SNAME))); \ \ if (!entry) \ return NULL; \ @@ -1245,13 +1271,13 @@ static const char *cmc_string_fmt_hashbidimap = "struct %s<%s, %s> " return entry; \ } \ \ - static struct SNAME##_entry **PFX##_impl_get_entry_by_key( \ - struct SNAME *_map_, K key) \ + static struct CMC_DEF_ENTRY(SNAME) * \ + *CMC_(PFX, _impl_get_entry_by_key)(struct SNAME * _map_, K key) \ { \ size_t hash = _map_->f_key->hash(key); \ size_t pos = hash % _map_->capacity; \ \ - struct SNAME##_entry *target = _map_->buffer[pos][0]; \ + struct CMC_DEF_ENTRY(SNAME) *target = _map_->buffer[pos][0]; \ \ while (target != NULL) \ { \ @@ -1266,13 +1292,13 @@ static const char *cmc_string_fmt_hashbidimap = "struct %s<%s, %s> " return NULL; \ } \ \ - static struct SNAME##_entry **PFX##_impl_get_entry_by_val( \ - struct SNAME *_map_, V val) \ + static struct CMC_DEF_ENTRY(SNAME) * \ + *CMC_(PFX, _impl_get_entry_by_val)(struct SNAME * _map_, V val) \ { \ size_t hash = _map_->f_val->hash(val); \ size_t pos = hash % _map_->capacity; \ \ - struct SNAME##_entry *target = _map_->buffer[pos][1]; \ + struct CMC_DEF_ENTRY(SNAME) *target = _map_->buffer[pos][1]; \ \ while (target != NULL) \ { \ @@ -1287,16 +1313,17 @@ static const char *cmc_string_fmt_hashbidimap = "struct %s<%s, %s> " return NULL; \ } \ \ - static struct SNAME##_entry **PFX##_impl_add_entry_to_key( \ - struct SNAME *_map_, struct SNAME##_entry *entry) \ + static struct CMC_DEF_ENTRY(SNAME) * \ + *CMC_(PFX, _impl_add_entry_to_key)( \ + struct SNAME * _map_, struct CMC_DEF_ENTRY(SNAME) * entry) \ { \ - struct SNAME##_entry **to_return = NULL; \ + struct CMC_DEF_ENTRY(SNAME) **to_return = NULL; \ \ size_t hash = _map_->f_key->hash(entry->key); \ size_t original_pos = hash % _map_->capacity; \ size_t pos = original_pos; \ \ - struct SNAME##_entry **scan = \ + struct CMC_DEF_ENTRY(SNAME) **scan = \ &(_map_->buffer[hash % _map_->capacity][0]); \ \ if (*scan == NULL) \ @@ -1336,7 +1363,7 @@ static const char *cmc_string_fmt_hashbidimap = "struct %s<%s, %s> " \ entry->ref[0] = scan; \ \ - struct SNAME##_entry *_tmp_ = *scan; \ + struct CMC_DEF_ENTRY(SNAME) *_tmp_ = *scan; \ *scan = entry; \ entry = _tmp_; \ } \ @@ -1346,16 +1373,17 @@ static const char *cmc_string_fmt_hashbidimap = "struct %s<%s, %s> " return NULL; \ } \ \ - static struct SNAME##_entry **PFX##_impl_add_entry_to_val( \ - struct SNAME *_map_, struct SNAME##_entry *entry) \ + static struct CMC_DEF_ENTRY(SNAME) * \ + *CMC_(PFX, _impl_add_entry_to_val)( \ + struct SNAME * _map_, struct CMC_DEF_ENTRY(SNAME) * entry) \ { \ - struct SNAME##_entry **to_return = NULL; \ + struct CMC_DEF_ENTRY(SNAME) **to_return = NULL; \ \ size_t hash = _map_->f_val->hash(entry->value); \ size_t original_pos = hash % _map_->capacity; \ size_t pos = original_pos; \ \ - struct SNAME##_entry **scan = \ + struct CMC_DEF_ENTRY(SNAME) **scan = \ &(_map_->buffer[hash % _map_->capacity][1]); \ \ if (*scan == NULL) \ @@ -1395,7 +1423,7 @@ static const char *cmc_string_fmt_hashbidimap = "struct %s<%s, %s> " \ entry->ref[1] = scan; \ \ - struct SNAME##_entry *_tmp_ = *scan; \ + struct CMC_DEF_ENTRY(SNAME) *_tmp_ = *scan; \ *scan = entry; \ entry = _tmp_; \ } \ @@ -1405,7 +1433,7 @@ static const char *cmc_string_fmt_hashbidimap = "struct %s<%s, %s> " return NULL; \ } \ \ - static size_t PFX##_impl_calculate_size(size_t required) \ + static size_t CMC_(PFX, _impl_calculate_size)(size_t required) \ { \ const size_t count = \ sizeof(cmc_hashtable_primes) / sizeof(cmc_hashtable_primes[0]); \ @@ -1420,23 +1448,25 @@ static const char *cmc_string_fmt_hashbidimap = "struct %s<%s, %s> " return cmc_hashtable_primes[i]; \ } \ \ - static struct SNAME##_iter PFX##_impl_it_start(struct SNAME *_map_) \ + static struct CMC_DEF_ITER(SNAME) \ + CMC_(PFX, _impl_it_start)(struct SNAME * _map_) \ { \ - struct SNAME##_iter iter; \ + struct CMC_DEF_ITER(SNAME) iter; \ \ - PFX##_iter_init(&iter, _map_); \ + CMC_(PFX, _iter_init)(&iter, _map_); \ \ return iter; \ } \ \ - static struct SNAME##_iter PFX##_impl_it_end(struct SNAME *_map_) \ + static struct CMC_DEF_ITER(SNAME) \ + CMC_(PFX, _impl_it_end)(struct SNAME * _map_) \ { \ - struct SNAME##_iter iter; \ + struct CMC_DEF_ITER(SNAME) iter; \ \ - PFX##_iter_init(&iter, _map_); \ - PFX##_iter_to_end(&iter); \ + CMC_(PFX, _iter_init)(&iter, _map_); \ + CMC_(PFX, _iter_to_end)(&iter); \ \ return iter; \ } -#endif /* CMC_HASHBIDIMAP_H */ +#endif /* CMC_CMC_HASHBIDIMAP_H */ diff --git a/src/cmc/hashmap.h b/src/cmc/hashmap.h index 33bafb3..d64dcaf 100644 --- a/src/cmc/hashmap.h +++ b/src/cmc/hashmap.h @@ -16,8 +16,8 @@ * hashtable with linear probing and robin hood hashing. */ -#ifndef CMC_HASHMAP_H -#define CMC_HASHMAP_H +#ifndef CMC_CMC_HASHMAP_H +#define CMC_CMC_HASHMAP_H /* ------------------------------------------------------------------------- * Core functionalities of the C Macro Collections Library @@ -33,38 +33,43 @@ * HashMap Specific * ------------------------------------------------------------------------- */ /* to_string format */ -static const char *cmc_string_fmt_hashmap = "struct %s<%s, %s> " - "at %p { " - "buffer:%p, " - "capacity:%" PRIuMAX ", " - "count:%" PRIuMAX ", " - "load:%lf, " - "flag:%d, " - "f_key:%p, " - "f_val:%p, " - "alloc:%p, " - "callbacks:%p }"; +static const char *cmc_cmc_string_fmt_hashmap = "struct %s<%s, %s> " + "at %p { " + "buffer:%p, " + "capacity:%" PRIuMAX ", " + "count:%" PRIuMAX ", " + "load:%lf, " + "flag:%d, " + "f_key:%p, " + "f_val:%p, " + "alloc:%p, " + "callbacks:%p }"; -#define CMC_GENERATE_HASHMAP(PFX, SNAME, K, V) \ - CMC_GENERATE_HASHMAP_HEADER(PFX, SNAME, K, V) \ - CMC_GENERATE_HASHMAP_SOURCE(PFX, SNAME, K, V) +/** + * Core HashMap implementation + */ +#define CMC_CMC_HASHMAP_CORE(BODY) \ + CMC_CMC_HASHMAP_CORE_HEADER(BODY) \ + CMC_CMC_HASHMAP_CORE_SOURCE(BODY) -#define CMC_WRAPGEN_HASHMAP_HEADER(PFX, SNAME, K, V) \ - CMC_GENERATE_HASHMAP_HEADER(PFX, SNAME, K, V) +#define CMC_CMC_HASHMAP_CORE_HEADER(BODY) \ + CMC_CMC_HASHMAP_CORE_HEADER_(CMC_PARAM_PFX(BODY), CMC_PARAM_SNAME(BODY), \ + CMC_PARAM_K(BODY), CMC_PARAM_V(BODY)) -#define CMC_WRAPGEN_HASHMAP_SOURCE(PFX, SNAME, K, V) \ - CMC_GENERATE_HASHMAP_SOURCE(PFX, SNAME, K, V) +#define CMC_CMC_HASHMAP_CORE_SOURCE(BODY) \ + CMC_CMC_HASHMAP_CORE_SOURCE_(CMC_PARAM_PFX(BODY), CMC_PARAM_SNAME(BODY), \ + CMC_PARAM_K(BODY), CMC_PARAM_V(BODY)) /* ------------------------------------------------------------------------- * Header * ------------------------------------------------------------------------- */ -#define CMC_GENERATE_HASHMAP_HEADER(PFX, SNAME, K, V) \ +#define CMC_CMC_HASHMAP_CORE_HEADER_(PFX, SNAME, K, V) \ \ /* Hashmap Structure */ \ struct SNAME \ { \ /* Array of Entries */ \ - struct SNAME##_entry *buffer; \ + struct CMC_DEF_ENTRY(SNAME) * buffer; \ \ /* Current array capacity */ \ size_t capacity; \ @@ -79,10 +84,10 @@ static const char *cmc_string_fmt_hashmap = "struct %s<%s, %s> " int flag; \ \ /* Key function table */ \ - struct SNAME##_fkey *f_key; \ + struct CMC_DEF_FKEY(SNAME) * f_key; \ \ /* Value function table */ \ - struct SNAME##_fval *f_val; \ + struct CMC_DEF_FVAL(SNAME) * f_val; \ \ /* Custom allocation functions */ \ struct cmc_alloc_node *alloc; \ @@ -92,7 +97,7 @@ static const char *cmc_string_fmt_hashmap = "struct %s<%s, %s> " }; \ \ /* Hashmap Entry */ \ - struct SNAME##_entry \ + struct CMC_DEF_ENTRY(SNAME) \ { \ /* Entry Key */ \ K key; \ @@ -109,7 +114,7 @@ static const char *cmc_string_fmt_hashmap = "struct %s<%s, %s> " }; \ \ /* Key struct function table */ \ - struct SNAME##_fkey \ + struct CMC_DEF_FKEY(SNAME) \ { \ /* Comparator function */ \ int (*cmp)(K, K); \ @@ -131,7 +136,7 @@ static const char *cmc_string_fmt_hashmap = "struct %s<%s, %s> " }; \ \ /* Value struct function table */ \ - struct SNAME##_fval \ + struct CMC_DEF_FVAL(SNAME) \ { \ /* Comparator function */ \ int (*cmp)(V, V); \ @@ -153,7 +158,7 @@ static const char *cmc_string_fmt_hashmap = "struct %s<%s, %s> " }; \ \ /* Hashmap Iterator */ \ - struct SNAME##_iter \ + struct CMC_DEF_ITER(SNAME) \ { \ /* Target hashmap */ \ struct SNAME *target; \ @@ -179,1046 +184,1012 @@ static const char *cmc_string_fmt_hashmap = "struct %s<%s, %s> " \ /* Collection Functions */ \ /* Collection Allocation and Deallocation */ \ - struct SNAME *PFX##_new(size_t capacity, double load, \ - struct SNAME##_fkey *f_key, \ - struct SNAME##_fval *f_val); \ - struct SNAME *PFX##_new_custom( \ - size_t capacity, double load, struct SNAME##_fkey *f_key, \ - struct SNAME##_fval *f_val, struct cmc_alloc_node *alloc, \ - struct cmc_callbacks *callbacks); \ - struct SNAME PFX##_init(size_t capacity, double load, \ - struct SNAME##_fkey *f_key, \ - struct SNAME##_fval *f_val); \ - struct SNAME PFX##_init_custom( \ - size_t capacity, double load, struct SNAME##_fkey *f_key, \ - struct SNAME##_fval *f_val, struct cmc_alloc_node *alloc, \ - struct cmc_callbacks *callbacks); \ - void PFX##_clear(struct SNAME *_map_); \ - void PFX##_free(struct SNAME *_map_); \ - void PFX##_release(struct SNAME _map_); \ + struct SNAME *CMC_(PFX, _new)(size_t capacity, double load, \ + struct CMC_DEF_FKEY(SNAME) * f_key, \ + struct CMC_DEF_FVAL(SNAME) * f_val); \ + struct SNAME *CMC_(PFX, _new_custom)( \ + size_t capacity, double load, struct CMC_DEF_FKEY(SNAME) * f_key, \ + struct CMC_DEF_FVAL(SNAME) * f_val, struct cmc_alloc_node * alloc, \ + struct cmc_callbacks * callbacks); \ + void CMC_(PFX, _clear)(struct SNAME * _map_); \ + void CMC_(PFX, _free)(struct SNAME * _map_); \ + void CMC_(PFX, _release)(struct SNAME _map_); \ /* Customization of Allocation and Callbacks */ \ - void PFX##_customize(struct SNAME *_map_, struct cmc_alloc_node *alloc, \ - struct cmc_callbacks *callbacks); \ + void CMC_(PFX, _customize)(struct SNAME * _map_, \ + struct cmc_alloc_node * alloc, \ + struct cmc_callbacks * callbacks); \ /* Collection Input and Output */ \ - bool PFX##_insert(struct SNAME *_map_, K key, V value); \ - bool PFX##_update(struct SNAME *_map_, K key, V new_value, V *old_value); \ - bool PFX##_remove(struct SNAME *_map_, K key, V *out_value); \ + bool CMC_(PFX, _insert)(struct SNAME * _map_, K key, V value); \ + bool CMC_(PFX, _update)(struct SNAME * _map_, K key, V new_value, \ + V * old_value); \ + bool CMC_(PFX, _remove)(struct SNAME * _map_, K key, V * out_value); \ /* Element Access */ \ - bool PFX##_max(struct SNAME *_map_, K *key, V *value); \ - bool PFX##_min(struct SNAME *_map_, K *key, V *value); \ - V PFX##_get(struct SNAME *_map_, K key); \ - V *PFX##_get_ref(struct SNAME *_map_, K key); \ + bool CMC_(PFX, _max)(struct SNAME * _map_, K * key, V * value); \ + bool CMC_(PFX, _min)(struct SNAME * _map_, K * key, V * value); \ + V CMC_(PFX, _get)(struct SNAME * _map_, K key); \ + V *CMC_(PFX, _get_ref)(struct SNAME * _map_, K key); \ /* Collection State */ \ - bool PFX##_contains(struct SNAME *_map_, K key); \ - bool PFX##_empty(struct SNAME *_map_); \ - bool PFX##_full(struct SNAME *_map_); \ - size_t PFX##_count(struct SNAME *_map_); \ - size_t PFX##_capacity(struct SNAME *_map_); \ - double PFX##_load(struct SNAME *_map_); \ - int PFX##_flag(struct SNAME *_map_); \ + bool CMC_(PFX, _contains)(struct SNAME * _map_, K key); \ + bool CMC_(PFX, _empty)(struct SNAME * _map_); \ + bool CMC_(PFX, _full)(struct SNAME * _map_); \ + size_t CMC_(PFX, _count)(struct SNAME * _map_); \ + size_t CMC_(PFX, _capacity)(struct SNAME * _map_); \ + double CMC_(PFX, _load)(struct SNAME * _map_); \ + int CMC_(PFX, _flag)(struct SNAME * _map_); \ /* Collection Utility */ \ - bool PFX##_resize(struct SNAME *_map_, size_t capacity); \ - struct SNAME *PFX##_copy_of(struct SNAME *_map_); \ - bool PFX##_equals(struct SNAME *_map1_, struct SNAME *_map2_); \ - struct cmc_string PFX##_to_string(struct SNAME *_map_); \ - bool PFX##_print(struct SNAME *_map_, FILE *fptr); \ + bool CMC_(PFX, _resize)(struct SNAME * _map_, size_t capacity); \ + struct SNAME *CMC_(PFX, _copy_of)(struct SNAME * _map_); \ + bool CMC_(PFX, _equals)(struct SNAME * _map1_, struct SNAME * _map2_); \ + struct cmc_string CMC_(PFX, _to_string)(struct SNAME * _map_); \ + bool CMC_(PFX, _print)(struct SNAME * _map_, FILE * fptr); \ \ /* Iterator Functions */ \ /* Iterator Initialization */ \ - struct SNAME##_iter PFX##_iter_start(struct SNAME *target); \ - struct SNAME##_iter PFX##_iter_end(struct SNAME *target); \ + struct CMC_DEF_ITER(SNAME) CMC_(PFX, _iter_start)(struct SNAME * target); \ + struct CMC_DEF_ITER(SNAME) CMC_(PFX, _iter_end)(struct SNAME * target); \ /* Iterator State */ \ - bool PFX##_iter_at_start(struct SNAME##_iter *iter); \ - bool PFX##_iter_at_end(struct SNAME##_iter *iter); \ + bool CMC_(PFX, _iter_at_start)(struct CMC_DEF_ITER(SNAME) * iter); \ + bool CMC_(PFX, _iter_at_end)(struct CMC_DEF_ITER(SNAME) * iter); \ /* Iterator Movement */ \ - bool PFX##_iter_to_start(struct SNAME##_iter *iter); \ - bool PFX##_iter_to_end(struct SNAME##_iter *iter); \ - bool PFX##_iter_next(struct SNAME##_iter *iter); \ - bool PFX##_iter_prev(struct SNAME##_iter *iter); \ - bool PFX##_iter_advance(struct SNAME##_iter *iter, size_t steps); \ - bool PFX##_iter_rewind(struct SNAME##_iter *iter, size_t steps); \ - bool PFX##_iter_go_to(struct SNAME##_iter *iter, size_t index); \ + bool CMC_(PFX, _iter_to_start)(struct CMC_DEF_ITER(SNAME) * iter); \ + bool CMC_(PFX, _iter_to_end)(struct CMC_DEF_ITER(SNAME) * iter); \ + bool CMC_(PFX, _iter_next)(struct CMC_DEF_ITER(SNAME) * iter); \ + bool CMC_(PFX, _iter_prev)(struct CMC_DEF_ITER(SNAME) * iter); \ + bool CMC_(PFX, _iter_advance)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t steps); \ + bool CMC_(PFX, _iter_rewind)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t steps); \ + bool CMC_(PFX, _iter_go_to)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t index); \ /* Iterator Access */ \ - K PFX##_iter_key(struct SNAME##_iter *iter); \ - V PFX##_iter_value(struct SNAME##_iter *iter); \ - V *PFX##_iter_rvalue(struct SNAME##_iter *iter); \ - size_t PFX##_iter_index(struct SNAME##_iter *iter); + K CMC_(PFX, _iter_key)(struct CMC_DEF_ITER(SNAME) * iter); \ + V CMC_(PFX, _iter_value)(struct CMC_DEF_ITER(SNAME) * iter); \ + V *CMC_(PFX, _iter_rvalue)(struct CMC_DEF_ITER(SNAME) * iter); \ + size_t CMC_(PFX, _iter_index)(struct CMC_DEF_ITER(SNAME) * iter); /* ------------------------------------------------------------------------- * Source * ------------------------------------------------------------------------- */ -#define CMC_GENERATE_HASHMAP_SOURCE(PFX, SNAME, K, V) \ - \ - /* Implementation Detail Functions */ \ - static struct SNAME##_entry *PFX##_impl_get_entry(struct SNAME *_map_, \ - K key); \ - static size_t PFX##_impl_calculate_size(size_t required); \ - \ - struct SNAME *PFX##_new(size_t capacity, double load, \ - struct SNAME##_fkey *f_key, \ - struct SNAME##_fval *f_val) \ - { \ - return PFX##_new_custom(capacity, load, f_key, f_val, NULL, NULL); \ - } \ - \ - struct SNAME *PFX##_new_custom( \ - size_t capacity, double load, struct SNAME##_fkey *f_key, \ - struct SNAME##_fval *f_val, struct cmc_alloc_node *alloc, \ - struct cmc_callbacks *callbacks) \ - { \ - if (capacity == 0 || load <= 0 || load >= 1) \ - return NULL; \ - \ - /* Prevent integer overflow */ \ - if (capacity >= UINTMAX_MAX * load) \ - return NULL; \ - \ - if (!f_key || !f_val) \ - return NULL; \ - \ - size_t real_capacity = PFX##_impl_calculate_size(capacity / load); \ - \ - if (!alloc) \ - alloc = &cmc_alloc_node_default; \ - \ - struct SNAME *_map_ = alloc->malloc(sizeof(struct SNAME)); \ - \ - if (!_map_) \ - return NULL; \ - \ - _map_->buffer = \ - alloc->calloc(real_capacity, sizeof(struct SNAME##_entry)); \ - \ - if (!_map_->buffer) \ - { \ - alloc->free(_map_); \ - return NULL; \ - } \ - \ - _map_->count = 0; \ - _map_->capacity = real_capacity; \ - _map_->load = load; \ - _map_->flag = cmc_flags.OK; \ - _map_->f_key = f_key; \ - _map_->f_val = f_val; \ - _map_->alloc = alloc; \ - _map_->callbacks = callbacks; \ - \ - return _map_; \ - } \ - struct SNAME PFX##_init(size_t capacity, double load, \ - struct SNAME##_fkey *f_key, \ - struct SNAME##_fval *f_val) \ - { \ - return PFX##_init_custom(capacity, load, f_key, f_val, NULL, NULL); \ - } \ - \ - struct SNAME PFX##_init_custom( \ - size_t capacity, double load, struct SNAME##_fkey *f_key, \ - struct SNAME##_fval *f_val, struct cmc_alloc_node *alloc, \ - struct cmc_callbacks *callbacks) \ - { \ - struct SNAME _map_ = { 0 }; \ - \ - if (capacity == 0 || load <= 0 || load >= 1) \ - return _map_; \ - \ - /* Prevent integer overflow */ \ - if (capacity >= UINTMAX_MAX * load) \ - return _map_; \ - \ - if (!f_key || !f_val) \ - return _map_; \ - \ - size_t real_capacity = PFX##_impl_calculate_size(capacity / load); \ - \ - if (!alloc) \ - alloc = &cmc_alloc_node_default; \ - \ - _map_.buffer = \ - alloc->calloc(real_capacity, sizeof(struct SNAME##_entry)); \ - \ - if (!_map_.buffer) \ - return _map_; \ - \ - _map_.count = 0; \ - _map_.capacity = real_capacity; \ - _map_.load = load; \ - _map_.flag = cmc_flags.OK; \ - _map_.f_key = f_key; \ - _map_.f_val = f_val; \ - _map_.alloc = alloc; \ - _map_.callbacks = callbacks; \ - \ - return _map_; \ - } \ - \ - void PFX##_clear(struct SNAME *_map_) \ - { \ - if (_map_->f_key->free || _map_->f_val->free) \ - { \ - for (size_t i = 0; i < _map_->capacity; i++) \ - { \ - struct SNAME##_entry *entry = &(_map_->buffer[i]); \ - \ - if (entry->state == CMC_ES_FILLED) \ - { \ - if (_map_->f_key->free) \ - _map_->f_key->free(entry->key); \ - if (_map_->f_val->free) \ - _map_->f_val->free(entry->value); \ - } \ - } \ - } \ - \ - memset(_map_->buffer, 0, \ - sizeof(struct SNAME##_entry) * _map_->capacity); \ - \ - _map_->count = 0; \ - _map_->flag = cmc_flags.OK; \ - } \ - \ - void PFX##_free(struct SNAME *_map_) \ - { \ - if (_map_->f_key->free || _map_->f_val->free) \ - { \ - for (size_t i = 0; i < _map_->capacity; i++) \ - { \ - struct SNAME##_entry *entry = &(_map_->buffer[i]); \ - \ - if (entry->state == CMC_ES_FILLED) \ - { \ - if (_map_->f_key->free) \ - _map_->f_key->free(entry->key); \ - if (_map_->f_val->free) \ - _map_->f_val->free(entry->value); \ - } \ - } \ - } \ - \ - _map_->alloc->free(_map_->buffer); \ - _map_->alloc->free(_map_); \ - } \ - \ - void PFX##_release(struct SNAME _map_) \ - { \ - if (_map_.f_key->free || _map_.f_val->free) \ - { \ - for (size_t i = 0; i < _map_.capacity; i++) \ - { \ - struct SNAME##_entry *entry = &(_map_.buffer[i]); \ - \ - if (entry->state == CMC_ES_FILLED) \ - { \ - if (_map_.f_key->free) \ - _map_.f_key->free(entry->key); \ - if (_map_.f_val->free) \ - _map_.f_val->free(entry->value); \ - } \ - } \ - } \ - \ - _map_.alloc->free(_map_.buffer); \ - } \ - \ - void PFX##_customize(struct SNAME *_map_, struct cmc_alloc_node *alloc, \ - struct cmc_callbacks *callbacks) \ - { \ - if (!alloc) \ - _map_->alloc = &cmc_alloc_node_default; \ - else \ - _map_->alloc = alloc; \ - \ - _map_->callbacks = callbacks; \ - \ - _map_->flag = cmc_flags.OK; \ - } \ - \ - bool PFX##_insert(struct SNAME *_map_, K key, V value) \ - { \ - if (PFX##_full(_map_)) \ - { \ - if (!PFX##_resize(_map_, _map_->capacity + 1)) \ - return false; \ - } \ - \ - if (PFX##_impl_get_entry(_map_, key) != NULL) \ - { \ - _map_->flag = cmc_flags.DUPLICATE; \ - return false; \ - } \ - \ - size_t hash = _map_->f_key->hash(key); \ - size_t original_pos = hash % _map_->capacity; \ - size_t pos = original_pos; \ - \ - struct SNAME##_entry *target = &(_map_->buffer[pos]); \ - \ - if (target->state == CMC_ES_EMPTY || target->state == CMC_ES_DELETED) \ - { \ - target->key = key; \ - target->value = value; \ - target->dist = 0; \ - target->state = CMC_ES_FILLED; \ - } \ - else \ - { \ - while (true) \ - { \ - pos++; \ - target = &(_map_->buffer[pos % _map_->capacity]); \ - \ - if (target->state == CMC_ES_EMPTY || \ - target->state == CMC_ES_DELETED) \ - { \ - target->key = key; \ - target->value = value; \ - target->dist = pos - original_pos; \ - target->state = CMC_ES_FILLED; \ - \ - break; \ - } \ - else if (target->dist < pos - original_pos) \ - { \ - K tmp_k = target->key; \ - V tmp_v = target->value; \ - size_t tmp_dist = target->dist; \ - \ - target->key = key; \ - target->value = value; \ - target->dist = pos - original_pos; \ - \ - key = tmp_k; \ - value = tmp_v; \ - original_pos = pos - tmp_dist; \ - } \ - } \ - } \ - \ - _map_->count++; \ - _map_->flag = cmc_flags.OK; \ - \ - if (_map_->callbacks && _map_->callbacks->create) \ - _map_->callbacks->create(); \ - \ - return true; \ - } \ - \ - bool PFX##_update(struct SNAME *_map_, K key, V new_value, V *old_value) \ - { \ - if (PFX##_empty(_map_)) \ - { \ - _map_->flag = cmc_flags.EMPTY; \ - return false; \ - } \ - \ - struct SNAME##_entry *entry = PFX##_impl_get_entry(_map_, key); \ - \ - if (!entry) \ - { \ - _map_->flag = cmc_flags.NOT_FOUND; \ - return false; \ - } \ - \ - if (old_value) \ - *old_value = entry->value; \ - \ - entry->value = new_value; \ - \ - _map_->flag = cmc_flags.OK; \ - \ - if (_map_->callbacks && _map_->callbacks->update) \ - _map_->callbacks->update(); \ - \ - return true; \ - } \ - \ - bool PFX##_remove(struct SNAME *_map_, K key, V *out_value) \ - { \ - if (PFX##_empty(_map_)) \ - { \ - _map_->flag = cmc_flags.EMPTY; \ - return false; \ - } \ - \ - struct SNAME##_entry *result = PFX##_impl_get_entry(_map_, key); \ - \ - if (result == NULL) \ - { \ - _map_->flag = cmc_flags.NOT_FOUND; \ - return false; \ - } \ - \ - if (out_value) \ - *out_value = result->value; \ - \ - result->key = (K){ 0 }; \ - result->value = (V){ 0 }; \ - result->dist = 0; \ - result->state = CMC_ES_DELETED; \ - \ - _map_->count--; \ - _map_->flag = cmc_flags.OK; \ - \ - if (_map_->callbacks && _map_->callbacks->delete) \ - _map_->callbacks->delete (); \ - \ - return true; \ - } \ - \ - bool PFX##_max(struct SNAME *_map_, K *key, V *value) \ - { \ - if (PFX##_empty(_map_)) \ - { \ - _map_->flag = cmc_flags.EMPTY; \ - return false; \ - } \ - \ - struct SNAME##_iter iter = PFX##_iter_start(_map_); \ - \ - K max_key = PFX##_iter_key(&iter); \ - V max_val = PFX##_iter_value(&iter); \ - \ - PFX##_iter_next(&iter); \ - \ - /* TODO Turn this into a normal loop */ \ - for (; !PFX##_iter_at_end(&iter); PFX##_iter_next(&iter)) \ - { \ - K iter_key = PFX##_iter_key(&iter); \ - V iter_val = PFX##_iter_value(&iter); \ - \ - if (_map_->f_key->cmp(iter_key, max_key) > 0) \ - { \ - max_key = iter_key; \ - max_val = iter_val; \ - } \ - } \ - \ - if (key) \ - *key = max_key; \ - if (value) \ - *value = max_val; \ - \ - if (_map_->callbacks && _map_->callbacks->read) \ - _map_->callbacks->read(); \ - \ - return true; \ - } \ - \ - bool PFX##_min(struct SNAME *_map_, K *key, V *value) \ - { \ - if (PFX##_empty(_map_)) \ - { \ - _map_->flag = cmc_flags.EMPTY; \ - return false; \ - } \ - \ - struct SNAME##_iter iter = PFX##_iter_start(_map_); \ - \ - K min_key = PFX##_iter_key(&iter); \ - V min_val = PFX##_iter_value(&iter); \ - \ - PFX##_iter_next(&iter); \ - \ - /* TODO Turn this into a normal loop */ \ - for (; !PFX##_iter_at_end(&iter); PFX##_iter_next(&iter)) \ - { \ - K iter_key = PFX##_iter_key(&iter); \ - V iter_val = PFX##_iter_value(&iter); \ - \ - if (_map_->f_key->cmp(iter_key, min_key) < 0) \ - { \ - min_key = iter_key; \ - min_val = iter_val; \ - } \ - } \ - \ - if (key) \ - *key = min_key; \ - if (value) \ - *value = min_val; \ - \ - if (_map_->callbacks && _map_->callbacks->read) \ - _map_->callbacks->read(); \ - \ - return true; \ - } \ - \ - V PFX##_get(struct SNAME *_map_, K key) \ - { \ - if (PFX##_empty(_map_)) \ - { \ - _map_->flag = cmc_flags.EMPTY; \ - return false; \ - } \ - \ - struct SNAME##_entry *entry = PFX##_impl_get_entry(_map_, key); \ - \ - if (!entry) \ - { \ - _map_->flag = cmc_flags.NOT_FOUND; \ - return (V){ 0 }; \ - } \ - \ - _map_->flag = cmc_flags.OK; \ - \ - if (_map_->callbacks && _map_->callbacks->read) \ - _map_->callbacks->read(); \ - \ - return entry->value; \ - } \ - \ - V *PFX##_get_ref(struct SNAME *_map_, K key) \ - { \ - if (PFX##_empty(_map_)) \ - { \ - _map_->flag = cmc_flags.EMPTY; \ - return false; \ - } \ - \ - struct SNAME##_entry *entry = PFX##_impl_get_entry(_map_, key); \ - \ - if (!entry) \ - { \ - _map_->flag = cmc_flags.NOT_FOUND; \ - return NULL; \ - } \ - \ - _map_->flag = cmc_flags.OK; \ - \ - if (_map_->callbacks && _map_->callbacks->read) \ - _map_->callbacks->read(); \ - \ - return &(entry->value); \ - } \ - \ - bool PFX##_contains(struct SNAME *_map_, K key) \ - { \ - _map_->flag = cmc_flags.OK; \ - \ - bool result = PFX##_impl_get_entry(_map_, key) != NULL; \ - \ - if (_map_->callbacks && _map_->callbacks->read) \ - _map_->callbacks->read(); \ - \ - return result; \ - } \ - \ - bool PFX##_empty(struct SNAME *_map_) \ - { \ - return _map_->count == 0; \ - } \ - \ - bool PFX##_full(struct SNAME *_map_) \ - { \ - return (double)_map_->capacity * _map_->load <= (double)_map_->count; \ - } \ - \ - size_t PFX##_count(struct SNAME *_map_) \ - { \ - return _map_->count; \ - } \ - \ - size_t PFX##_capacity(struct SNAME *_map_) \ - { \ - return _map_->capacity; \ - } \ - \ - double PFX##_load(struct SNAME *_map_) \ - { \ - return _map_->load; \ - } \ - \ - int PFX##_flag(struct SNAME *_map_) \ - { \ - return _map_->flag; \ - } \ - \ - bool PFX##_resize(struct SNAME *_map_, size_t capacity) \ - { \ - _map_->flag = cmc_flags.OK; \ - \ - if (_map_->capacity == capacity) \ - goto success; \ - \ - if (_map_->capacity > capacity / _map_->load) \ - goto success; \ - \ - /* Prevent integer overflow */ \ - if (capacity >= UINTMAX_MAX * _map_->load) \ - { \ - _map_->flag = cmc_flags.ERROR; \ - return false; \ - } \ - \ - /* Calculate required capacity based on the prime numbers */ \ - size_t theoretical_size = PFX##_impl_calculate_size(capacity); \ - \ - /* Not possible to shrink with current available prime numbers */ \ - if (theoretical_size < _map_->count / _map_->load) \ - { \ - _map_->flag = cmc_flags.INVALID; \ - return false; \ - } \ - \ - /* No callbacks since _new_map_ is just a temporary hashtable */ \ - struct SNAME *_new_map_ = \ - PFX##_new_custom(capacity, _map_->load, _map_->f_key, \ - _map_->f_val, _map_->alloc, NULL); \ - \ - if (!_new_map_) \ - { \ - _map_->flag = cmc_flags.ALLOC; \ - return false; \ - } \ - \ - struct SNAME##_iter iter = PFX##_iter_start(_map_); \ - \ - /* TODO turn this into a normal loop */ \ - for (; !PFX##_iter_at_end(&iter); PFX##_iter_next(&iter)) \ - { \ - K key = PFX##_iter_key(&iter); \ - V value = PFX##_iter_value(&iter); \ - \ - PFX##_insert(_new_map_, key, value); \ - } \ - \ - /* Unlikely */ \ - if (_map_->count != _new_map_->count) \ - { \ - PFX##_free(_new_map_); \ - \ - _map_->flag = cmc_flags.ERROR; \ - return false; \ - } \ - \ - struct SNAME##_entry *tmp_b = _map_->buffer; \ - _map_->buffer = _new_map_->buffer; \ - _new_map_->buffer = tmp_b; \ - \ - size_t tmp_c = _map_->capacity; \ - _map_->capacity = _new_map_->capacity; \ - _new_map_->capacity = tmp_c; \ - \ - /* Prevent the map from freeing the data */ \ - _new_map_->f_key = &(struct SNAME##_fkey){ NULL }; \ - _new_map_->f_val = &(struct SNAME##_fval){ NULL }; \ - \ - PFX##_free(_new_map_); \ - \ - success: \ - \ - if (_map_->callbacks && _map_->callbacks->resize) \ - _map_->callbacks->resize(); \ - \ - return true; \ - } \ - \ - struct SNAME *PFX##_copy_of(struct SNAME *_map_) \ - { \ - struct SNAME *result = PFX##_new_custom( \ - _map_->capacity * _map_->load, _map_->load, _map_->f_key, \ - _map_->f_val, _map_->alloc, _map_->callbacks); \ - \ - if (!result) \ - { \ - _map_->flag = cmc_flags.ERROR; \ - return NULL; \ - } \ - \ - if (_map_->f_key->cpy || _map_->f_val->cpy) \ - { \ - for (size_t i = 0; i < _map_->capacity; i++) \ - { \ - struct SNAME##_entry *scan = &(_map_->buffer[i]); \ - \ - if (scan->state != CMC_ES_EMPTY) \ - { \ - struct SNAME##_entry *target = &(result->buffer[i]); \ - \ - if (scan->state == CMC_ES_DELETED) \ - target->state = CMC_ES_DELETED; \ - else \ - { \ - target->state = scan->state; \ - target->dist = scan->dist; \ - \ - if (_map_->f_key->cpy) \ - target->key = _map_->f_key->cpy(scan->key); \ - else \ - target->key = scan->key; \ - \ - if (_map_->f_val->cpy) \ - target->value = _map_->f_val->cpy(scan->value); \ - else \ - target->value = scan->value; \ - } \ - } \ - } \ - } \ - else \ - memcpy(result->buffer, _map_->buffer, \ - sizeof(struct SNAME##_entry) * _map_->capacity); \ - \ - result->count = _map_->count; \ - \ - _map_->flag = cmc_flags.OK; \ - \ - return result; \ - } \ - \ - bool PFX##_equals(struct SNAME *_map1_, struct SNAME *_map2_) \ - { \ - _map1_->flag = cmc_flags.OK; \ - _map2_->flag = cmc_flags.OK; \ - \ - if (_map1_->count != _map2_->count) \ - return false; \ - \ - struct SNAME##_iter iter = PFX##_iter_start(_map1_); \ - \ - /* TODO optimize this loop */ \ - for (; !PFX##_iter_at_end(&iter); PFX##_iter_next(&iter)) \ - { \ - struct SNAME##_entry *entry = \ - PFX##_impl_get_entry(_map2_, PFX##_iter_key(&iter)); \ - \ - if (entry == NULL) \ - return false; \ - \ - if (_map1_->f_val->cmp(entry->value, PFX##_iter_value(&iter)) != \ - 0) \ - return false; \ - } \ - \ - return true; \ - } \ - \ - struct cmc_string PFX##_to_string(struct SNAME *_map_) \ - { \ - struct cmc_string str; \ - struct SNAME *m_ = _map_; \ - \ - int n = snprintf(str.s, cmc_string_len, cmc_string_fmt_hashmap, \ - #SNAME, #K, #V, m_, m_->buffer, m_->capacity, \ - m_->count, m_->load, m_->flag, m_->f_key, m_->f_val, \ - m_->alloc, m_->callbacks); \ - \ - return n >= 0 ? str : (struct cmc_string){ 0 }; \ - } \ - \ - bool PFX##_print(struct SNAME *_map_, FILE *fptr) \ - { \ - for (size_t i = 0; i < _map_->capacity; i++) \ - { \ - struct SNAME##_entry *entry = &(_map_->buffer[i]); \ - \ - if (entry->state == CMC_ES_FILLED) \ - { \ - if (!_map_->f_key->str(fptr, entry->key) || \ - !_map_->f_val->str(fptr, entry->value)) \ - return false; \ - } \ - } \ - \ - return true; \ - } \ - \ - struct SNAME##_iter PFX##_iter_start(struct SNAME *target) \ - { \ - struct SNAME##_iter iter; \ - \ - iter.target = target; \ - iter.cursor = 0; \ - iter.index = 0; \ - iter.first = 0; \ - iter.last = 0; \ - iter.start = true; \ - iter.end = PFX##_empty(target); \ - \ - if (!PFX##_empty(target)) \ - { \ - for (size_t i = 0; i < target->capacity; i++) \ - { \ - if (target->buffer[i].state == CMC_ES_FILLED) \ - { \ - iter.first = i; \ - break; \ - } \ - } \ - \ - iter.cursor = iter.first; \ - \ - for (size_t i = target->capacity; i > 0; i--) \ - { \ - if (target->buffer[i - 1].state == CMC_ES_FILLED) \ - { \ - iter.last = i - 1; \ - break; \ - } \ - } \ - } \ - \ - return iter; \ - } \ - \ - struct SNAME##_iter PFX##_iter_end(struct SNAME *target) \ - { \ - struct SNAME##_iter iter; \ - \ - iter.target = target; \ - iter.cursor = 0; \ - iter.index = 0; \ - iter.first = 0; \ - iter.last = 0; \ - iter.start = PFX##_empty(target); \ - iter.end = true; \ - \ - if (!PFX##_empty(target)) \ - { \ - for (size_t i = 0; i < target->capacity; i++) \ - { \ - if (target->buffer[i].state == CMC_ES_FILLED) \ - { \ - iter.first = i; \ - break; \ - } \ - } \ - \ - for (size_t i = target->capacity; i > 0; i--) \ - { \ - if (target->buffer[i - 1].state == CMC_ES_FILLED) \ - { \ - iter.last = i - 1; \ - break; \ - } \ - } \ - \ - iter.cursor = iter.last; \ - iter.index = target->count - 1; \ - } \ - \ - return iter; \ - } \ - \ - bool PFX##_iter_at_start(struct SNAME##_iter *iter) \ - { \ - return PFX##_empty(iter->target) || iter->start; \ - } \ - \ - bool PFX##_iter_at_end(struct SNAME##_iter *iter) \ - { \ - return PFX##_empty(iter->target) || iter->end; \ - } \ - \ - bool PFX##_iter_to_start(struct SNAME##_iter *iter) \ - { \ - if (!PFX##_empty(iter->target)) \ - { \ - iter->cursor = iter->first; \ - iter->index = 0; \ - iter->start = true; \ - iter->end = PFX##_empty(iter->target); \ - \ - return true; \ - } \ - \ - return false; \ - } \ - \ - bool PFX##_iter_to_end(struct SNAME##_iter *iter) \ - { \ - if (!PFX##_empty(iter->target)) \ - { \ - iter->cursor = iter->last; \ - iter->index = iter->target->count - 1; \ - iter->start = PFX##_empty(iter->target); \ - iter->end = true; \ - \ - return true; \ - } \ - \ - return false; \ - } \ - \ - bool PFX##_iter_next(struct SNAME##_iter *iter) \ - { \ - if (iter->end) \ - return false; \ - \ - if (iter->index + 1 == iter->target->count) \ - { \ - iter->end = true; \ - return false; \ - } \ - \ - iter->start = PFX##_empty(iter->target); \ - \ - struct SNAME##_entry *scan = &(iter->target->buffer[iter->cursor]); \ - \ - iter->index++; \ - \ - while (1) \ - { \ - iter->cursor++; \ - scan = &(iter->target->buffer[iter->cursor]); \ - \ - if (scan->state == CMC_ES_FILLED) \ - break; \ - } \ - \ - return true; \ - } \ - \ - bool PFX##_iter_prev(struct SNAME##_iter *iter) \ - { \ - if (iter->start) \ - return false; \ - \ - if (iter->index == 0) \ - { \ - iter->start = true; \ - return false; \ - } \ - \ - iter->end = PFX##_empty(iter->target); \ - \ - struct SNAME##_entry *scan = &(iter->target->buffer[iter->cursor]); \ - \ - iter->index--; \ - \ - while (1) \ - { \ - iter->cursor--; \ - scan = &(iter->target->buffer[iter->cursor]); \ - \ - if (scan->state == CMC_ES_FILLED) \ - break; \ - } \ - \ - return true; \ - } \ - \ - /* Returns true only if the iterator moved */ \ - bool PFX##_iter_advance(struct SNAME##_iter *iter, size_t steps) \ - { \ - if (iter->end) \ - return false; \ - \ - if (iter->index + 1 == iter->target->count) \ - { \ - iter->end = true; \ - return false; \ - } \ - \ - if (steps == 0 || iter->index + steps >= iter->target->count) \ - return false; \ - \ - for (size_t i = 0; i < steps; i++) \ - PFX##_iter_next(iter); \ - \ - return true; \ - } \ - \ - /* Returns true only if the iterator moved */ \ - bool PFX##_iter_rewind(struct SNAME##_iter *iter, size_t steps) \ - { \ - if (iter->start) \ - return false; \ - \ - if (iter->index == 0) \ - { \ - iter->start = true; \ - return false; \ - } \ - \ - if (steps == 0 || iter->index < steps) \ - return false; \ - \ - for (size_t i = 0; i < steps; i++) \ - PFX##_iter_prev(iter); \ - \ - return true; \ - } \ - \ - /* Returns true only if the iterator was able to be positioned at the */ \ - /* given index */ \ - bool PFX##_iter_go_to(struct SNAME##_iter *iter, size_t index) \ - { \ - if (index >= iter->target->count) \ - return false; \ - \ - if (iter->index > index) \ - return PFX##_iter_rewind(iter, iter->index - index); \ - else if (iter->index < index) \ - return PFX##_iter_advance(iter, index - iter->index); \ - \ - return true; \ - } \ - \ - K PFX##_iter_key(struct SNAME##_iter *iter) \ - { \ - if (PFX##_empty(iter->target)) \ - return (K){ 0 }; \ - \ - return iter->target->buffer[iter->cursor].key; \ - } \ - \ - V PFX##_iter_value(struct SNAME##_iter *iter) \ - { \ - if (PFX##_empty(iter->target)) \ - return (V){ 0 }; \ - \ - return iter->target->buffer[iter->cursor].value; \ - } \ - \ - V *PFX##_iter_rvalue(struct SNAME##_iter *iter) \ - { \ - if (PFX##_empty(iter->target)) \ - return NULL; \ - \ - return &(iter->target->buffer[iter->cursor].value); \ - } \ - \ - size_t PFX##_iter_index(struct SNAME##_iter *iter) \ - { \ - return iter->index; \ - } \ - \ - static struct SNAME##_entry *PFX##_impl_get_entry(struct SNAME *_map_, \ - K key) \ - { \ - size_t hash = _map_->f_key->hash(key); \ - size_t pos = hash % _map_->capacity; \ - \ - struct SNAME##_entry *target = &(_map_->buffer[pos]); \ - \ - while (target->state == CMC_ES_FILLED || \ - target->state == CMC_ES_DELETED) \ - { \ - if (_map_->f_key->cmp(target->key, key) == 0) \ - return target; \ - \ - pos++; \ - target = &(_map_->buffer[pos % _map_->capacity]); \ - } \ - \ - return NULL; \ - } \ - \ - static size_t PFX##_impl_calculate_size(size_t required) \ - { \ - const size_t count = \ - sizeof(cmc_hashtable_primes) / sizeof(cmc_hashtable_primes[0]); \ - \ - if (cmc_hashtable_primes[count - 1] < required) \ - return required; \ - \ - size_t i = 0; \ - while (cmc_hashtable_primes[i] < required) \ - i++; \ - \ - return cmc_hashtable_primes[i]; \ +#define CMC_CMC_HASHMAP_CORE_SOURCE_(PFX, SNAME, K, V) \ + \ + /* Implementation Detail Functions */ \ + static struct CMC_DEF_ENTRY(SNAME) * \ + CMC_(PFX, _impl_get_entry)(struct SNAME * _map_, K key); \ + static size_t CMC_(PFX, _impl_calculate_size)(size_t required); \ + \ + struct SNAME *CMC_(PFX, _new)(size_t capacity, double load, \ + struct CMC_DEF_FKEY(SNAME) * f_key, \ + struct CMC_DEF_FVAL(SNAME) * f_val) \ + { \ + return CMC_(PFX, _new_custom)(capacity, load, f_key, f_val, NULL, \ + NULL); \ + } \ + \ + struct SNAME *CMC_(PFX, _new_custom)( \ + size_t capacity, double load, struct CMC_DEF_FKEY(SNAME) * f_key, \ + struct CMC_DEF_FVAL(SNAME) * f_val, struct cmc_alloc_node * alloc, \ + struct cmc_callbacks * callbacks) \ + { \ + if (capacity == 0 || load <= 0 || load >= 1) \ + return NULL; \ + \ + /* Prevent integer overflow */ \ + if (capacity >= UINTMAX_MAX * load) \ + return NULL; \ + \ + if (!f_key || !f_val) \ + return NULL; \ + \ + size_t real_capacity = \ + CMC_(PFX, _impl_calculate_size)(capacity / load); \ + \ + if (!alloc) \ + alloc = &cmc_alloc_node_default; \ + \ + struct SNAME *_map_ = alloc->malloc(sizeof(struct SNAME)); \ + \ + if (!_map_) \ + return NULL; \ + \ + _map_->buffer = \ + alloc->calloc(real_capacity, sizeof(struct CMC_DEF_ENTRY(SNAME))); \ + \ + if (!_map_->buffer) \ + { \ + alloc->free(_map_); \ + return NULL; \ + } \ + \ + _map_->count = 0; \ + _map_->capacity = real_capacity; \ + _map_->load = load; \ + _map_->flag = CMC_FLAG_OK; \ + _map_->f_key = f_key; \ + _map_->f_val = f_val; \ + _map_->alloc = alloc; \ + _map_->callbacks = callbacks; \ + \ + return _map_; \ + } \ + \ + void CMC_(PFX, _clear)(struct SNAME * _map_) \ + { \ + if (_map_->f_key->free || _map_->f_val->free) \ + { \ + for (size_t i = 0; i < _map_->capacity; i++) \ + { \ + struct CMC_DEF_ENTRY(SNAME) *entry = &(_map_->buffer[i]); \ + \ + if (entry->state == CMC_ES_FILLED) \ + { \ + if (_map_->f_key->free) \ + _map_->f_key->free(entry->key); \ + if (_map_->f_val->free) \ + _map_->f_val->free(entry->value); \ + } \ + } \ + } \ + \ + memset(_map_->buffer, 0, \ + sizeof(struct CMC_DEF_ENTRY(SNAME)) * _map_->capacity); \ + \ + _map_->count = 0; \ + _map_->flag = CMC_FLAG_OK; \ + } \ + \ + void CMC_(PFX, _free)(struct SNAME * _map_) \ + { \ + if (_map_->f_key->free || _map_->f_val->free) \ + { \ + for (size_t i = 0; i < _map_->capacity; i++) \ + { \ + struct CMC_DEF_ENTRY(SNAME) *entry = &(_map_->buffer[i]); \ + \ + if (entry->state == CMC_ES_FILLED) \ + { \ + if (_map_->f_key->free) \ + _map_->f_key->free(entry->key); \ + if (_map_->f_val->free) \ + _map_->f_val->free(entry->value); \ + } \ + } \ + } \ + \ + _map_->alloc->free(_map_->buffer); \ + _map_->alloc->free(_map_); \ + } \ + \ + void CMC_(PFX, _release)(struct SNAME _map_) \ + { \ + if (_map_.f_key->free || _map_.f_val->free) \ + { \ + for (size_t i = 0; i < _map_.capacity; i++) \ + { \ + struct CMC_DEF_ENTRY(SNAME) *entry = &(_map_.buffer[i]); \ + \ + if (entry->state == CMC_ES_FILLED) \ + { \ + if (_map_.f_key->free) \ + _map_.f_key->free(entry->key); \ + if (_map_.f_val->free) \ + _map_.f_val->free(entry->value); \ + } \ + } \ + } \ + \ + _map_.alloc->free(_map_.buffer); \ + } \ + \ + void CMC_(PFX, _customize)(struct SNAME * _map_, \ + struct cmc_alloc_node * alloc, \ + struct cmc_callbacks * callbacks) \ + { \ + if (!alloc) \ + _map_->alloc = &cmc_alloc_node_default; \ + else \ + _map_->alloc = alloc; \ + \ + _map_->callbacks = callbacks; \ + \ + _map_->flag = CMC_FLAG_OK; \ + } \ + \ + bool CMC_(PFX, _insert)(struct SNAME * _map_, K key, V value) \ + { \ + if (CMC_(PFX, _full)(_map_)) \ + { \ + if (!CMC_(PFX, _resize)(_map_, _map_->capacity + 1)) \ + return false; \ + } \ + \ + if (CMC_(PFX, _impl_get_entry)(_map_, key) != NULL) \ + { \ + _map_->flag = CMC_FLAG_DUPLICATE; \ + return false; \ + } \ + \ + size_t hash = _map_->f_key->hash(key); \ + size_t original_pos = hash % _map_->capacity; \ + size_t pos = original_pos; \ + \ + struct CMC_DEF_ENTRY(SNAME) *target = &(_map_->buffer[pos]); \ + \ + if (target->state == CMC_ES_EMPTY || target->state == CMC_ES_DELETED) \ + { \ + target->key = key; \ + target->value = value; \ + target->dist = 0; \ + target->state = CMC_ES_FILLED; \ + } \ + else \ + { \ + while (true) \ + { \ + pos++; \ + target = &(_map_->buffer[pos % _map_->capacity]); \ + \ + if (target->state == CMC_ES_EMPTY || \ + target->state == CMC_ES_DELETED) \ + { \ + target->key = key; \ + target->value = value; \ + target->dist = pos - original_pos; \ + target->state = CMC_ES_FILLED; \ + \ + break; \ + } \ + else if (target->dist < pos - original_pos) \ + { \ + K tmp_k = target->key; \ + V tmp_v = target->value; \ + size_t tmp_dist = target->dist; \ + \ + target->key = key; \ + target->value = value; \ + target->dist = pos - original_pos; \ + \ + key = tmp_k; \ + value = tmp_v; \ + original_pos = pos - tmp_dist; \ + } \ + } \ + } \ + \ + _map_->count++; \ + _map_->flag = CMC_FLAG_OK; \ + \ + if (_map_->callbacks && _map_->callbacks->create) \ + _map_->callbacks->create(); \ + \ + return true; \ + } \ + \ + bool CMC_(PFX, _update)(struct SNAME * _map_, K key, V new_value, \ + V * old_value) \ + { \ + if (CMC_(PFX, _empty)(_map_)) \ + { \ + _map_->flag = CMC_FLAG_EMPTY; \ + return false; \ + } \ + \ + struct CMC_DEF_ENTRY(SNAME) *entry = \ + CMC_(PFX, _impl_get_entry)(_map_, key); \ + \ + if (!entry) \ + { \ + _map_->flag = CMC_FLAG_NOT_FOUND; \ + return false; \ + } \ + \ + if (old_value) \ + *old_value = entry->value; \ + \ + entry->value = new_value; \ + \ + _map_->flag = CMC_FLAG_OK; \ + \ + if (_map_->callbacks && _map_->callbacks->update) \ + _map_->callbacks->update(); \ + \ + return true; \ + } \ + \ + bool CMC_(PFX, _remove)(struct SNAME * _map_, K key, V * out_value) \ + { \ + if (CMC_(PFX, _empty)(_map_)) \ + { \ + _map_->flag = CMC_FLAG_EMPTY; \ + return false; \ + } \ + \ + struct CMC_DEF_ENTRY(SNAME) *result = \ + CMC_(PFX, _impl_get_entry)(_map_, key); \ + \ + if (result == NULL) \ + { \ + _map_->flag = CMC_FLAG_NOT_FOUND; \ + return false; \ + } \ + \ + if (out_value) \ + *out_value = result->value; \ + \ + result->key = (K){ 0 }; \ + result->value = (V){ 0 }; \ + result->dist = 0; \ + result->state = CMC_ES_DELETED; \ + \ + _map_->count--; \ + _map_->flag = CMC_FLAG_OK; \ + \ + if (_map_->callbacks && _map_->callbacks->delete) \ + _map_->callbacks->delete (); \ + \ + return true; \ + } \ + \ + bool CMC_(PFX, _max)(struct SNAME * _map_, K * key, V * value) \ + { \ + if (CMC_(PFX, _empty)(_map_)) \ + { \ + _map_->flag = CMC_FLAG_EMPTY; \ + return false; \ + } \ + \ + struct CMC_DEF_ITER(SNAME) iter = CMC_(PFX, _iter_start)(_map_); \ + \ + K max_key = CMC_(PFX, _iter_key)(&iter); \ + V max_val = CMC_(PFX, _iter_value)(&iter); \ + \ + CMC_(PFX, _iter_next)(&iter); \ + \ + /* TODO Turn this into a normal loop */ \ + for (; !CMC_(PFX, _iter_at_end)(&iter); CMC_(PFX, _iter_next)(&iter)) \ + { \ + K iter_key = CMC_(PFX, _iter_key)(&iter); \ + V iter_val = CMC_(PFX, _iter_value)(&iter); \ + \ + if (_map_->f_key->cmp(iter_key, max_key) > 0) \ + { \ + max_key = iter_key; \ + max_val = iter_val; \ + } \ + } \ + \ + if (key) \ + *key = max_key; \ + if (value) \ + *value = max_val; \ + \ + if (_map_->callbacks && _map_->callbacks->read) \ + _map_->callbacks->read(); \ + \ + return true; \ + } \ + \ + bool CMC_(PFX, _min)(struct SNAME * _map_, K * key, V * value) \ + { \ + if (CMC_(PFX, _empty)(_map_)) \ + { \ + _map_->flag = CMC_FLAG_EMPTY; \ + return false; \ + } \ + \ + struct CMC_DEF_ITER(SNAME) iter = CMC_(PFX, _iter_start)(_map_); \ + \ + K min_key = CMC_(PFX, _iter_key)(&iter); \ + V min_val = CMC_(PFX, _iter_value)(&iter); \ + \ + CMC_(PFX, _iter_next)(&iter); \ + \ + /* TODO Turn this into a normal loop */ \ + for (; !CMC_(PFX, _iter_at_end)(&iter); CMC_(PFX, _iter_next)(&iter)) \ + { \ + K iter_key = CMC_(PFX, _iter_key)(&iter); \ + V iter_val = CMC_(PFX, _iter_value)(&iter); \ + \ + if (_map_->f_key->cmp(iter_key, min_key) < 0) \ + { \ + min_key = iter_key; \ + min_val = iter_val; \ + } \ + } \ + \ + if (key) \ + *key = min_key; \ + if (value) \ + *value = min_val; \ + \ + if (_map_->callbacks && _map_->callbacks->read) \ + _map_->callbacks->read(); \ + \ + return true; \ + } \ + \ + V CMC_(PFX, _get)(struct SNAME * _map_, K key) \ + { \ + if (CMC_(PFX, _empty)(_map_)) \ + { \ + _map_->flag = CMC_FLAG_EMPTY; \ + return false; \ + } \ + \ + struct CMC_DEF_ENTRY(SNAME) *entry = \ + CMC_(PFX, _impl_get_entry)(_map_, key); \ + \ + if (!entry) \ + { \ + _map_->flag = CMC_FLAG_NOT_FOUND; \ + return (V){ 0 }; \ + } \ + \ + _map_->flag = CMC_FLAG_OK; \ + \ + if (_map_->callbacks && _map_->callbacks->read) \ + _map_->callbacks->read(); \ + \ + return entry->value; \ + } \ + \ + V *CMC_(PFX, _get_ref)(struct SNAME * _map_, K key) \ + { \ + if (CMC_(PFX, _empty)(_map_)) \ + { \ + _map_->flag = CMC_FLAG_EMPTY; \ + return false; \ + } \ + \ + struct CMC_DEF_ENTRY(SNAME) *entry = \ + CMC_(PFX, _impl_get_entry)(_map_, key); \ + \ + if (!entry) \ + { \ + _map_->flag = CMC_FLAG_NOT_FOUND; \ + return NULL; \ + } \ + \ + _map_->flag = CMC_FLAG_OK; \ + \ + if (_map_->callbacks && _map_->callbacks->read) \ + _map_->callbacks->read(); \ + \ + return &(entry->value); \ + } \ + \ + bool CMC_(PFX, _contains)(struct SNAME * _map_, K key) \ + { \ + _map_->flag = CMC_FLAG_OK; \ + \ + bool result = CMC_(PFX, _impl_get_entry)(_map_, key) != NULL; \ + \ + if (_map_->callbacks && _map_->callbacks->read) \ + _map_->callbacks->read(); \ + \ + return result; \ + } \ + \ + bool CMC_(PFX, _empty)(struct SNAME * _map_) \ + { \ + return _map_->count == 0; \ + } \ + \ + bool CMC_(PFX, _full)(struct SNAME * _map_) \ + { \ + return (double)_map_->capacity * _map_->load <= (double)_map_->count; \ + } \ + \ + size_t CMC_(PFX, _count)(struct SNAME * _map_) \ + { \ + return _map_->count; \ + } \ + \ + size_t CMC_(PFX, _capacity)(struct SNAME * _map_) \ + { \ + return _map_->capacity; \ + } \ + \ + double CMC_(PFX, _load)(struct SNAME * _map_) \ + { \ + return _map_->load; \ + } \ + \ + int CMC_(PFX, _flag)(struct SNAME * _map_) \ + { \ + return _map_->flag; \ + } \ + \ + bool CMC_(PFX, _resize)(struct SNAME * _map_, size_t capacity) \ + { \ + _map_->flag = CMC_FLAG_OK; \ + \ + if (_map_->capacity == capacity) \ + goto success; \ + \ + if (_map_->capacity > capacity / _map_->load) \ + goto success; \ + \ + /* Prevent integer overflow */ \ + if (capacity >= UINTMAX_MAX * _map_->load) \ + { \ + _map_->flag = CMC_FLAG_ERROR; \ + return false; \ + } \ + \ + /* Calculate required capacity based on the prime numbers */ \ + size_t theoretical_size = CMC_(PFX, _impl_calculate_size)(capacity); \ + \ + /* Not possible to shrink with current available prime numbers */ \ + if (theoretical_size < _map_->count / _map_->load) \ + { \ + _map_->flag = CMC_FLAG_INVALID; \ + return false; \ + } \ + \ + /* No callbacks since _new_map_ is just a temporary hashtable */ \ + struct SNAME *_new_map_ = \ + CMC_(PFX, _new_custom)(capacity, _map_->load, _map_->f_key, \ + _map_->f_val, _map_->alloc, NULL); \ + \ + if (!_new_map_) \ + { \ + _map_->flag = CMC_FLAG_ALLOC; \ + return false; \ + } \ + \ + struct CMC_DEF_ITER(SNAME) iter = CMC_(PFX, _iter_start)(_map_); \ + \ + /* TODO turn this into a normal loop */ \ + for (; !CMC_(PFX, _iter_at_end)(&iter); CMC_(PFX, _iter_next)(&iter)) \ + { \ + K key = CMC_(PFX, _iter_key)(&iter); \ + V value = CMC_(PFX, _iter_value)(&iter); \ + \ + CMC_(PFX, _insert)(_new_map_, key, value); \ + } \ + \ + /* Unlikely */ \ + if (_map_->count != _new_map_->count) \ + { \ + CMC_(PFX, _free)(_new_map_); \ + \ + _map_->flag = CMC_FLAG_ERROR; \ + return false; \ + } \ + \ + struct CMC_DEF_ENTRY(SNAME) *tmp_b = _map_->buffer; \ + _map_->buffer = _new_map_->buffer; \ + _new_map_->buffer = tmp_b; \ + \ + size_t tmp_c = _map_->capacity; \ + _map_->capacity = _new_map_->capacity; \ + _new_map_->capacity = tmp_c; \ + \ + /* Prevent the map from freeing the data */ \ + _new_map_->f_key = &(struct CMC_DEF_FKEY(SNAME)){ NULL }; \ + _new_map_->f_val = &(struct CMC_DEF_FVAL(SNAME)){ NULL }; \ + \ + CMC_(PFX, _free)(_new_map_); \ + \ + success: \ + \ + if (_map_->callbacks && _map_->callbacks->resize) \ + _map_->callbacks->resize(); \ + \ + return true; \ + } \ + \ + struct SNAME *CMC_(PFX, _copy_of)(struct SNAME * _map_) \ + { \ + struct SNAME *result = CMC_(PFX, _new_custom)( \ + _map_->capacity * _map_->load, _map_->load, _map_->f_key, \ + _map_->f_val, _map_->alloc, _map_->callbacks); \ + \ + if (!result) \ + { \ + _map_->flag = CMC_FLAG_ERROR; \ + return NULL; \ + } \ + \ + if (_map_->f_key->cpy || _map_->f_val->cpy) \ + { \ + for (size_t i = 0; i < _map_->capacity; i++) \ + { \ + struct CMC_DEF_ENTRY(SNAME) *scan = &(_map_->buffer[i]); \ + \ + if (scan->state != CMC_ES_EMPTY) \ + { \ + struct CMC_DEF_ENTRY(SNAME) *target = \ + &(result->buffer[i]); \ + \ + if (scan->state == CMC_ES_DELETED) \ + target->state = CMC_ES_DELETED; \ + else \ + { \ + target->state = scan->state; \ + target->dist = scan->dist; \ + \ + if (_map_->f_key->cpy) \ + target->key = _map_->f_key->cpy(scan->key); \ + else \ + target->key = scan->key; \ + \ + if (_map_->f_val->cpy) \ + target->value = _map_->f_val->cpy(scan->value); \ + else \ + target->value = scan->value; \ + } \ + } \ + } \ + } \ + else \ + memcpy(result->buffer, _map_->buffer, \ + sizeof(struct CMC_DEF_ENTRY(SNAME)) * _map_->capacity); \ + \ + result->count = _map_->count; \ + \ + _map_->flag = CMC_FLAG_OK; \ + \ + return result; \ + } \ + \ + bool CMC_(PFX, _equals)(struct SNAME * _map1_, struct SNAME * _map2_) \ + { \ + _map1_->flag = CMC_FLAG_OK; \ + _map2_->flag = CMC_FLAG_OK; \ + \ + if (_map1_->count != _map2_->count) \ + return false; \ + \ + struct CMC_DEF_ITER(SNAME) iter = CMC_(PFX, _iter_start)(_map1_); \ + \ + /* TODO optimize this loop */ \ + for (; !CMC_(PFX, _iter_at_end)(&iter); CMC_(PFX, _iter_next)(&iter)) \ + { \ + struct CMC_DEF_ENTRY(SNAME) *entry = CMC_(PFX, _impl_get_entry)( \ + _map2_, CMC_(PFX, _iter_key)(&iter)); \ + \ + if (entry == NULL) \ + return false; \ + \ + if (_map1_->f_val->cmp(entry->value, \ + CMC_(PFX, _iter_value)(&iter)) != 0) \ + return false; \ + } \ + \ + return true; \ + } \ + \ + struct cmc_string CMC_(PFX, _to_string)(struct SNAME * _map_) \ + { \ + struct cmc_string str; \ + struct SNAME *m_ = _map_; \ + \ + int n = snprintf(str.s, cmc_string_len, cmc_cmc_string_fmt_hashmap, \ + #SNAME, #K, #V, m_, m_->buffer, m_->capacity, \ + m_->count, m_->load, m_->flag, m_->f_key, m_->f_val, \ + m_->alloc, m_->callbacks); \ + \ + return n >= 0 ? str : (struct cmc_string){ 0 }; \ + } \ + \ + bool CMC_(PFX, _print)(struct SNAME * _map_, FILE * fptr) \ + { \ + for (size_t i = 0; i < _map_->capacity; i++) \ + { \ + struct CMC_DEF_ENTRY(SNAME) *entry = &(_map_->buffer[i]); \ + \ + if (entry->state == CMC_ES_FILLED) \ + { \ + if (!_map_->f_key->str(fptr, entry->key) || \ + !_map_->f_val->str(fptr, entry->value)) \ + return false; \ + } \ + } \ + \ + return true; \ + } \ + \ + struct CMC_DEF_ITER(SNAME) CMC_(PFX, _iter_start)(struct SNAME * target) \ + { \ + struct CMC_DEF_ITER(SNAME) iter; \ + \ + iter.target = target; \ + iter.cursor = 0; \ + iter.index = 0; \ + iter.first = 0; \ + iter.last = 0; \ + iter.start = true; \ + iter.end = CMC_(PFX, _empty)(target); \ + \ + if (!CMC_(PFX, _empty)(target)) \ + { \ + for (size_t i = 0; i < target->capacity; i++) \ + { \ + if (target->buffer[i].state == CMC_ES_FILLED) \ + { \ + iter.first = i; \ + break; \ + } \ + } \ + \ + iter.cursor = iter.first; \ + \ + for (size_t i = target->capacity; i > 0; i--) \ + { \ + if (target->buffer[i - 1].state == CMC_ES_FILLED) \ + { \ + iter.last = i - 1; \ + break; \ + } \ + } \ + } \ + \ + return iter; \ + } \ + \ + struct CMC_DEF_ITER(SNAME) CMC_(PFX, _iter_end)(struct SNAME * target) \ + { \ + struct CMC_DEF_ITER(SNAME) iter; \ + \ + iter.target = target; \ + iter.cursor = 0; \ + iter.index = 0; \ + iter.first = 0; \ + iter.last = 0; \ + iter.start = CMC_(PFX, _empty)(target); \ + iter.end = true; \ + \ + if (!CMC_(PFX, _empty)(target)) \ + { \ + for (size_t i = 0; i < target->capacity; i++) \ + { \ + if (target->buffer[i].state == CMC_ES_FILLED) \ + { \ + iter.first = i; \ + break; \ + } \ + } \ + \ + for (size_t i = target->capacity; i > 0; i--) \ + { \ + if (target->buffer[i - 1].state == CMC_ES_FILLED) \ + { \ + iter.last = i - 1; \ + break; \ + } \ + } \ + \ + iter.cursor = iter.last; \ + iter.index = target->count - 1; \ + } \ + \ + return iter; \ + } \ + \ + bool CMC_(PFX, _iter_at_start)(struct CMC_DEF_ITER(SNAME) * iter) \ + { \ + return CMC_(PFX, _empty)(iter->target) || iter->start; \ + } \ + \ + bool CMC_(PFX, _iter_at_end)(struct CMC_DEF_ITER(SNAME) * iter) \ + { \ + return CMC_(PFX, _empty)(iter->target) || iter->end; \ + } \ + \ + bool CMC_(PFX, _iter_to_start)(struct CMC_DEF_ITER(SNAME) * iter) \ + { \ + if (!CMC_(PFX, _empty)(iter->target)) \ + { \ + iter->cursor = iter->first; \ + iter->index = 0; \ + iter->start = true; \ + iter->end = CMC_(PFX, _empty)(iter->target); \ + \ + return true; \ + } \ + \ + return false; \ + } \ + \ + bool CMC_(PFX, _iter_to_end)(struct CMC_DEF_ITER(SNAME) * iter) \ + { \ + if (!CMC_(PFX, _empty)(iter->target)) \ + { \ + iter->cursor = iter->last; \ + iter->index = iter->target->count - 1; \ + iter->start = CMC_(PFX, _empty)(iter->target); \ + iter->end = true; \ + \ + return true; \ + } \ + \ + return false; \ + } \ + \ + bool CMC_(PFX, _iter_next)(struct CMC_DEF_ITER(SNAME) * iter) \ + { \ + if (iter->end) \ + return false; \ + \ + if (iter->index + 1 == iter->target->count) \ + { \ + iter->end = true; \ + return false; \ + } \ + \ + iter->start = CMC_(PFX, _empty)(iter->target); \ + \ + struct CMC_DEF_ENTRY(SNAME) *scan = \ + &(iter->target->buffer[iter->cursor]); \ + \ + iter->index++; \ + \ + while (1) \ + { \ + iter->cursor++; \ + scan = &(iter->target->buffer[iter->cursor]); \ + \ + if (scan->state == CMC_ES_FILLED) \ + break; \ + } \ + \ + return true; \ + } \ + \ + bool CMC_(PFX, _iter_prev)(struct CMC_DEF_ITER(SNAME) * iter) \ + { \ + if (iter->start) \ + return false; \ + \ + if (iter->index == 0) \ + { \ + iter->start = true; \ + return false; \ + } \ + \ + iter->end = CMC_(PFX, _empty)(iter->target); \ + \ + struct CMC_DEF_ENTRY(SNAME) *scan = \ + &(iter->target->buffer[iter->cursor]); \ + \ + iter->index--; \ + \ + while (1) \ + { \ + iter->cursor--; \ + scan = &(iter->target->buffer[iter->cursor]); \ + \ + if (scan->state == CMC_ES_FILLED) \ + break; \ + } \ + \ + return true; \ + } \ + \ + /* Returns true only if the iterator moved */ \ + bool CMC_(PFX, _iter_advance)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t steps) \ + { \ + if (iter->end) \ + return false; \ + \ + if (iter->index + 1 == iter->target->count) \ + { \ + iter->end = true; \ + return false; \ + } \ + \ + if (steps == 0 || iter->index + steps >= iter->target->count) \ + return false; \ + \ + for (size_t i = 0; i < steps; i++) \ + CMC_(PFX, _iter_next)(iter); \ + \ + return true; \ + } \ + \ + /* Returns true only if the iterator moved */ \ + bool CMC_(PFX, _iter_rewind)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t steps) \ + { \ + if (iter->start) \ + return false; \ + \ + if (iter->index == 0) \ + { \ + iter->start = true; \ + return false; \ + } \ + \ + if (steps == 0 || iter->index < steps) \ + return false; \ + \ + for (size_t i = 0; i < steps; i++) \ + CMC_(PFX, _iter_prev)(iter); \ + \ + return true; \ + } \ + \ + /* Returns true only if the iterator was able to be positioned at the */ \ + /* given index */ \ + bool CMC_(PFX, _iter_go_to)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t index) \ + { \ + if (index >= iter->target->count) \ + return false; \ + \ + if (iter->index > index) \ + return CMC_(PFX, _iter_rewind)(iter, iter->index - index); \ + else if (iter->index < index) \ + return CMC_(PFX, _iter_advance)(iter, index - iter->index); \ + \ + return true; \ + } \ + \ + K CMC_(PFX, _iter_key)(struct CMC_DEF_ITER(SNAME) * iter) \ + { \ + if (CMC_(PFX, _empty)(iter->target)) \ + return (K){ 0 }; \ + \ + return iter->target->buffer[iter->cursor].key; \ + } \ + \ + V CMC_(PFX, _iter_value)(struct CMC_DEF_ITER(SNAME) * iter) \ + { \ + if (CMC_(PFX, _empty)(iter->target)) \ + return (V){ 0 }; \ + \ + return iter->target->buffer[iter->cursor].value; \ + } \ + \ + V *CMC_(PFX, _iter_rvalue)(struct CMC_DEF_ITER(SNAME) * iter) \ + { \ + if (CMC_(PFX, _empty)(iter->target)) \ + return NULL; \ + \ + return &(iter->target->buffer[iter->cursor].value); \ + } \ + \ + size_t CMC_(PFX, _iter_index)(struct CMC_DEF_ITER(SNAME) * iter) \ + { \ + return iter->index; \ + } \ + \ + static struct CMC_DEF_ENTRY(SNAME) * \ + CMC_(PFX, _impl_get_entry)(struct SNAME * _map_, K key) \ + { \ + size_t hash = _map_->f_key->hash(key); \ + size_t pos = hash % _map_->capacity; \ + \ + struct CMC_DEF_ENTRY(SNAME) *target = &(_map_->buffer[pos]); \ + \ + while (target->state == CMC_ES_FILLED || \ + target->state == CMC_ES_DELETED) \ + { \ + if (_map_->f_key->cmp(target->key, key) == 0) \ + return target; \ + \ + pos++; \ + target = &(_map_->buffer[pos % _map_->capacity]); \ + } \ + \ + return NULL; \ + } \ + \ + static size_t CMC_(PFX, _impl_calculate_size)(size_t required) \ + { \ + const size_t count = \ + sizeof(cmc_hashtable_primes) / sizeof(cmc_hashtable_primes[0]); \ + \ + if (cmc_hashtable_primes[count - 1] < required) \ + return required; \ + \ + size_t i = 0; \ + while (cmc_hashtable_primes[i] < required) \ + i++; \ + \ + return cmc_hashtable_primes[i]; \ } -#endif /* CMC_HASHMAP_H */ +#endif /* CMC_CMC_HASHMAP_H */ diff --git a/src/cmc/hashmultimap.h b/src/cmc/hashmultimap.h index be8c95e..cc4461b 100644 --- a/src/cmc/hashmultimap.h +++ b/src/cmc/hashmultimap.h @@ -41,8 +41,8 @@ * the first key added will be the first to be removed. */ -#ifndef CMC_HASHMULTIMAP_H -#define CMC_HASHMULTIMAP_H +#ifndef CMC_CMC_HASHMULTIMAP_H +#define CMC_CMC_HASHMULTIMAP_H /* ------------------------------------------------------------------------- * Core functionalities of the C Macro Collections Library @@ -58,38 +58,45 @@ * HashMultiMap specific * ------------------------------------------------------------------------- */ /* to_string format */ -static const char *cmc_string_fmt_hashmultimap = "struct %s<%s, %s> " - "at %p { " - "buffer:%p, " - "capacity:%" PRIuMAX ", " - "count:%" PRIuMAX ", " - "load:%lf, " - "flag:%d, " - "f_key:%p, " - "f_val:%p, " - "alloc:%p, " - "callbacks:%p }"; +static const char *cmc_cmc_string_fmt_hashmultimap = "struct %s<%s, %s> " + "at %p { " + "buffer:%p, " + "capacity:%" PRIuMAX ", " + "count:%" PRIuMAX ", " + "load:%lf, " + "flag:%d, " + "f_key:%p, " + "f_val:%p, " + "alloc:%p, " + "callbacks:%p }"; -#define CMC_GENERATE_HASHMULTIMAP(PFX, SNAME, K, V) \ - CMC_GENERATE_HASHMULTIMAP_HEADER(PFX, SNAME, K, V) \ - CMC_GENERATE_HASHMULTIMAP_SOURCE(PFX, SNAME, K, V) +/** + * Core HashMultiMap implementation + */ +#define CMC_CMC_HASHMULTIMAP_CORE(BODY) \ + CMC_CMC_HASHMULTIMAP_CORE_HEADER(BODY) \ + CMC_CMC_HASHMULTIMAP_CORE_SOURCE(BODY) -#define CMC_WRAPGEN_HASHMULTIMAP_HEADER(PFX, SNAME, K, V) \ - CMC_GENERATE_HASHMULTIMAP_HEADER(PFX, SNAME, K, V) +#define CMC_CMC_HASHMULTIMAP_CORE_HEADER(BODY) \ + CMC_CMC_HASHMULTIMAP_CORE_HEADER_(CMC_PARAM_PFX(BODY), \ + CMC_PARAM_SNAME(BODY), \ + CMC_PARAM_K(BODY), CMC_PARAM_V(BODY)) -#define CMC_WRAPGEN_HASHMULTIMAP_SOURCE(PFX, SNAME, K, V) \ - CMC_GENERATE_HASHMULTIMAP_SOURCE(PFX, SNAME, K, V) +#define CMC_CMC_HASHMULTIMAP_CORE_SOURCE(BODY) \ + CMC_CMC_HASHMULTIMAP_CORE_SOURCE_(CMC_PARAM_PFX(BODY), \ + CMC_PARAM_SNAME(BODY), \ + CMC_PARAM_K(BODY), CMC_PARAM_V(BODY)) /* ------------------------------------------------------------------------- * Header * ------------------------------------------------------------------------- */ -#define CMC_GENERATE_HASHMULTIMAP_HEADER(PFX, SNAME, K, V) \ +#define CMC_CMC_HASHMULTIMAP_CORE_HEADER_(PFX, SNAME, K, V) \ \ /* HashMultimap Structure */ \ struct SNAME \ { \ /* Array of linked list to entries */ \ - struct SNAME##_entry *(*buffer)[2]; \ + struct CMC_DEF_ENTRY(SNAME) * (*buffer)[2]; \ \ /* Current array capacity */ \ size_t capacity; \ @@ -104,10 +111,10 @@ static const char *cmc_string_fmt_hashmultimap = "struct %s<%s, %s> " int flag; \ \ /* Key function table */ \ - struct SNAME##_fkey *f_key; \ + struct CMC_DEF_FKEY(SNAME) * f_key; \ \ /* Value function table */ \ - struct SNAME##_fval *f_val; \ + struct CMC_DEF_FVAL(SNAME) * f_val; \ \ /* Custom allocation functions */ \ struct cmc_alloc_node *alloc; \ @@ -117,7 +124,7 @@ static const char *cmc_string_fmt_hashmultimap = "struct %s<%s, %s> " }; \ \ /* HashMultimap Entry */ \ - struct SNAME##_entry \ + struct CMC_DEF_ENTRY(SNAME) \ { \ /* Entry Key */ \ K key; \ @@ -126,14 +133,14 @@ static const char *cmc_string_fmt_hashmultimap = "struct %s<%s, %s> " V value; \ \ /* Next entry on the linked list */ \ - struct SNAME##_entry *next; \ + struct CMC_DEF_ENTRY(SNAME) * next; \ \ /* Previous entry on the linked list */ \ - struct SNAME##_entry *prev; \ + struct CMC_DEF_ENTRY(SNAME) * prev; \ }; \ \ /* Key struct function table */ \ - struct SNAME##_fkey \ + struct CMC_DEF_FKEY(SNAME) \ { \ /* Comparator function */ \ int (*cmp)(K, K); \ @@ -155,7 +162,7 @@ static const char *cmc_string_fmt_hashmultimap = "struct %s<%s, %s> " }; \ \ /* Value struct function table */ \ - struct SNAME##_fval \ + struct CMC_DEF_FVAL(SNAME) \ { \ /* Comparator function */ \ int (*cmp)(V, V); \ @@ -176,13 +183,13 @@ static const char *cmc_string_fmt_hashmultimap = "struct %s<%s, %s> " int (*pri)(V, V); \ }; \ \ - struct SNAME##_iter \ + struct CMC_DEF_ITER(SNAME) \ { \ /* Target hashmultimap */ \ struct SNAME *target; \ \ /* Current entry */ \ - struct SNAME##_entry *curr_entry; \ + struct CMC_DEF_ENTRY(SNAME) * curr_entry; \ \ /* Cursor`s position (index) */ \ size_t cursor; \ @@ -205,1266 +212,1287 @@ static const char *cmc_string_fmt_hashmultimap = "struct %s<%s, %s> " \ /* Collection Functions */ \ /* Collection Allocation and Deallocation */ \ - struct SNAME *PFX##_new(size_t capacity, double load, \ - struct SNAME##_fkey *f_key, \ - struct SNAME##_fval *f_val); \ - struct SNAME *PFX##_new_custom( \ - size_t capacity, double load, struct SNAME##_fkey *f_key, \ - struct SNAME##_fval *f_val, struct cmc_alloc_node *alloc, \ - struct cmc_callbacks *callbacks); \ - void PFX##_clear(struct SNAME *_map_); \ - void PFX##_free(struct SNAME *_map_); \ + struct SNAME *CMC_(PFX, _new)(size_t capacity, double load, \ + struct CMC_DEF_FKEY(SNAME) * f_key, \ + struct CMC_DEF_FVAL(SNAME) * f_val); \ + struct SNAME *CMC_(PFX, _new_custom)( \ + size_t capacity, double load, struct CMC_DEF_FKEY(SNAME) * f_key, \ + struct CMC_DEF_FVAL(SNAME) * f_val, struct cmc_alloc_node * alloc, \ + struct cmc_callbacks * callbacks); \ + void CMC_(PFX, _clear)(struct SNAME * _map_); \ + void CMC_(PFX, _free)(struct SNAME * _map_); \ /* Customization of Allocation and Callbacks */ \ - void PFX##_customize(struct SNAME *_map_, struct cmc_alloc_node *alloc, \ - struct cmc_callbacks *callbacks); \ + void CMC_(PFX, _customize)(struct SNAME * _map_, \ + struct cmc_alloc_node * alloc, \ + struct cmc_callbacks * callbacks); \ /* Collection Input and Output */ \ - bool PFX##_insert(struct SNAME *_map_, K key, V value); \ - bool PFX##_update(struct SNAME *_map_, K key, V new_value, V *old_value); \ - size_t PFX##_update_all(struct SNAME *_map_, K key, V new_value, \ - V **old_values); \ - bool PFX##_remove(struct SNAME *_map_, K key, V *out_value); \ - size_t PFX##_remove_all(struct SNAME *_map_, K key, V **out_values); \ + bool CMC_(PFX, _insert)(struct SNAME * _map_, K key, V value); \ + bool CMC_(PFX, _update)(struct SNAME * _map_, K key, V new_value, \ + V * old_value); \ + size_t CMC_(PFX, _update_all)(struct SNAME * _map_, K key, V new_value, \ + V * *old_values); \ + bool CMC_(PFX, _remove)(struct SNAME * _map_, K key, V * out_value); \ + size_t CMC_(PFX, _remove_all)(struct SNAME * _map_, K key, \ + V * *out_values); \ /* Element Access */ \ - bool PFX##_max(struct SNAME *_map_, K *key, V *value); \ - bool PFX##_min(struct SNAME *_map_, K *key, V *value); \ - V PFX##_get(struct SNAME *_map_, K key); \ - V *PFX##_get_ref(struct SNAME *_map_, K key); \ + bool CMC_(PFX, _max)(struct SNAME * _map_, K * key, V * value); \ + bool CMC_(PFX, _min)(struct SNAME * _map_, K * key, V * value); \ + V CMC_(PFX, _get)(struct SNAME * _map_, K key); \ + V *CMC_(PFX, _get_ref)(struct SNAME * _map_, K key); \ /* Collection State */ \ - bool PFX##_contains(struct SNAME *_map_, K key); \ - bool PFX##_empty(struct SNAME *_map_); \ - bool PFX##_full(struct SNAME *_map_); \ - size_t PFX##_count(struct SNAME *_map_); \ - size_t PFX##_key_count(struct SNAME *_map_, K key); \ - size_t PFX##_capacity(struct SNAME *_map_); \ - double PFX##_load(struct SNAME *_map_); \ - int PFX##_flag(struct SNAME *_map_); \ + bool CMC_(PFX, _contains)(struct SNAME * _map_, K key); \ + bool CMC_(PFX, _empty)(struct SNAME * _map_); \ + bool CMC_(PFX, _full)(struct SNAME * _map_); \ + size_t CMC_(PFX, _count)(struct SNAME * _map_); \ + size_t CMC_(PFX, _key_count)(struct SNAME * _map_, K key); \ + size_t CMC_(PFX, _capacity)(struct SNAME * _map_); \ + double CMC_(PFX, _load)(struct SNAME * _map_); \ + int CMC_(PFX, _flag)(struct SNAME * _map_); \ /* Collection Utility */ \ - bool PFX##_resize(struct SNAME *_map_, size_t capacity); \ - struct SNAME *PFX##_copy_of(struct SNAME *_map_); \ - bool PFX##_equals(struct SNAME *_map1_, struct SNAME *_map2_); \ - struct cmc_string PFX##_to_string(struct SNAME *_map_); \ - bool PFX##_print(struct SNAME *_map_, FILE *fptr); \ + bool CMC_(PFX, _resize)(struct SNAME * _map_, size_t capacity); \ + struct SNAME *CMC_(PFX, _copy_of)(struct SNAME * _map_); \ + bool CMC_(PFX, _equals)(struct SNAME * _map1_, struct SNAME * _map2_); \ + struct cmc_string CMC_(PFX, _to_string)(struct SNAME * _map_); \ + bool CMC_(PFX, _print)(struct SNAME * _map_, FILE * fptr); \ \ /* Iterator Functions */ \ /* Iterator Initialization */ \ - struct SNAME##_iter PFX##_iter_start(struct SNAME *target); \ - struct SNAME##_iter PFX##_iter_end(struct SNAME *target); \ + struct CMC_DEF_ITER(SNAME) CMC_(PFX, _iter_start)(struct SNAME * target); \ + struct CMC_DEF_ITER(SNAME) CMC_(PFX, _iter_end)(struct SNAME * target); \ /* Iterator State */ \ - bool PFX##_iter_at_start(struct SNAME##_iter *iter); \ - bool PFX##_iter_at_end(struct SNAME##_iter *iter); \ + bool CMC_(PFX, _iter_at_start)(struct CMC_DEF_ITER(SNAME) * iter); \ + bool CMC_(PFX, _iter_at_end)(struct CMC_DEF_ITER(SNAME) * iter); \ /* Iterator Movement */ \ - bool PFX##_iter_to_start(struct SNAME##_iter *iter); \ - bool PFX##_iter_to_end(struct SNAME##_iter *iter); \ - bool PFX##_iter_next(struct SNAME##_iter *iter); \ - bool PFX##_iter_prev(struct SNAME##_iter *iter); \ - bool PFX##_iter_advance(struct SNAME##_iter *iter, size_t steps); \ - bool PFX##_iter_rewind(struct SNAME##_iter *iter, size_t steps); \ - bool PFX##_iter_go_to(struct SNAME##_iter *iter, size_t index); \ + bool CMC_(PFX, _iter_to_start)(struct CMC_DEF_ITER(SNAME) * iter); \ + bool CMC_(PFX, _iter_to_end)(struct CMC_DEF_ITER(SNAME) * iter); \ + bool CMC_(PFX, _iter_next)(struct CMC_DEF_ITER(SNAME) * iter); \ + bool CMC_(PFX, _iter_prev)(struct CMC_DEF_ITER(SNAME) * iter); \ + bool CMC_(PFX, _iter_advance)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t steps); \ + bool CMC_(PFX, _iter_rewind)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t steps); \ + bool CMC_(PFX, _iter_go_to)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t index); \ /* Iterator Access */ \ - K PFX##_iter_key(struct SNAME##_iter *iter); \ - V PFX##_iter_value(struct SNAME##_iter *iter); \ - V *PFX##_iter_rvalue(struct SNAME##_iter *iter); \ - size_t PFX##_iter_index(struct SNAME##_iter *iter); + K CMC_(PFX, _iter_key)(struct CMC_DEF_ITER(SNAME) * iter); \ + V CMC_(PFX, _iter_value)(struct CMC_DEF_ITER(SNAME) * iter); \ + V *CMC_(PFX, _iter_rvalue)(struct CMC_DEF_ITER(SNAME) * iter); \ + size_t CMC_(PFX, _iter_index)(struct CMC_DEF_ITER(SNAME) * iter); /* ------------------------------------------------------------------------- * Source * ------------------------------------------------------------------------- */ -#define CMC_GENERATE_HASHMULTIMAP_SOURCE(PFX, SNAME, K, V) \ - \ - /* Implementation Detail Functions */ \ - struct SNAME##_entry *PFX##_impl_new_entry(struct SNAME *_map_, K key, \ - V value); \ - struct SNAME##_entry *PFX##_impl_get_entry(struct SNAME *_map_, K key); \ - size_t PFX##_impl_key_count(struct SNAME *_map_, K key); \ - size_t PFX##_impl_calculate_size(size_t required); \ - \ - struct SNAME *PFX##_new(size_t capacity, double load, \ - struct SNAME##_fkey *f_key, \ - struct SNAME##_fval *f_val) \ - { \ - struct cmc_alloc_node *alloc = &cmc_alloc_node_default; \ - \ - if (capacity == 0 || load <= 0) \ - return NULL; \ - \ - /* Prevent integer overflow */ \ - if (capacity >= UINTMAX_MAX * load) \ - return NULL; \ - \ - if (!f_key || !f_val) \ - return NULL; \ - \ - size_t real_capacity = PFX##_impl_calculate_size(capacity / load); \ - \ - struct SNAME *_map_ = alloc->malloc(sizeof(struct SNAME)); \ - \ - if (!_map_) \ - return NULL; \ - \ - _map_->buffer = \ - alloc->calloc(real_capacity, sizeof(struct SNAME##_entry *[2])); \ - \ - if (!_map_->buffer) \ - { \ - alloc->free(_map_); \ - return NULL; \ - } \ - \ - _map_->count = 0; \ - _map_->capacity = real_capacity; \ - _map_->load = load; \ - _map_->flag = cmc_flags.OK; \ - _map_->f_key = f_key; \ - _map_->f_val = f_val; \ - _map_->alloc = alloc; \ - _map_->callbacks = NULL; \ - \ - return _map_; \ - } \ - \ - struct SNAME *PFX##_new_custom( \ - size_t capacity, double load, struct SNAME##_fkey *f_key, \ - struct SNAME##_fval *f_val, struct cmc_alloc_node *alloc, \ - struct cmc_callbacks *callbacks) \ - { \ - if (capacity == 0 || load <= 0) \ - return NULL; \ - \ - /* Prevent integer overflow */ \ - if (capacity >= UINTMAX_MAX * load) \ - return NULL; \ - \ - if (!f_key || !f_val) \ - return NULL; \ - \ - if (!alloc) \ - alloc = &cmc_alloc_node_default; \ - \ - size_t real_capacity = PFX##_impl_calculate_size(capacity / load); \ - \ - struct SNAME *_map_ = alloc->malloc(sizeof(struct SNAME)); \ - \ - if (!_map_) \ - return NULL; \ - \ - _map_->buffer = \ - alloc->calloc(real_capacity, sizeof(struct SNAME##_entry *[2])); \ - \ - if (!_map_->buffer) \ - { \ - alloc->free(_map_); \ - return NULL; \ - } \ - \ - _map_->count = 0; \ - _map_->capacity = real_capacity; \ - _map_->load = load; \ - _map_->flag = cmc_flags.OK; \ - _map_->f_key = f_key; \ - _map_->f_val = f_val; \ - _map_->alloc = alloc; \ - _map_->callbacks = callbacks; \ - \ - return _map_; \ - } \ - \ - void PFX##_clear(struct SNAME *_map_) \ - { \ - for (size_t i = 0; i < _map_->capacity; i++) \ - { \ - struct SNAME##_entry *scan = _map_->buffer[i][0]; \ - \ - while (scan != NULL) \ - { \ - struct SNAME##_entry *next = scan->next; \ - \ - if (_map_->f_key->free) \ - _map_->f_key->free(scan->key); \ - if (_map_->f_val->free) \ - _map_->f_val->free(scan->value); \ - \ - _map_->alloc->free(scan); \ - \ - scan = next; \ - } \ - } \ - \ - memset(_map_->buffer, 0, \ - sizeof(struct SNAME##_entry *[2]) * _map_->capacity); \ - \ - _map_->count = 0; \ - _map_->flag = cmc_flags.OK; \ - } \ - \ - void PFX##_free(struct SNAME *_map_) \ - { \ - size_t index = 0; \ - \ - while (index < _map_->capacity) \ - { \ - struct SNAME##_entry *scan = _map_->buffer[index][0]; \ - \ - if (scan != NULL) \ - { \ - if (scan->next == NULL && scan->prev == NULL) \ - { \ - if (_map_->f_key->free) \ - _map_->f_key->free(scan->key); \ - if (_map_->f_val->free) \ - _map_->f_val->free(scan->value); \ - \ - _map_->alloc->free(scan); \ - } \ - else \ - { \ - while (scan != NULL) \ - { \ - struct SNAME##_entry *tmp = scan; \ - \ - scan = scan->next; \ - \ - if (_map_->f_key->free) \ - _map_->f_key->free(tmp->key); \ - if (_map_->f_val->free) \ - _map_->f_val->free(tmp->value); \ - \ - _map_->alloc->free(tmp); \ - } \ - } \ - } \ - \ - index++; \ - } \ - \ - _map_->alloc->free(_map_->buffer); \ - _map_->alloc->free(_map_); \ - } \ - \ - void PFX##_customize(struct SNAME *_map_, struct cmc_alloc_node *alloc, \ - struct cmc_callbacks *callbacks) \ - { \ - if (!alloc) \ - _map_->alloc = &cmc_alloc_node_default; \ - else \ - _map_->alloc = alloc; \ - \ - _map_->callbacks = callbacks; \ - \ - _map_->flag = cmc_flags.OK; \ - } \ - \ - bool PFX##_insert(struct SNAME *_map_, K key, V value) \ - { \ - if (PFX##_full(_map_)) \ - { \ - if (!PFX##_resize(_map_, _map_->capacity + 1)) \ - return false; \ - } \ - \ - size_t hash = _map_->f_key->hash(key); \ - size_t pos = hash % _map_->capacity; \ - \ - struct SNAME##_entry *entry = PFX##_impl_new_entry(_map_, key, value); \ - \ - if (_map_->buffer[pos][0] == NULL) \ - { \ - _map_->buffer[pos][0] = entry; \ - _map_->buffer[pos][1] = entry; \ - } \ - else \ - { \ - entry->prev = _map_->buffer[pos][1]; \ - \ - _map_->buffer[pos][1]->next = entry; \ - _map_->buffer[pos][1] = entry; \ - } \ - \ - _map_->count++; \ - _map_->flag = cmc_flags.OK; \ - \ - if (_map_->callbacks && _map_->callbacks->create) \ - _map_->callbacks->create(); \ - \ - return true; \ - } \ - \ - bool PFX##_update(struct SNAME *_map_, K key, V new_value, V *old_value) \ - { \ - if (PFX##_empty(_map_)) \ - { \ - _map_->flag = cmc_flags.EMPTY; \ - return false; \ - } \ - \ - struct SNAME##_entry *entry = PFX##_impl_get_entry(_map_, key); \ - \ - if (!entry) \ - { \ - _map_->flag = cmc_flags.NOT_FOUND; \ - return false; \ - } \ - \ - if (old_value) \ - *old_value = entry->value; \ - \ - entry->value = new_value; \ - \ - _map_->flag = cmc_flags.OK; \ - \ - if (_map_->callbacks && _map_->callbacks->update) \ - _map_->callbacks->update(); \ - \ - return true; \ - } \ - \ - size_t PFX##_update_all(struct SNAME *_map_, K key, V new_value, \ - V **old_values) \ - { \ - if (PFX##_empty(_map_)) \ - { \ - _map_->flag = cmc_flags.EMPTY; \ - return 0; \ - } \ - \ - size_t hash = _map_->f_key->hash(key); \ - \ - struct SNAME##_entry *entry = \ - _map_->buffer[hash % _map_->capacity][0]; \ - \ - if (entry == NULL) \ - { \ - _map_->flag = cmc_flags.NOT_FOUND; \ - return 0; \ - } \ - \ - if (old_values) \ - { \ - size_t total = PFX##_impl_key_count(_map_, key); \ - \ - if (total == 0) \ - { \ - _map_->flag = cmc_flags.NOT_FOUND; \ - return 0; \ - } \ - \ - *old_values = _map_->alloc->malloc(sizeof(V) * total); \ - \ - if (!(*old_values)) \ - { \ - _map_->flag = cmc_flags.ALLOC; \ - return 0; \ - } \ - } \ - \ - size_t index = 0; \ - \ - while (entry != NULL) \ - { \ - if (_map_->f_key->cmp(entry->key, key) == 0) \ - { \ - if (old_values) \ - (*old_values)[index] = entry->value; \ - \ - index++; \ - entry->value = new_value; \ - } \ - \ - entry = entry->next; \ - } \ - \ - _map_->flag = cmc_flags.OK; \ - \ - if (_map_->callbacks && _map_->callbacks->update) \ - _map_->callbacks->update(); \ - \ - return index; \ - } \ - \ - bool PFX##_remove(struct SNAME *_map_, K key, V *out_value) \ - { \ - if (PFX##_empty(_map_)) \ - { \ - _map_->flag = cmc_flags.EMPTY; \ - return false; \ - } \ - \ - size_t hash = _map_->f_key->hash(key); \ - \ - struct SNAME##_entry **head = \ - &(_map_->buffer[hash % _map_->capacity][0]); \ - struct SNAME##_entry **tail = \ - &(_map_->buffer[hash % _map_->capacity][1]); \ - \ - if (*head == NULL) \ - { \ - _map_->flag = cmc_flags.NOT_FOUND; \ - return false; \ - } \ - \ - struct SNAME##_entry *entry = *head; \ - \ - if (entry->next == NULL && entry->prev == NULL) \ - { \ - if (_map_->f_key->cmp(entry->key, key) == 0) \ - { \ - *head = NULL; \ - *tail = NULL; \ - \ - if (out_value) \ - *out_value = entry->value; \ - } \ - else \ - { \ - _map_->flag = cmc_flags.NOT_FOUND; \ - return false; \ - } \ - } \ - else \ - { \ - bool found = false; \ - \ - while (entry != NULL) \ - { \ - if (_map_->f_key->cmp(entry->key, key) == 0) \ - { \ - if (*head == entry) \ - *head = entry->next; \ - if (*tail == entry) \ - *tail = entry->prev; \ - \ - if (entry->prev != NULL) \ - entry->prev->next = entry->next; \ - if (entry->next != NULL) \ - entry->next->prev = entry->prev; \ - \ - if (out_value) \ - *out_value = entry->value; \ - \ - found = true; \ - \ - break; \ - } \ - else \ - entry = entry->next; \ - } \ - \ - if (!found) \ - { \ - _map_->flag = cmc_flags.NOT_FOUND; \ - return false; \ - } \ - } \ - \ - _map_->alloc->free(entry); \ - \ - _map_->count--; \ - _map_->flag = cmc_flags.OK; \ - \ - if (_map_->callbacks && _map_->callbacks->delete) \ - _map_->callbacks->delete (); \ - \ - return true; \ - } \ - \ - size_t PFX##_remove_all(struct SNAME *_map_, K key, V **out_values) \ - { \ - if (PFX##_empty(_map_)) \ - { \ - _map_->flag = cmc_flags.EMPTY; \ - return false; \ - } \ - \ - size_t hash = _map_->f_key->hash(key); \ - \ - struct SNAME##_entry **head = \ - &(_map_->buffer[hash % _map_->capacity][0]); \ - struct SNAME##_entry **tail = \ - &(_map_->buffer[hash % _map_->capacity][1]); \ - \ - if (*head == NULL) \ - { \ - _map_->flag = cmc_flags.NOT_FOUND; \ - return 0; \ - } \ - \ - if (out_values) \ - { \ - size_t total = PFX##_impl_key_count(_map_, key); \ - \ - if (total == 0) \ - { \ - _map_->flag = cmc_flags.NOT_FOUND; \ - return 0; \ - } \ - \ - *out_values = _map_->alloc->malloc(sizeof(V) * total); \ - \ - if (!(*out_values)) \ - { \ - _map_->flag = cmc_flags.ALLOC; \ - return 0; \ - } \ - } \ - \ - size_t index = 0; \ - struct SNAME##_entry *entry = *head; \ - \ - if (entry->next == NULL) \ - { \ - *head = NULL; \ - *tail = NULL; \ - \ - if (out_values) \ - (*out_values)[index] = entry->value; \ - \ - index++; \ - _map_->alloc->free(entry); \ - } \ - else \ - { \ - while (entry != NULL) \ - { \ - if (_map_->f_key->cmp(entry->key, key) == 0) \ - { \ - if (*head == entry) \ - *head = entry->next; \ - if (*tail == entry) \ - *tail = entry->prev; \ - \ - struct SNAME##_entry *next = entry->next; \ - \ - if (entry->prev != NULL) \ - entry->prev->next = entry->next; \ - if (entry->next != NULL) \ - entry->next->prev = entry->prev; \ - \ - if (out_values) \ - (*out_values)[index] = entry->value; \ - \ - index++; \ - _map_->alloc->free(entry); \ - \ - entry = next; \ - } \ - else \ - entry = entry->next; \ - } \ - } \ - \ - _map_->count -= index; \ - _map_->flag = cmc_flags.OK; \ - \ - if (_map_->callbacks && _map_->callbacks->delete) \ - _map_->callbacks->delete (); \ - \ - return index; \ - } \ - \ - bool PFX##_max(struct SNAME *_map_, K *key, V *value) \ - { \ - if (PFX##_empty(_map_)) \ - { \ - _map_->flag = cmc_flags.EMPTY; \ - return false; \ - } \ - \ - K max_key; \ - V max_val; \ - \ - struct SNAME##_iter iter = PFX##_iter_start(_map_); \ - \ - /* TODO Turn this into a normal loop */ \ - for (; !PFX##_iter_at_end(&iter); PFX##_iter_next(&iter)) \ - { \ - K result_key = PFX##_iter_key(&iter); \ - V result_value = PFX##_iter_value(&iter); \ - size_t index = PFX##_iter_index(&iter); \ - \ - if (index == 0) \ - { \ - max_key = result_key; \ - max_val = result_value; \ - } \ - else if (_map_->f_key->cmp(result_key, max_key) > 0) \ - { \ - max_key = result_key; \ - max_val = result_value; \ - } \ - } \ - \ - if (key) \ - *key = max_key; \ - if (value) \ - *value = max_val; \ - \ - _map_->flag = cmc_flags.OK; \ - \ - if (_map_->callbacks && _map_->callbacks->read) \ - _map_->callbacks->read(); \ - \ - return true; \ - } \ - \ - bool PFX##_min(struct SNAME *_map_, K *key, V *value) \ - { \ - if (PFX##_empty(_map_)) \ - { \ - _map_->flag = cmc_flags.EMPTY; \ - return false; \ - } \ - \ - K min_key; \ - V min_val; \ - \ - struct SNAME##_iter iter = PFX##_iter_start(_map_); \ - \ - /* TODO Turn this into a normal loop */ \ - for (; !PFX##_iter_at_end(&iter); PFX##_iter_next(&iter)) \ - { \ - K result_key = PFX##_iter_key(&iter); \ - V result_value = PFX##_iter_value(&iter); \ - size_t index = PFX##_iter_index(&iter); \ - \ - if (index == 0) \ - { \ - min_key = result_key; \ - min_val = result_value; \ - } \ - else if (_map_->f_key->cmp(result_key, min_key) < 0) \ - { \ - min_key = result_key; \ - min_val = result_value; \ - } \ - } \ - \ - if (key) \ - *key = min_key; \ - if (value) \ - *value = min_val; \ - \ - _map_->flag = cmc_flags.OK; \ - \ - if (_map_->callbacks && _map_->callbacks->read) \ - _map_->callbacks->read(); \ - \ - return true; \ - } \ - \ - V PFX##_get(struct SNAME *_map_, K key) \ - { \ - if (PFX##_empty(_map_)) \ - { \ - _map_->flag = cmc_flags.EMPTY; \ - return false; \ - } \ - \ - struct SNAME##_entry *entry = PFX##_impl_get_entry(_map_, key); \ - \ - if (!entry) \ - { \ - _map_->flag = cmc_flags.NOT_FOUND; \ - return (V){ 0 }; \ - } \ - \ - _map_->flag = cmc_flags.OK; \ - \ - if (_map_->callbacks && _map_->callbacks->read) \ - _map_->callbacks->read(); \ - \ - return entry->value; \ - } \ - \ - V *PFX##_get_ref(struct SNAME *_map_, K key) \ - { \ - if (PFX##_empty(_map_)) \ - { \ - _map_->flag = cmc_flags.EMPTY; \ - return false; \ - } \ - \ - struct SNAME##_entry *entry = PFX##_impl_get_entry(_map_, key); \ - \ - if (!entry) \ - { \ - _map_->flag = cmc_flags.NOT_FOUND; \ - return NULL; \ - } \ - \ - _map_->flag = cmc_flags.OK; \ - \ - if (_map_->callbacks && _map_->callbacks->read) \ - _map_->callbacks->read(); \ - \ - return &(entry->value); \ - } \ - \ - bool PFX##_contains(struct SNAME *_map_, K key) \ - { \ - _map_->flag = cmc_flags.OK; \ - \ - bool result = PFX##_impl_get_entry(_map_, key) != NULL; \ - \ - if (_map_->callbacks && _map_->callbacks->read) \ - _map_->callbacks->read(); \ - \ - return result; \ - } \ - \ - bool PFX##_empty(struct SNAME *_map_) \ - { \ - return _map_->count == 0; \ - } \ - \ - bool PFX##_full(struct SNAME *_map_) \ - { \ - return (double)_map_->capacity * _map_->load <= (double)_map_->count; \ - } \ - \ - size_t PFX##_count(struct SNAME *_map_) \ - { \ - return _map_->count; \ - } \ - \ - size_t PFX##_key_count(struct SNAME *_map_, K key) \ - { \ - return PFX##_impl_key_count(_map_, key); \ - } \ - \ - size_t PFX##_capacity(struct SNAME *_map_) \ - { \ - return _map_->capacity; \ - } \ - \ - double PFX##_load(struct SNAME *_map_) \ - { \ - return _map_->load; \ - } \ - \ - int PFX##_flag(struct SNAME *_map_) \ - { \ - return _map_->flag; \ - } \ - \ - bool PFX##_resize(struct SNAME *_map_, size_t capacity) \ - { \ - _map_->flag = cmc_flags.OK; \ - \ - if (_map_->capacity == capacity) \ - goto success; \ - \ - if (_map_->capacity > capacity / _map_->load) \ - goto success; \ - \ - /* Prevent integer overflow */ \ - if (capacity >= UINTMAX_MAX * _map_->load) \ - { \ - _map_->flag = cmc_flags.ERROR; \ - return false; \ - } \ - \ - /* Calculate required capacity based on the prime numbers */ \ - size_t theoretical_size = PFX##_impl_calculate_size(capacity); \ - \ - /* Not possible to shrink with current available prime numbers */ \ - if (theoretical_size < _map_->count / _map_->load) \ - { \ - _map_->flag = cmc_flags.INVALID; \ - return false; \ - } \ - \ - /* No callbacks since _new_map_ is just a temporary hashtable */ \ - struct SNAME *_new_map_ = \ - PFX##_new_custom(capacity, _map_->load, _map_->f_key, \ - _map_->f_val, _map_->alloc, NULL); \ - \ - if (!_new_map_) \ - { \ - _map_->flag = cmc_flags.ALLOC; \ - return false; \ - } \ - \ - struct SNAME##_iter iter = PFX##_iter_start(_map_); \ - \ - /* TODO Turn this into a normal loop */ \ - for (; !PFX##_iter_at_end(&iter); PFX##_iter_next(&iter)) \ - { \ - K key = PFX##_iter_key(&iter); \ - V value = PFX##_iter_value(&iter); \ - \ - /* TODO check for errors */ \ - PFX##_insert(_new_map_, key, value); \ - } \ - \ - if (_map_->count != _new_map_->count) \ - { \ - PFX##_free(_new_map_); \ - \ - _map_->flag = cmc_flags.ERROR; \ - return false; \ - } \ - \ - struct SNAME##_entry *(*tmp_b)[2] = _map_->buffer; \ - _map_->buffer = _new_map_->buffer; \ - _new_map_->buffer = tmp_b; \ - \ - size_t tmp_c = _map_->capacity; \ - _map_->capacity = _new_map_->capacity; \ - _new_map_->capacity = tmp_c; \ - \ - /* Prevent the map from freeing the data */ \ - _new_map_->f_key = &(struct SNAME##_fkey){ NULL }; \ - _new_map_->f_val = &(struct SNAME##_fval){ NULL }; \ - \ - PFX##_free(_new_map_); \ - \ - success: \ - \ - if (_map_->callbacks && _map_->callbacks->resize) \ - _map_->callbacks->resize(); \ - \ - return true; \ - } \ - \ - struct SNAME *PFX##_copy_of(struct SNAME *_map_) \ - { \ - /* Callback will be added later */ \ - struct SNAME *result = \ - PFX##_new_custom(_map_->capacity * _map_->load, _map_->load, \ - _map_->f_key, _map_->f_val, _map_->alloc, NULL); \ - \ - if (!result) \ - { \ - _map_->flag = cmc_flags.ERROR; \ - return NULL; \ - } \ - \ - struct SNAME##_iter iter = PFX##_iter_start(_map_); \ - \ - if (!PFX##_empty(_map_)) \ - { \ - /* TODO Turn this into a normal loop */ \ - for (; !PFX##_iter_at_end(&iter); PFX##_iter_next(&iter)) \ - { \ - K key = PFX##_iter_key(&iter); \ - V value = PFX##_iter_value(&iter); \ - \ - if (_map_->f_key->cpy) \ - key = _map_->f_key->cpy(key); \ - if (_map_->f_val->cpy) \ - value = _map_->f_val->cpy(value); \ - \ - /* TODO check for errors */ \ - PFX##_insert(result, key, value); \ - } \ - } \ - \ - result->callbacks = _map_->callbacks; \ - _map_->flag = cmc_flags.OK; \ - \ - return result; \ - } \ - \ - bool PFX##_equals(struct SNAME *_map1_, struct SNAME *_map2_) \ - { \ - _map1_->flag = cmc_flags.OK; \ - _map2_->flag = cmc_flags.OK; \ - \ - if (_map1_->count != _map2_->count) \ - return false; \ - \ - struct SNAME##_iter iter = PFX##_iter_start(_map1_); \ - \ - /* TODO Turn this into a normal loop */ \ - for (; !PFX##_iter_at_end(&iter); PFX##_iter_next(&iter)) \ - { \ - K key = PFX##_iter_key(&iter); \ - \ - if (PFX##_impl_key_count(_map1_, key) != \ - PFX##_impl_key_count(_map2_, key)) \ - return false; \ - } \ - \ - return true; \ - } \ - \ - struct cmc_string PFX##_to_string(struct SNAME *_map_) \ - { \ - struct cmc_string str; \ - struct SNAME *m_ = _map_; \ - \ - int n = snprintf(str.s, cmc_string_len, cmc_string_fmt_hashmultimap, \ - #SNAME, #K, #V, m_, m_->buffer, m_->capacity, \ - m_->count, m_->load, m_->flag, m_->f_key, m_->f_val, \ - m_->alloc, m_->callbacks); \ - \ - return n >= 0 ? str : (struct cmc_string){ 0 }; \ - } \ - \ - bool PFX##_print(struct SNAME *_map_, FILE *fptr) \ - { \ - for (size_t i = 0; i < _map_->capacity; i++) \ - { \ - struct SNAME##_entry *scan = _map_->buffer[i][0]; \ - \ - while (scan != NULL) \ - { \ - if (!_map_->f_key->str(fptr, scan->key) || \ - !_map_->f_val->str(fptr, scan->value)) \ - return false; \ - \ - scan = scan->next; \ - } \ - } \ - \ - return true; \ - } \ - \ - struct SNAME##_iter PFX##_iter_start(struct SNAME *target) \ - { \ - struct SNAME##_iter iter; \ - \ - iter.target = target; \ - iter.curr_entry = NULL; \ - iter.cursor = 0; \ - iter.index = 0; \ - iter.first = 0; \ - iter.last = 0; \ - iter.start = true; \ - iter.end = PFX##_empty(target); \ - \ - if (!PFX##_empty(target)) \ - { \ - for (size_t i = 0; i < target->capacity; i++) \ - { \ - if (target->buffer[i][0] != NULL) \ - { \ - iter.curr_entry = target->buffer[i][0]; \ - iter.first = i; \ - break; \ - } \ - } \ - \ - iter.cursor = iter.first; \ - \ - for (size_t i = target->capacity; i > 0; i--) \ - { \ - if (target->buffer[i - 1][1] != NULL) \ - { \ - iter.last = i - 1; \ - break; \ - } \ - } \ - } \ - \ - return iter; \ - } \ - \ - struct SNAME##_iter PFX##_iter_end(struct SNAME *target) \ - { \ - struct SNAME##_iter iter; \ - \ - iter.target = target; \ - iter.curr_entry = NULL; \ - iter.cursor = 0; \ - iter.index = 0; \ - iter.first = 0; \ - iter.last = 0; \ - iter.start = PFX##_empty(target); \ - iter.end = true; \ - \ - if (!PFX##_empty(target)) \ - { \ - for (size_t i = 0; i < target->capacity; i++) \ - { \ - if (target->buffer[i][0] != NULL) \ - { \ - iter.first = i; \ - break; \ - } \ - } \ - \ - for (size_t i = target->capacity; i > 0; i--) \ - { \ - if (target->buffer[i - 1][1] != NULL) \ - { \ - iter.curr_entry = target->buffer[i - 1][1]; \ - iter.last = i - 1; \ - break; \ - } \ - } \ - \ - iter.cursor = iter.last; \ - iter.index = target->count - 1; \ - } \ - \ - return iter; \ - } \ - \ - bool PFX##_iter_at_start(struct SNAME##_iter *iter) \ - { \ - return PFX##_empty(iter->target) || iter->start; \ - } \ - \ - bool PFX##_iter_at_end(struct SNAME##_iter *iter) \ - { \ - return PFX##_empty(iter->target) || iter->end; \ - } \ - \ - bool PFX##_iter_to_start(struct SNAME##_iter *iter) \ - { \ - if (!PFX##_empty(iter->target)) \ - { \ - iter->cursor = iter->first; \ - iter->index = 0; \ - iter->start = true; \ - iter->end = PFX##_empty(iter->target); \ - iter->curr_entry = iter->target->buffer[iter->first][0]; \ - \ - return true; \ - } \ - \ - return false; \ - } \ - \ - bool PFX##_iter_to_end(struct SNAME##_iter *iter) \ - { \ - if (!PFX##_empty(iter->target)) \ - { \ - iter->cursor = iter->last; \ - iter->index = iter->target->count - 1; \ - iter->start = PFX##_empty(iter->target); \ - iter->end = true; \ - iter->curr_entry = iter->target->buffer[iter->last][1]; \ - \ - return true; \ - } \ - \ - return false; \ - } \ - \ - bool PFX##_iter_next(struct SNAME##_iter *iter) \ - { \ - if (iter->end) \ - return false; \ - \ - if (iter->curr_entry->next != NULL) \ - { \ - iter->curr_entry = iter->curr_entry->next; \ - iter->index++; \ - } \ - else \ - { \ - if (iter->cursor == iter->last) \ - { \ - iter->end = true; \ - return false; \ - } \ - \ - iter->cursor++; \ - \ - while (iter->target->buffer[iter->cursor][0] == NULL) \ - iter->cursor++; \ - \ - iter->curr_entry = iter->target->buffer[iter->cursor][0]; \ - \ - iter->index++; \ - } \ - \ - iter->start = PFX##_empty(iter->target); \ - \ - return true; \ - } \ - \ - bool PFX##_iter_prev(struct SNAME##_iter *iter) \ - { \ - if (iter->start) \ - return false; \ - \ - if (iter->curr_entry->prev != NULL) \ - { \ - iter->curr_entry = iter->curr_entry->prev; \ - iter->index--; \ - } \ - else \ - { \ - if (iter->cursor == iter->first) \ - { \ - iter->start = true; \ - return false; \ - } \ - \ - iter->cursor--; \ - \ - while (iter->target->buffer[iter->cursor][1] == NULL) \ - iter->cursor--; \ - \ - iter->curr_entry = iter->target->buffer[iter->cursor][1]; \ - \ - iter->index--; \ - } \ - \ - iter->end = PFX##_empty(iter->target); \ - \ - return true; \ - } \ - \ - /* Returns true only if the iterator moved */ \ - bool PFX##_iter_advance(struct SNAME##_iter *iter, size_t steps) \ - { \ - if (iter->end) \ - return false; \ - \ - if (iter->index + 1 == iter->target->count) \ - { \ - iter->end = true; \ - return false; \ - } \ - \ - if (steps == 0 || iter->index + steps >= iter->target->count) \ - return false; \ - \ - for (size_t i = 0; i < steps; i++) \ - PFX##_iter_next(iter); \ - \ - return true; \ - } \ - \ - /* Returns true only if the iterator moved */ \ - bool PFX##_iter_rewind(struct SNAME##_iter *iter, size_t steps) \ - { \ - if (iter->start) \ - return false; \ - \ - if (iter->index == 0) \ - { \ - iter->start = true; \ - return false; \ - } \ - \ - if (steps == 0 || iter->index < steps) \ - return false; \ - \ - for (size_t i = 0; i < steps; i++) \ - PFX##_iter_prev(iter); \ - \ - return true; \ - } \ - \ - /* Returns true only if the iterator was able to be positioned at the */ \ - /* given index */ \ - bool PFX##_iter_go_to(struct SNAME##_iter *iter, size_t index) \ - { \ - if (index >= iter->target->count) \ - return false; \ - \ - if (iter->index > index) \ - return PFX##_iter_rewind(iter, iter->index - index); \ - else if (iter->index < index) \ - return PFX##_iter_advance(iter, index - iter->index); \ - \ - return true; \ - } \ - \ - K PFX##_iter_key(struct SNAME##_iter *iter) \ - { \ - if (PFX##_empty(iter->target)) \ - return (K){ 0 }; \ - \ - return iter->curr_entry->key; \ - } \ - \ - V PFX##_iter_value(struct SNAME##_iter *iter) \ - { \ - if (PFX##_empty(iter->target)) \ - return (V){ 0 }; \ - \ - return iter->curr_entry->value; \ - } \ - \ - V *PFX##_iter_rvalue(struct SNAME##_iter *iter) \ - { \ - if (PFX##_empty(iter->target)) \ - return NULL; \ - \ - return &(iter->curr_entry->value); \ - } \ - \ - size_t PFX##_iter_index(struct SNAME##_iter *iter) \ - { \ - return iter->index; \ - } \ - \ - struct SNAME##_entry *PFX##_impl_new_entry(struct SNAME *_map_, K key, \ - V value) \ - { \ - struct SNAME##_entry *entry = \ - _map_->alloc->malloc(sizeof(struct SNAME##_entry)); \ - \ - if (!entry) \ - return NULL; \ - \ - entry->key = key; \ - entry->value = value; \ - entry->next = NULL; \ - entry->prev = NULL; \ - \ - return entry; \ - } \ - \ - struct SNAME##_entry *PFX##_impl_get_entry(struct SNAME *_map_, K key) \ - { \ - size_t hash = _map_->f_key->hash(key); \ - \ - struct SNAME##_entry *entry = \ - _map_->buffer[hash % _map_->capacity][0]; \ - \ - while (entry != NULL) \ - { \ - if (_map_->f_key->cmp(entry->key, key) == 0) \ - return entry; \ - \ - entry = entry->next; \ - } \ - \ - return NULL; \ - } \ - \ - size_t PFX##_impl_key_count(struct SNAME *_map_, K key) \ - { \ - size_t hash = _map_->f_key->hash(key); \ - \ - struct SNAME##_entry *entry = \ - _map_->buffer[hash % _map_->capacity][0]; \ - \ - size_t total_count = 0; \ - \ - if (!entry) \ - return total_count; \ - \ - while (entry != NULL) \ - { \ - if (_map_->f_key->cmp(entry->key, key) == 0) \ - total_count++; \ - \ - entry = entry->next; \ - } \ - \ - return total_count; \ - } \ - \ - size_t PFX##_impl_calculate_size(size_t required) \ - { \ - const size_t count = \ - sizeof(cmc_hashtable_primes) / sizeof(cmc_hashtable_primes[0]); \ - \ - if (cmc_hashtable_primes[count - 1] < required) \ - return required; \ - \ - size_t i = 0; \ - while (cmc_hashtable_primes[i] < required) \ - i++; \ - \ - return cmc_hashtable_primes[i]; \ +#define CMC_CMC_HASHMULTIMAP_CORE_SOURCE_(PFX, SNAME, K, V) \ + \ + /* Implementation Detail Functions */ \ + struct CMC_DEF_ENTRY(SNAME) * \ + CMC_(PFX, _impl_new_entry)(struct SNAME * _map_, K key, V value); \ + struct CMC_DEF_ENTRY(SNAME) * \ + CMC_(PFX, _impl_get_entry)(struct SNAME * _map_, K key); \ + size_t CMC_(PFX, _impl_key_count)(struct SNAME * _map_, K key); \ + size_t CMC_(PFX, _impl_calculate_size)(size_t required); \ + \ + struct SNAME *CMC_(PFX, _new)(size_t capacity, double load, \ + struct CMC_DEF_FKEY(SNAME) * f_key, \ + struct CMC_DEF_FVAL(SNAME) * f_val) \ + { \ + struct cmc_alloc_node *alloc = &cmc_alloc_node_default; \ + \ + if (capacity == 0 || load <= 0) \ + return NULL; \ + \ + /* Prevent integer overflow */ \ + if (capacity >= UINTMAX_MAX * load) \ + return NULL; \ + \ + if (!f_key || !f_val) \ + return NULL; \ + \ + size_t real_capacity = \ + CMC_(PFX, _impl_calculate_size)(capacity / load); \ + \ + struct SNAME *_map_ = alloc->malloc(sizeof(struct SNAME)); \ + \ + if (!_map_) \ + return NULL; \ + \ + _map_->buffer = alloc->calloc( \ + real_capacity, sizeof(struct CMC_DEF_ENTRY(SNAME) *[2])); \ + \ + if (!_map_->buffer) \ + { \ + alloc->free(_map_); \ + return NULL; \ + } \ + \ + _map_->count = 0; \ + _map_->capacity = real_capacity; \ + _map_->load = load; \ + _map_->flag = CMC_FLAG_OK; \ + _map_->f_key = f_key; \ + _map_->f_val = f_val; \ + _map_->alloc = alloc; \ + _map_->callbacks = NULL; \ + \ + return _map_; \ + } \ + \ + struct SNAME *CMC_(PFX, _new_custom)( \ + size_t capacity, double load, struct CMC_DEF_FKEY(SNAME) * f_key, \ + struct CMC_DEF_FVAL(SNAME) * f_val, struct cmc_alloc_node * alloc, \ + struct cmc_callbacks * callbacks) \ + { \ + if (capacity == 0 || load <= 0) \ + return NULL; \ + \ + /* Prevent integer overflow */ \ + if (capacity >= UINTMAX_MAX * load) \ + return NULL; \ + \ + if (!f_key || !f_val) \ + return NULL; \ + \ + if (!alloc) \ + alloc = &cmc_alloc_node_default; \ + \ + size_t real_capacity = \ + CMC_(PFX, _impl_calculate_size)(capacity / load); \ + \ + struct SNAME *_map_ = alloc->malloc(sizeof(struct SNAME)); \ + \ + if (!_map_) \ + return NULL; \ + \ + _map_->buffer = alloc->calloc( \ + real_capacity, sizeof(struct CMC_DEF_ENTRY(SNAME) *[2])); \ + \ + if (!_map_->buffer) \ + { \ + alloc->free(_map_); \ + return NULL; \ + } \ + \ + _map_->count = 0; \ + _map_->capacity = real_capacity; \ + _map_->load = load; \ + _map_->flag = CMC_FLAG_OK; \ + _map_->f_key = f_key; \ + _map_->f_val = f_val; \ + _map_->alloc = alloc; \ + _map_->callbacks = callbacks; \ + \ + return _map_; \ + } \ + \ + void CMC_(PFX, _clear)(struct SNAME * _map_) \ + { \ + for (size_t i = 0; i < _map_->capacity; i++) \ + { \ + struct CMC_DEF_ENTRY(SNAME) *scan = _map_->buffer[i][0]; \ + \ + while (scan != NULL) \ + { \ + struct CMC_DEF_ENTRY(SNAME) *next = scan->next; \ + \ + if (_map_->f_key->free) \ + _map_->f_key->free(scan->key); \ + if (_map_->f_val->free) \ + _map_->f_val->free(scan->value); \ + \ + _map_->alloc->free(scan); \ + \ + scan = next; \ + } \ + } \ + \ + memset(_map_->buffer, 0, \ + sizeof(struct CMC_DEF_ENTRY(SNAME) *[2]) * _map_->capacity); \ + \ + _map_->count = 0; \ + _map_->flag = CMC_FLAG_OK; \ + } \ + \ + void CMC_(PFX, _free)(struct SNAME * _map_) \ + { \ + size_t index = 0; \ + \ + while (index < _map_->capacity) \ + { \ + struct CMC_DEF_ENTRY(SNAME) *scan = _map_->buffer[index][0]; \ + \ + if (scan != NULL) \ + { \ + if (scan->next == NULL && scan->prev == NULL) \ + { \ + if (_map_->f_key->free) \ + _map_->f_key->free(scan->key); \ + if (_map_->f_val->free) \ + _map_->f_val->free(scan->value); \ + \ + _map_->alloc->free(scan); \ + } \ + else \ + { \ + while (scan != NULL) \ + { \ + struct CMC_DEF_ENTRY(SNAME) *tmp = scan; \ + \ + scan = scan->next; \ + \ + if (_map_->f_key->free) \ + _map_->f_key->free(tmp->key); \ + if (_map_->f_val->free) \ + _map_->f_val->free(tmp->value); \ + \ + _map_->alloc->free(tmp); \ + } \ + } \ + } \ + \ + index++; \ + } \ + \ + _map_->alloc->free(_map_->buffer); \ + _map_->alloc->free(_map_); \ + } \ + \ + void CMC_(PFX, _customize)(struct SNAME * _map_, \ + struct cmc_alloc_node * alloc, \ + struct cmc_callbacks * callbacks) \ + { \ + if (!alloc) \ + _map_->alloc = &cmc_alloc_node_default; \ + else \ + _map_->alloc = alloc; \ + \ + _map_->callbacks = callbacks; \ + \ + _map_->flag = CMC_FLAG_OK; \ + } \ + \ + bool CMC_(PFX, _insert)(struct SNAME * _map_, K key, V value) \ + { \ + if (CMC_(PFX, _full)(_map_)) \ + { \ + if (!CMC_(PFX, _resize)(_map_, _map_->capacity + 1)) \ + return false; \ + } \ + \ + size_t hash = _map_->f_key->hash(key); \ + size_t pos = hash % _map_->capacity; \ + \ + struct CMC_DEF_ENTRY(SNAME) *entry = \ + CMC_(PFX, _impl_new_entry)(_map_, key, value); \ + \ + if (_map_->buffer[pos][0] == NULL) \ + { \ + _map_->buffer[pos][0] = entry; \ + _map_->buffer[pos][1] = entry; \ + } \ + else \ + { \ + entry->prev = _map_->buffer[pos][1]; \ + \ + _map_->buffer[pos][1]->next = entry; \ + _map_->buffer[pos][1] = entry; \ + } \ + \ + _map_->count++; \ + _map_->flag = CMC_FLAG_OK; \ + \ + if (_map_->callbacks && _map_->callbacks->create) \ + _map_->callbacks->create(); \ + \ + return true; \ + } \ + \ + bool CMC_(PFX, _update)(struct SNAME * _map_, K key, V new_value, \ + V * old_value) \ + { \ + if (CMC_(PFX, _empty)(_map_)) \ + { \ + _map_->flag = CMC_FLAG_EMPTY; \ + return false; \ + } \ + \ + struct CMC_DEF_ENTRY(SNAME) *entry = \ + CMC_(PFX, _impl_get_entry)(_map_, key); \ + \ + if (!entry) \ + { \ + _map_->flag = CMC_FLAG_NOT_FOUND; \ + return false; \ + } \ + \ + if (old_value) \ + *old_value = entry->value; \ + \ + entry->value = new_value; \ + \ + _map_->flag = CMC_FLAG_OK; \ + \ + if (_map_->callbacks && _map_->callbacks->update) \ + _map_->callbacks->update(); \ + \ + return true; \ + } \ + \ + size_t CMC_(PFX, _update_all)(struct SNAME * _map_, K key, V new_value, \ + V * *old_values) \ + { \ + if (CMC_(PFX, _empty)(_map_)) \ + { \ + _map_->flag = CMC_FLAG_EMPTY; \ + return 0; \ + } \ + \ + size_t hash = _map_->f_key->hash(key); \ + \ + struct CMC_DEF_ENTRY(SNAME) *entry = \ + _map_->buffer[hash % _map_->capacity][0]; \ + \ + if (entry == NULL) \ + { \ + _map_->flag = CMC_FLAG_NOT_FOUND; \ + return 0; \ + } \ + \ + if (old_values) \ + { \ + size_t total = CMC_(PFX, _impl_key_count)(_map_, key); \ + \ + if (total == 0) \ + { \ + _map_->flag = CMC_FLAG_NOT_FOUND; \ + return 0; \ + } \ + \ + *old_values = _map_->alloc->malloc(sizeof(V) * total); \ + \ + if (!(*old_values)) \ + { \ + _map_->flag = CMC_FLAG_ALLOC; \ + return 0; \ + } \ + } \ + \ + size_t index = 0; \ + \ + while (entry != NULL) \ + { \ + if (_map_->f_key->cmp(entry->key, key) == 0) \ + { \ + if (old_values) \ + (*old_values)[index] = entry->value; \ + \ + index++; \ + entry->value = new_value; \ + } \ + \ + entry = entry->next; \ + } \ + \ + _map_->flag = CMC_FLAG_OK; \ + \ + if (_map_->callbacks && _map_->callbacks->update) \ + _map_->callbacks->update(); \ + \ + return index; \ + } \ + \ + bool CMC_(PFX, _remove)(struct SNAME * _map_, K key, V * out_value) \ + { \ + if (CMC_(PFX, _empty)(_map_)) \ + { \ + _map_->flag = CMC_FLAG_EMPTY; \ + return false; \ + } \ + \ + size_t hash = _map_->f_key->hash(key); \ + \ + struct CMC_DEF_ENTRY(SNAME) **head = \ + &(_map_->buffer[hash % _map_->capacity][0]); \ + struct CMC_DEF_ENTRY(SNAME) **tail = \ + &(_map_->buffer[hash % _map_->capacity][1]); \ + \ + if (*head == NULL) \ + { \ + _map_->flag = CMC_FLAG_NOT_FOUND; \ + return false; \ + } \ + \ + struct CMC_DEF_ENTRY(SNAME) *entry = *head; \ + \ + if (entry->next == NULL && entry->prev == NULL) \ + { \ + if (_map_->f_key->cmp(entry->key, key) == 0) \ + { \ + *head = NULL; \ + *tail = NULL; \ + \ + if (out_value) \ + *out_value = entry->value; \ + } \ + else \ + { \ + _map_->flag = CMC_FLAG_NOT_FOUND; \ + return false; \ + } \ + } \ + else \ + { \ + bool found = false; \ + \ + while (entry != NULL) \ + { \ + if (_map_->f_key->cmp(entry->key, key) == 0) \ + { \ + if (*head == entry) \ + *head = entry->next; \ + if (*tail == entry) \ + *tail = entry->prev; \ + \ + if (entry->prev != NULL) \ + entry->prev->next = entry->next; \ + if (entry->next != NULL) \ + entry->next->prev = entry->prev; \ + \ + if (out_value) \ + *out_value = entry->value; \ + \ + found = true; \ + \ + break; \ + } \ + else \ + entry = entry->next; \ + } \ + \ + if (!found) \ + { \ + _map_->flag = CMC_FLAG_NOT_FOUND; \ + return false; \ + } \ + } \ + \ + _map_->alloc->free(entry); \ + \ + _map_->count--; \ + _map_->flag = CMC_FLAG_OK; \ + \ + if (_map_->callbacks && _map_->callbacks->delete) \ + _map_->callbacks->delete (); \ + \ + return true; \ + } \ + \ + size_t CMC_(PFX, _remove_all)(struct SNAME * _map_, K key, \ + V * *out_values) \ + { \ + if (CMC_(PFX, _empty)(_map_)) \ + { \ + _map_->flag = CMC_FLAG_EMPTY; \ + return false; \ + } \ + \ + size_t hash = _map_->f_key->hash(key); \ + \ + struct CMC_DEF_ENTRY(SNAME) **head = \ + &(_map_->buffer[hash % _map_->capacity][0]); \ + struct CMC_DEF_ENTRY(SNAME) **tail = \ + &(_map_->buffer[hash % _map_->capacity][1]); \ + \ + if (*head == NULL) \ + { \ + _map_->flag = CMC_FLAG_NOT_FOUND; \ + return 0; \ + } \ + \ + if (out_values) \ + { \ + size_t total = CMC_(PFX, _impl_key_count)(_map_, key); \ + \ + if (total == 0) \ + { \ + _map_->flag = CMC_FLAG_NOT_FOUND; \ + return 0; \ + } \ + \ + *out_values = _map_->alloc->malloc(sizeof(V) * total); \ + \ + if (!(*out_values)) \ + { \ + _map_->flag = CMC_FLAG_ALLOC; \ + return 0; \ + } \ + } \ + \ + size_t index = 0; \ + struct CMC_DEF_ENTRY(SNAME) *entry = *head; \ + \ + if (entry->next == NULL) \ + { \ + *head = NULL; \ + *tail = NULL; \ + \ + if (out_values) \ + (*out_values)[index] = entry->value; \ + \ + index++; \ + _map_->alloc->free(entry); \ + } \ + else \ + { \ + while (entry != NULL) \ + { \ + if (_map_->f_key->cmp(entry->key, key) == 0) \ + { \ + if (*head == entry) \ + *head = entry->next; \ + if (*tail == entry) \ + *tail = entry->prev; \ + \ + struct CMC_DEF_ENTRY(SNAME) *next = entry->next; \ + \ + if (entry->prev != NULL) \ + entry->prev->next = entry->next; \ + if (entry->next != NULL) \ + entry->next->prev = entry->prev; \ + \ + if (out_values) \ + (*out_values)[index] = entry->value; \ + \ + index++; \ + _map_->alloc->free(entry); \ + \ + entry = next; \ + } \ + else \ + entry = entry->next; \ + } \ + } \ + \ + _map_->count -= index; \ + _map_->flag = CMC_FLAG_OK; \ + \ + if (_map_->callbacks && _map_->callbacks->delete) \ + _map_->callbacks->delete (); \ + \ + return index; \ + } \ + \ + bool CMC_(PFX, _max)(struct SNAME * _map_, K * key, V * value) \ + { \ + if (CMC_(PFX, _empty)(_map_)) \ + { \ + _map_->flag = CMC_FLAG_EMPTY; \ + return false; \ + } \ + \ + K max_key; \ + V max_val; \ + \ + struct CMC_DEF_ITER(SNAME) iter = CMC_(PFX, _iter_start)(_map_); \ + \ + /* TODO Turn this into a normal loop */ \ + for (; !CMC_(PFX, _iter_at_end)(&iter); CMC_(PFX, _iter_next)(&iter)) \ + { \ + K result_key = CMC_(PFX, _iter_key)(&iter); \ + V result_value = CMC_(PFX, _iter_value)(&iter); \ + size_t index = CMC_(PFX, _iter_index)(&iter); \ + \ + if (index == 0) \ + { \ + max_key = result_key; \ + max_val = result_value; \ + } \ + else if (_map_->f_key->cmp(result_key, max_key) > 0) \ + { \ + max_key = result_key; \ + max_val = result_value; \ + } \ + } \ + \ + if (key) \ + *key = max_key; \ + if (value) \ + *value = max_val; \ + \ + _map_->flag = CMC_FLAG_OK; \ + \ + if (_map_->callbacks && _map_->callbacks->read) \ + _map_->callbacks->read(); \ + \ + return true; \ + } \ + \ + bool CMC_(PFX, _min)(struct SNAME * _map_, K * key, V * value) \ + { \ + if (CMC_(PFX, _empty)(_map_)) \ + { \ + _map_->flag = CMC_FLAG_EMPTY; \ + return false; \ + } \ + \ + K min_key; \ + V min_val; \ + \ + struct CMC_DEF_ITER(SNAME) iter = CMC_(PFX, _iter_start)(_map_); \ + \ + /* TODO Turn this into a normal loop */ \ + for (; !CMC_(PFX, _iter_at_end)(&iter); CMC_(PFX, _iter_next)(&iter)) \ + { \ + K result_key = CMC_(PFX, _iter_key)(&iter); \ + V result_value = CMC_(PFX, _iter_value)(&iter); \ + size_t index = CMC_(PFX, _iter_index)(&iter); \ + \ + if (index == 0) \ + { \ + min_key = result_key; \ + min_val = result_value; \ + } \ + else if (_map_->f_key->cmp(result_key, min_key) < 0) \ + { \ + min_key = result_key; \ + min_val = result_value; \ + } \ + } \ + \ + if (key) \ + *key = min_key; \ + if (value) \ + *value = min_val; \ + \ + _map_->flag = CMC_FLAG_OK; \ + \ + if (_map_->callbacks && _map_->callbacks->read) \ + _map_->callbacks->read(); \ + \ + return true; \ + } \ + \ + V CMC_(PFX, _get)(struct SNAME * _map_, K key) \ + { \ + if (CMC_(PFX, _empty)(_map_)) \ + { \ + _map_->flag = CMC_FLAG_EMPTY; \ + return false; \ + } \ + \ + struct CMC_DEF_ENTRY(SNAME) *entry = \ + CMC_(PFX, _impl_get_entry)(_map_, key); \ + \ + if (!entry) \ + { \ + _map_->flag = CMC_FLAG_NOT_FOUND; \ + return (V){ 0 }; \ + } \ + \ + _map_->flag = CMC_FLAG_OK; \ + \ + if (_map_->callbacks && _map_->callbacks->read) \ + _map_->callbacks->read(); \ + \ + return entry->value; \ + } \ + \ + V *CMC_(PFX, _get_ref)(struct SNAME * _map_, K key) \ + { \ + if (CMC_(PFX, _empty)(_map_)) \ + { \ + _map_->flag = CMC_FLAG_EMPTY; \ + return false; \ + } \ + \ + struct CMC_DEF_ENTRY(SNAME) *entry = \ + CMC_(PFX, _impl_get_entry)(_map_, key); \ + \ + if (!entry) \ + { \ + _map_->flag = CMC_FLAG_NOT_FOUND; \ + return NULL; \ + } \ + \ + _map_->flag = CMC_FLAG_OK; \ + \ + if (_map_->callbacks && _map_->callbacks->read) \ + _map_->callbacks->read(); \ + \ + return &(entry->value); \ + } \ + \ + bool CMC_(PFX, _contains)(struct SNAME * _map_, K key) \ + { \ + _map_->flag = CMC_FLAG_OK; \ + \ + bool result = CMC_(PFX, _impl_get_entry)(_map_, key) != NULL; \ + \ + if (_map_->callbacks && _map_->callbacks->read) \ + _map_->callbacks->read(); \ + \ + return result; \ + } \ + \ + bool CMC_(PFX, _empty)(struct SNAME * _map_) \ + { \ + return _map_->count == 0; \ + } \ + \ + bool CMC_(PFX, _full)(struct SNAME * _map_) \ + { \ + return (double)_map_->capacity * _map_->load <= (double)_map_->count; \ + } \ + \ + size_t CMC_(PFX, _count)(struct SNAME * _map_) \ + { \ + return _map_->count; \ + } \ + \ + size_t CMC_(PFX, _key_count)(struct SNAME * _map_, K key) \ + { \ + return CMC_(PFX, _impl_key_count)(_map_, key); \ + } \ + \ + size_t CMC_(PFX, _capacity)(struct SNAME * _map_) \ + { \ + return _map_->capacity; \ + } \ + \ + double CMC_(PFX, _load)(struct SNAME * _map_) \ + { \ + return _map_->load; \ + } \ + \ + int CMC_(PFX, _flag)(struct SNAME * _map_) \ + { \ + return _map_->flag; \ + } \ + \ + bool CMC_(PFX, _resize)(struct SNAME * _map_, size_t capacity) \ + { \ + _map_->flag = CMC_FLAG_OK; \ + \ + if (_map_->capacity == capacity) \ + goto success; \ + \ + if (_map_->capacity > capacity / _map_->load) \ + goto success; \ + \ + /* Prevent integer overflow */ \ + if (capacity >= UINTMAX_MAX * _map_->load) \ + { \ + _map_->flag = CMC_FLAG_ERROR; \ + return false; \ + } \ + \ + /* Calculate required capacity based on the prime numbers */ \ + size_t theoretical_size = CMC_(PFX, _impl_calculate_size)(capacity); \ + \ + /* Not possible to shrink with current available prime numbers */ \ + if (theoretical_size < _map_->count / _map_->load) \ + { \ + _map_->flag = CMC_FLAG_INVALID; \ + return false; \ + } \ + \ + /* No callbacks since _new_map_ is just a temporary hashtable */ \ + struct SNAME *_new_map_ = \ + CMC_(PFX, _new_custom)(capacity, _map_->load, _map_->f_key, \ + _map_->f_val, _map_->alloc, NULL); \ + \ + if (!_new_map_) \ + { \ + _map_->flag = CMC_FLAG_ALLOC; \ + return false; \ + } \ + \ + struct CMC_DEF_ITER(SNAME) iter = CMC_(PFX, _iter_start)(_map_); \ + \ + /* TODO Turn this into a normal loop */ \ + for (; !CMC_(PFX, _iter_at_end)(&iter); CMC_(PFX, _iter_next)(&iter)) \ + { \ + K key = CMC_(PFX, _iter_key)(&iter); \ + V value = CMC_(PFX, _iter_value)(&iter); \ + \ + /* TODO check for errors */ \ + CMC_(PFX, _insert)(_new_map_, key, value); \ + } \ + \ + if (_map_->count != _new_map_->count) \ + { \ + CMC_(PFX, _free)(_new_map_); \ + \ + _map_->flag = CMC_FLAG_ERROR; \ + return false; \ + } \ + \ + struct CMC_DEF_ENTRY(SNAME) * (*tmp_b)[2] = _map_->buffer; \ + _map_->buffer = _new_map_->buffer; \ + _new_map_->buffer = tmp_b; \ + \ + size_t tmp_c = _map_->capacity; \ + _map_->capacity = _new_map_->capacity; \ + _new_map_->capacity = tmp_c; \ + \ + /* Prevent the map from freeing the data */ \ + _new_map_->f_key = &(struct CMC_DEF_FKEY(SNAME)){ NULL }; \ + _new_map_->f_val = &(struct CMC_DEF_FVAL(SNAME)){ NULL }; \ + \ + CMC_(PFX, _free)(_new_map_); \ + \ + success: \ + \ + if (_map_->callbacks && _map_->callbacks->resize) \ + _map_->callbacks->resize(); \ + \ + return true; \ + } \ + \ + struct SNAME *CMC_(PFX, _copy_of)(struct SNAME * _map_) \ + { \ + /* Callback will be added later */ \ + struct SNAME *result = CMC_(PFX, _new_custom)( \ + _map_->capacity * _map_->load, _map_->load, _map_->f_key, \ + _map_->f_val, _map_->alloc, NULL); \ + \ + if (!result) \ + { \ + _map_->flag = CMC_FLAG_ERROR; \ + return NULL; \ + } \ + \ + struct CMC_DEF_ITER(SNAME) iter = CMC_(PFX, _iter_start)(_map_); \ + \ + if (!CMC_(PFX, _empty)(_map_)) \ + { \ + /* TODO Turn this into a normal loop */ \ + for (; !CMC_(PFX, _iter_at_end)(&iter); \ + CMC_(PFX, _iter_next)(&iter)) \ + { \ + K key = CMC_(PFX, _iter_key)(&iter); \ + V value = CMC_(PFX, _iter_value)(&iter); \ + \ + if (_map_->f_key->cpy) \ + key = _map_->f_key->cpy(key); \ + if (_map_->f_val->cpy) \ + value = _map_->f_val->cpy(value); \ + \ + /* TODO check for errors */ \ + CMC_(PFX, _insert)(result, key, value); \ + } \ + } \ + \ + result->callbacks = _map_->callbacks; \ + _map_->flag = CMC_FLAG_OK; \ + \ + return result; \ + } \ + \ + bool CMC_(PFX, _equals)(struct SNAME * _map1_, struct SNAME * _map2_) \ + { \ + _map1_->flag = CMC_FLAG_OK; \ + _map2_->flag = CMC_FLAG_OK; \ + \ + if (_map1_->count != _map2_->count) \ + return false; \ + \ + struct CMC_DEF_ITER(SNAME) iter = CMC_(PFX, _iter_start)(_map1_); \ + \ + /* TODO Turn this into a normal loop */ \ + for (; !CMC_(PFX, _iter_at_end)(&iter); CMC_(PFX, _iter_next)(&iter)) \ + { \ + K key = CMC_(PFX, _iter_key)(&iter); \ + \ + if (CMC_(PFX, _impl_key_count)(_map1_, key) != \ + CMC_(PFX, _impl_key_count)(_map2_, key)) \ + return false; \ + } \ + \ + return true; \ + } \ + \ + struct cmc_string CMC_(PFX, _to_string)(struct SNAME * _map_) \ + { \ + struct cmc_string str; \ + struct SNAME *m_ = _map_; \ + \ + int n = snprintf( \ + str.s, cmc_string_len, cmc_cmc_string_fmt_hashmultimap, #SNAME, \ + #K, #V, m_, m_->buffer, m_->capacity, m_->count, m_->load, \ + m_->flag, m_->f_key, m_->f_val, m_->alloc, m_->callbacks); \ + \ + return n >= 0 ? str : (struct cmc_string){ 0 }; \ + } \ + \ + bool CMC_(PFX, _print)(struct SNAME * _map_, FILE * fptr) \ + { \ + for (size_t i = 0; i < _map_->capacity; i++) \ + { \ + struct CMC_DEF_ENTRY(SNAME) *scan = _map_->buffer[i][0]; \ + \ + while (scan != NULL) \ + { \ + if (!_map_->f_key->str(fptr, scan->key) || \ + !_map_->f_val->str(fptr, scan->value)) \ + return false; \ + \ + scan = scan->next; \ + } \ + } \ + \ + return true; \ + } \ + \ + struct CMC_DEF_ITER(SNAME) CMC_(PFX, _iter_start)(struct SNAME * target) \ + { \ + struct CMC_DEF_ITER(SNAME) iter; \ + \ + iter.target = target; \ + iter.curr_entry = NULL; \ + iter.cursor = 0; \ + iter.index = 0; \ + iter.first = 0; \ + iter.last = 0; \ + iter.start = true; \ + iter.end = CMC_(PFX, _empty)(target); \ + \ + if (!CMC_(PFX, _empty)(target)) \ + { \ + for (size_t i = 0; i < target->capacity; i++) \ + { \ + if (target->buffer[i][0] != NULL) \ + { \ + iter.curr_entry = target->buffer[i][0]; \ + iter.first = i; \ + break; \ + } \ + } \ + \ + iter.cursor = iter.first; \ + \ + for (size_t i = target->capacity; i > 0; i--) \ + { \ + if (target->buffer[i - 1][1] != NULL) \ + { \ + iter.last = i - 1; \ + break; \ + } \ + } \ + } \ + \ + return iter; \ + } \ + \ + struct CMC_DEF_ITER(SNAME) CMC_(PFX, _iter_end)(struct SNAME * target) \ + { \ + struct CMC_DEF_ITER(SNAME) iter; \ + \ + iter.target = target; \ + iter.curr_entry = NULL; \ + iter.cursor = 0; \ + iter.index = 0; \ + iter.first = 0; \ + iter.last = 0; \ + iter.start = CMC_(PFX, _empty)(target); \ + iter.end = true; \ + \ + if (!CMC_(PFX, _empty)(target)) \ + { \ + for (size_t i = 0; i < target->capacity; i++) \ + { \ + if (target->buffer[i][0] != NULL) \ + { \ + iter.first = i; \ + break; \ + } \ + } \ + \ + for (size_t i = target->capacity; i > 0; i--) \ + { \ + if (target->buffer[i - 1][1] != NULL) \ + { \ + iter.curr_entry = target->buffer[i - 1][1]; \ + iter.last = i - 1; \ + break; \ + } \ + } \ + \ + iter.cursor = iter.last; \ + iter.index = target->count - 1; \ + } \ + \ + return iter; \ + } \ + \ + bool CMC_(PFX, _iter_at_start)(struct CMC_DEF_ITER(SNAME) * iter) \ + { \ + return CMC_(PFX, _empty)(iter->target) || iter->start; \ + } \ + \ + bool CMC_(PFX, _iter_at_end)(struct CMC_DEF_ITER(SNAME) * iter) \ + { \ + return CMC_(PFX, _empty)(iter->target) || iter->end; \ + } \ + \ + bool CMC_(PFX, _iter_to_start)(struct CMC_DEF_ITER(SNAME) * iter) \ + { \ + if (!CMC_(PFX, _empty)(iter->target)) \ + { \ + iter->cursor = iter->first; \ + iter->index = 0; \ + iter->start = true; \ + iter->end = CMC_(PFX, _empty)(iter->target); \ + iter->curr_entry = iter->target->buffer[iter->first][0]; \ + \ + return true; \ + } \ + \ + return false; \ + } \ + \ + bool CMC_(PFX, _iter_to_end)(struct CMC_DEF_ITER(SNAME) * iter) \ + { \ + if (!CMC_(PFX, _empty)(iter->target)) \ + { \ + iter->cursor = iter->last; \ + iter->index = iter->target->count - 1; \ + iter->start = CMC_(PFX, _empty)(iter->target); \ + iter->end = true; \ + iter->curr_entry = iter->target->buffer[iter->last][1]; \ + \ + return true; \ + } \ + \ + return false; \ + } \ + \ + bool CMC_(PFX, _iter_next)(struct CMC_DEF_ITER(SNAME) * iter) \ + { \ + if (iter->end) \ + return false; \ + \ + if (iter->curr_entry->next != NULL) \ + { \ + iter->curr_entry = iter->curr_entry->next; \ + iter->index++; \ + } \ + else \ + { \ + if (iter->cursor == iter->last) \ + { \ + iter->end = true; \ + return false; \ + } \ + \ + iter->cursor++; \ + \ + while (iter->target->buffer[iter->cursor][0] == NULL) \ + iter->cursor++; \ + \ + iter->curr_entry = iter->target->buffer[iter->cursor][0]; \ + \ + iter->index++; \ + } \ + \ + iter->start = CMC_(PFX, _empty)(iter->target); \ + \ + return true; \ + } \ + \ + bool CMC_(PFX, _iter_prev)(struct CMC_DEF_ITER(SNAME) * iter) \ + { \ + if (iter->start) \ + return false; \ + \ + if (iter->curr_entry->prev != NULL) \ + { \ + iter->curr_entry = iter->curr_entry->prev; \ + iter->index--; \ + } \ + else \ + { \ + if (iter->cursor == iter->first) \ + { \ + iter->start = true; \ + return false; \ + } \ + \ + iter->cursor--; \ + \ + while (iter->target->buffer[iter->cursor][1] == NULL) \ + iter->cursor--; \ + \ + iter->curr_entry = iter->target->buffer[iter->cursor][1]; \ + \ + iter->index--; \ + } \ + \ + iter->end = CMC_(PFX, _empty)(iter->target); \ + \ + return true; \ + } \ + \ + /* Returns true only if the iterator moved */ \ + bool CMC_(PFX, _iter_advance)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t steps) \ + { \ + if (iter->end) \ + return false; \ + \ + if (iter->index + 1 == iter->target->count) \ + { \ + iter->end = true; \ + return false; \ + } \ + \ + if (steps == 0 || iter->index + steps >= iter->target->count) \ + return false; \ + \ + for (size_t i = 0; i < steps; i++) \ + CMC_(PFX, _iter_next)(iter); \ + \ + return true; \ + } \ + \ + /* Returns true only if the iterator moved */ \ + bool CMC_(PFX, _iter_rewind)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t steps) \ + { \ + if (iter->start) \ + return false; \ + \ + if (iter->index == 0) \ + { \ + iter->start = true; \ + return false; \ + } \ + \ + if (steps == 0 || iter->index < steps) \ + return false; \ + \ + for (size_t i = 0; i < steps; i++) \ + CMC_(PFX, _iter_prev)(iter); \ + \ + return true; \ + } \ + \ + /* Returns true only if the iterator was able to be positioned at the */ \ + /* given index */ \ + bool CMC_(PFX, _iter_go_to)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t index) \ + { \ + if (index >= iter->target->count) \ + return false; \ + \ + if (iter->index > index) \ + return CMC_(PFX, _iter_rewind)(iter, iter->index - index); \ + else if (iter->index < index) \ + return CMC_(PFX, _iter_advance)(iter, index - iter->index); \ + \ + return true; \ + } \ + \ + K CMC_(PFX, _iter_key)(struct CMC_DEF_ITER(SNAME) * iter) \ + { \ + if (CMC_(PFX, _empty)(iter->target)) \ + return (K){ 0 }; \ + \ + return iter->curr_entry->key; \ + } \ + \ + V CMC_(PFX, _iter_value)(struct CMC_DEF_ITER(SNAME) * iter) \ + { \ + if (CMC_(PFX, _empty)(iter->target)) \ + return (V){ 0 }; \ + \ + return iter->curr_entry->value; \ + } \ + \ + V *CMC_(PFX, _iter_rvalue)(struct CMC_DEF_ITER(SNAME) * iter) \ + { \ + if (CMC_(PFX, _empty)(iter->target)) \ + return NULL; \ + \ + return &(iter->curr_entry->value); \ + } \ + \ + size_t CMC_(PFX, _iter_index)(struct CMC_DEF_ITER(SNAME) * iter) \ + { \ + return iter->index; \ + } \ + \ + struct CMC_DEF_ENTRY(SNAME) * \ + CMC_(PFX, _impl_new_entry)(struct SNAME * _map_, K key, V value) \ + { \ + struct CMC_DEF_ENTRY(SNAME) *entry = \ + _map_->alloc->malloc(sizeof(struct CMC_DEF_ENTRY(SNAME))); \ + \ + if (!entry) \ + return NULL; \ + \ + entry->key = key; \ + entry->value = value; \ + entry->next = NULL; \ + entry->prev = NULL; \ + \ + return entry; \ + } \ + \ + struct CMC_DEF_ENTRY(SNAME) * \ + CMC_(PFX, _impl_get_entry)(struct SNAME * _map_, K key) \ + { \ + size_t hash = _map_->f_key->hash(key); \ + \ + struct CMC_DEF_ENTRY(SNAME) *entry = \ + _map_->buffer[hash % _map_->capacity][0]; \ + \ + while (entry != NULL) \ + { \ + if (_map_->f_key->cmp(entry->key, key) == 0) \ + return entry; \ + \ + entry = entry->next; \ + } \ + \ + return NULL; \ + } \ + \ + size_t CMC_(PFX, _impl_key_count)(struct SNAME * _map_, K key) \ + { \ + size_t hash = _map_->f_key->hash(key); \ + \ + struct CMC_DEF_ENTRY(SNAME) *entry = \ + _map_->buffer[hash % _map_->capacity][0]; \ + \ + size_t total_count = 0; \ + \ + if (!entry) \ + return total_count; \ + \ + while (entry != NULL) \ + { \ + if (_map_->f_key->cmp(entry->key, key) == 0) \ + total_count++; \ + \ + entry = entry->next; \ + } \ + \ + return total_count; \ + } \ + \ + size_t CMC_(PFX, _impl_calculate_size)(size_t required) \ + { \ + const size_t count = \ + sizeof(cmc_hashtable_primes) / sizeof(cmc_hashtable_primes[0]); \ + \ + if (cmc_hashtable_primes[count - 1] < required) \ + return required; \ + \ + size_t i = 0; \ + while (cmc_hashtable_primes[i] < required) \ + i++; \ + \ + return cmc_hashtable_primes[i]; \ } -#endif /* CMC_HASHMULTIMAP_H */ +#endif /* CMC_CMC_HASHMULTIMAP_H */ diff --git a/src/cmc/hashmultiset.h b/src/cmc/hashmultiset.h index 9a92106..b2c5613 100644 --- a/src/cmc/hashmultiset.h +++ b/src/cmc/hashmultiset.h @@ -23,8 +23,8 @@ * mapped to their multiplicity. */ -#ifndef CMC_HASHMULTISET_H -#define CMC_HASHMULTISET_H +#ifndef CMC_CMC_HASHMULTISET_H +#define CMC_CMC_HASHMULTISET_H /* ------------------------------------------------------------------------- * Core functionalities of the C Macro Collections Library @@ -40,38 +40,44 @@ * HashMultiSet specific * ------------------------------------------------------------------------- */ /* to_string format */ -static const char *cmc_string_fmt_hashmultiset = "struct %s<%s> " - "at %p { " - "buffer:%p, " - "capacity:%" PRIuMAX ", " - "count:%" PRIuMAX ", " - "cardinality:%" PRIuMAX ", " - "load:%lf, " - "flag:%d, " - "f_val:%p, " - "alloc:%p, " - "callbacks:%p }"; +static const char *cmc_cmc_string_fmt_hashmultiset = + "struct %s<%s> " + "at %p { " + "buffer:%p, " + "capacity:%" PRIuMAX ", " + "count:%" PRIuMAX ", " + "cardinality:%" PRIuMAX ", " + "load:%lf, " + "flag:%d, " + "f_val:%p, " + "alloc:%p, " + "callbacks:%p }"; -#define CMC_GENERATE_HASHMULTISET(PFX, SNAME, V) \ - CMC_GENERATE_HASHMULTISET_HEADER(PFX, SNAME, V) \ - CMC_GENERATE_HASHMULTISET_SOURCE(PFX, SNAME, V) +/** + * Core HashMultiSet implementation + */ +#define CMC_CMC_HASHMULTISET_CORE(BODY) \ + CMC_CMC_HASHMULTISET_CORE_HEADER(BODY) \ + CMC_CMC_HASHMULTISET_CORE_SOURCE(BODY) -#define CMC_WRAPGEN_HASHMULTISET_HEADER(PFX, SNAME, K, V) \ - CMC_GENERATE_HASHMULTISET_HEADER(PFX, SNAME, V) +#define CMC_CMC_HASHMULTISET_CORE_HEADER(BODY) \ + CMC_CMC_HASHMULTISET_CORE_HEADER_( \ + CMC_PARAM_PFX(BODY), CMC_PARAM_SNAME(BODY), CMC_PARAM_V(BODY)) -#define CMC_WRAPGEN_HASHMULTISET_SOURCE(PFX, SNAME, K, V) \ - CMC_GENERATE_HASHMULTISET_SOURCE(PFX, SNAME, V) +#define CMC_CMC_HASHMULTISET_CORE_SOURCE(BODY) \ + CMC_CMC_HASHMULTISET_CORE_SOURCE_( \ + CMC_PARAM_PFX(BODY), CMC_PARAM_SNAME(BODY), CMC_PARAM_V(BODY)) /* ------------------------------------------------------------------------- * Header * ------------------------------------------------------------------------- */ -#define CMC_GENERATE_HASHMULTISET_HEADER(PFX, SNAME, V) \ +#define CMC_CMC_HASHMULTISET_CORE_HEADER_(PFX, SNAME, V) \ \ /* HashMultiset Structure */ \ struct SNAME \ { \ /* Array of Entries */ \ - struct SNAME##_entry *buffer; \ + struct CMC_DEF_ENTRY(SNAME) * buffer; \ \ /* Current Array Capcity */ \ size_t capacity; \ @@ -89,7 +95,7 @@ static const char *cmc_string_fmt_hashmultiset = "struct %s<%s> " int flag; \ \ /* Key function table */ \ - struct SNAME##_fval *f_val; \ + struct CMC_DEF_FVAL(SNAME) * f_val; \ \ /* Custom allocation functions */ \ struct cmc_alloc_node *alloc; \ @@ -98,7 +104,7 @@ static const char *cmc_string_fmt_hashmultiset = "struct %s<%s> " struct cmc_callbacks *callbacks; \ }; \ \ - struct SNAME##_entry \ + struct CMC_DEF_ENTRY(SNAME) \ { \ /* Entry element */ \ V value; \ @@ -115,7 +121,7 @@ static const char *cmc_string_fmt_hashmultiset = "struct %s<%s> " }; \ \ /* Value struct function table */ \ - struct SNAME##_fval \ + struct CMC_DEF_FVAL(SNAME) \ { \ /* Comparator function */ \ int (*cmp)(V, V); \ @@ -137,7 +143,7 @@ static const char *cmc_string_fmt_hashmultiset = "struct %s<%s> " }; \ \ /* HashMultiset Iterator */ \ - struct SNAME##_iter \ + struct CMC_DEF_ITER(SNAME) \ { \ /* Target HashMultiset */ \ struct SNAME *target; \ @@ -163,92 +169,105 @@ static const char *cmc_string_fmt_hashmultiset = "struct %s<%s> " \ /* Collection Functions */ \ /* Collection Allocation and Deallocation */ \ - struct SNAME *PFX##_new(size_t capacity, double load, \ - struct SNAME##_fval *f_val); \ - struct SNAME *PFX##_new_custom( \ - size_t capacity, double load, struct SNAME##_fval *f_val, \ - struct cmc_alloc_node *alloc, struct cmc_callbacks *callbacks); \ - void PFX##_clear(struct SNAME *_set_); \ - void PFX##_free(struct SNAME *_set_); \ + struct SNAME *CMC_(PFX, _new)(size_t capacity, double load, \ + struct CMC_DEF_FVAL(SNAME) * f_val); \ + struct SNAME *CMC_(PFX, _new_custom)( \ + size_t capacity, double load, struct CMC_DEF_FVAL(SNAME) * f_val, \ + struct cmc_alloc_node * alloc, struct cmc_callbacks * callbacks); \ + void CMC_(PFX, _clear)(struct SNAME * _set_); \ + void CMC_(PFX, _free)(struct SNAME * _set_); \ /* Customization of Allocation and Callbacks */ \ - void PFX##_customize(struct SNAME *_set_, struct cmc_alloc_node *alloc, \ - struct cmc_callbacks *callbacks); \ + void CMC_(PFX, _customize)(struct SNAME * _set_, \ + struct cmc_alloc_node * alloc, \ + struct cmc_callbacks * callbacks); \ /* Collection Input and Output */ \ - bool PFX##_insert(struct SNAME *_set_, V value); \ - bool PFX##_insert_many(struct SNAME *_set_, V value, size_t count); \ - bool PFX##_update(struct SNAME *_set_, V value, size_t multiplicity); \ - bool PFX##_remove(struct SNAME *_set_, V value); \ - size_t PFX##_remove_all(struct SNAME *_set_, V value); \ + bool CMC_(PFX, _insert)(struct SNAME * _set_, V value); \ + bool CMC_(PFX, _insert_many)(struct SNAME * _set_, V value, size_t count); \ + bool CMC_(PFX, _update)(struct SNAME * _set_, V value, \ + size_t multiplicity); \ + bool CMC_(PFX, _remove)(struct SNAME * _set_, V value); \ + size_t CMC_(PFX, _remove_all)(struct SNAME * _set_, V value); \ /* Element Access */ \ - bool PFX##_max(struct SNAME *_set_, V *value); \ - bool PFX##_min(struct SNAME *_set_, V *value); \ - size_t PFX##_multiplicity_of(struct SNAME *_set_, V value); \ + bool CMC_(PFX, _max)(struct SNAME * _set_, V * value); \ + bool CMC_(PFX, _min)(struct SNAME * _set_, V * value); \ + size_t CMC_(PFX, _multiplicity_of)(struct SNAME * _set_, V value); \ /* Collection State */ \ - bool PFX##_contains(struct SNAME *_set_, V value); \ - bool PFX##_empty(struct SNAME *_set_); \ - bool PFX##_full(struct SNAME *_set_); \ - size_t PFX##_count(struct SNAME *_set_); \ - size_t PFX##_cardinality(struct SNAME *_set_); \ - size_t PFX##_capacity(struct SNAME *_set_); \ - double PFX##_load(struct SNAME *_set_); \ - int PFX##_flag(struct SNAME *_set_); \ + bool CMC_(PFX, _contains)(struct SNAME * _set_, V value); \ + bool CMC_(PFX, _empty)(struct SNAME * _set_); \ + bool CMC_(PFX, _full)(struct SNAME * _set_); \ + size_t CMC_(PFX, _count)(struct SNAME * _set_); \ + size_t CMC_(PFX, _cardinality)(struct SNAME * _set_); \ + size_t CMC_(PFX, _capacity)(struct SNAME * _set_); \ + double CMC_(PFX, _load)(struct SNAME * _set_); \ + int CMC_(PFX, _flag)(struct SNAME * _set_); \ /* Collection Utility */ \ - bool PFX##_resize(struct SNAME *_set_, size_t capacity); \ - struct SNAME *PFX##_copy_of(struct SNAME *_set_); \ - bool PFX##_equals(struct SNAME *_set1_, struct SNAME *_set2_); \ - struct cmc_string PFX##_to_string(struct SNAME *_set_); \ - bool PFX##_print(struct SNAME *_set_, FILE *fptr); \ + bool CMC_(PFX, _resize)(struct SNAME * _set_, size_t capacity); \ + struct SNAME *CMC_(PFX, _copy_of)(struct SNAME * _set_); \ + bool CMC_(PFX, _equals)(struct SNAME * _set1_, struct SNAME * _set2_); \ + struct cmc_string CMC_(PFX, _to_string)(struct SNAME * _set_); \ + bool CMC_(PFX, _print)(struct SNAME * _set_, FILE * fptr); \ \ /* Set Operations */ \ - struct SNAME *PFX##_union(struct SNAME *_set1_, struct SNAME *_set2_); \ - struct SNAME *PFX##_intersection(struct SNAME *_set1_, \ - struct SNAME *_set2_); \ - struct SNAME *PFX##_difference(struct SNAME *_set1_, \ - struct SNAME *_set2_); \ - struct SNAME *PFX##_summation(struct SNAME *_set1_, struct SNAME *_set2_); \ - struct SNAME *PFX##_symmetric_difference(struct SNAME *_set1_, \ - struct SNAME *_set2_); \ - bool PFX##_is_subset(struct SNAME *_set1_, struct SNAME *_set2_); \ - bool PFX##_is_superset(struct SNAME *_set1_, struct SNAME *_set2_); \ - bool PFX##_is_proper_subset(struct SNAME *_set1_, struct SNAME *_set2_); \ - bool PFX##_is_proper_superset(struct SNAME *_set1_, struct SNAME *_set2_); \ - bool PFX##_is_disjointset(struct SNAME *_set1_, struct SNAME *_set2_); \ + struct SNAME *CMC_(PFX, _union)(struct SNAME * _set1_, \ + struct SNAME * _set2_); \ + struct SNAME *CMC_(PFX, _intersection)(struct SNAME * _set1_, \ + struct SNAME * _set2_); \ + struct SNAME *CMC_(PFX, _difference)(struct SNAME * _set1_, \ + struct SNAME * _set2_); \ + struct SNAME *CMC_(PFX, _summation)(struct SNAME * _set1_, \ + struct SNAME * _set2_); \ + struct SNAME *CMC_(PFX, _symmetric_difference)(struct SNAME * _set1_, \ + struct SNAME * _set2_); \ + bool CMC_(PFX, _is_subset)(struct SNAME * _set1_, struct SNAME * _set2_); \ + bool CMC_(PFX, _is_superset)(struct SNAME * _set1_, \ + struct SNAME * _set2_); \ + bool CMC_(PFX, _is_proper_subset)(struct SNAME * _set1_, \ + struct SNAME * _set2_); \ + bool CMC_(PFX, _is_proper_superset)(struct SNAME * _set1_, \ + struct SNAME * _set2_); \ + bool CMC_(PFX, _is_disjointset)(struct SNAME * _set1_, \ + struct SNAME * _set2_); \ \ /* Iterator Functions */ \ /* Iterator Initialization */ \ - struct SNAME##_iter PFX##_iter_start(struct SNAME *target); \ - struct SNAME##_iter PFX##_iter_end(struct SNAME *target); \ + struct CMC_DEF_ITER(SNAME) CMC_(PFX, _iter_start)(struct SNAME * target); \ + struct CMC_DEF_ITER(SNAME) CMC_(PFX, _iter_end)(struct SNAME * target); \ /* Iterator State */ \ - bool PFX##_iter_at_start(struct SNAME##_iter *iter); \ - bool PFX##_iter_at_end(struct SNAME##_iter *iter); \ + bool CMC_(PFX, _iter_at_start)(struct CMC_DEF_ITER(SNAME) * iter); \ + bool CMC_(PFX, _iter_at_end)(struct CMC_DEF_ITER(SNAME) * iter); \ /* Iterator Movement */ \ - bool PFX##_iter_to_start(struct SNAME##_iter *iter); \ - bool PFX##_iter_to_end(struct SNAME##_iter *iter); \ - bool PFX##_iter_next(struct SNAME##_iter *iter); \ - bool PFX##_iter_prev(struct SNAME##_iter *iter); \ - bool PFX##_iter_advance(struct SNAME##_iter *iter, size_t steps); \ - bool PFX##_iter_rewind(struct SNAME##_iter *iter, size_t steps); \ - bool PFX##_iter_go_to(struct SNAME##_iter *iter, size_t index); \ + bool CMC_(PFX, _iter_to_start)(struct CMC_DEF_ITER(SNAME) * iter); \ + bool CMC_(PFX, _iter_to_end)(struct CMC_DEF_ITER(SNAME) * iter); \ + bool CMC_(PFX, _iter_next)(struct CMC_DEF_ITER(SNAME) * iter); \ + bool CMC_(PFX, _iter_prev)(struct CMC_DEF_ITER(SNAME) * iter); \ + bool CMC_(PFX, _iter_advance)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t steps); \ + bool CMC_(PFX, _iter_rewind)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t steps); \ + bool CMC_(PFX, _iter_go_to)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t index); \ /* Iterator Access */ \ - V PFX##_iter_value(struct SNAME##_iter *iter); \ - size_t PFX##_iter_multiplicity(struct SNAME##_iter *iter); \ - size_t PFX##_iter_index(struct SNAME##_iter *iter); + V CMC_(PFX, _iter_value)(struct CMC_DEF_ITER(SNAME) * iter); \ + size_t CMC_(PFX, _iter_multiplicity)(struct CMC_DEF_ITER(SNAME) * iter); \ + size_t CMC_(PFX, _iter_index)(struct CMC_DEF_ITER(SNAME) * iter); /* ------------------------------------------------------------------------- * Source * ------------------------------------------------------------------------- */ -#define CMC_GENERATE_HASHMULTISET_SOURCE(PFX, SNAME, V) \ +#define CMC_CMC_HASHMULTISET_CORE_SOURCE_(PFX, SNAME, V) \ \ /* Implementation Detail Functions */ \ - static size_t PFX##_impl_multiplicity_of(struct SNAME *_set_, V value); \ - static struct SNAME##_entry *PFX##_impl_insert_and_return( \ - struct SNAME *_set_, V value, bool *new_node); \ - static struct SNAME##_entry *PFX##_impl_get_entry(struct SNAME *_set_, \ - V value); \ - static size_t PFX##_impl_calculate_size(size_t required); \ + static size_t CMC_(PFX, _impl_multiplicity_of)(struct SNAME * _set_, \ + V value); \ + static struct CMC_DEF_ENTRY(SNAME) * \ + CMC_(PFX, _impl_insert_and_return)(struct SNAME * _set_, V value, \ + bool *new_node); \ + static struct CMC_DEF_ENTRY(SNAME) * \ + CMC_(PFX, _impl_get_entry)(struct SNAME * _set_, V value); \ + static size_t CMC_(PFX, _impl_calculate_size)(size_t required); \ \ - struct SNAME *PFX##_new(size_t capacity, double load, \ - struct SNAME##_fval *f_val) \ + struct SNAME *CMC_(PFX, _new)(size_t capacity, double load, \ + struct CMC_DEF_FVAL(SNAME) * f_val) \ { \ struct cmc_alloc_node *alloc = &cmc_alloc_node_default; \ \ @@ -262,7 +281,8 @@ static const char *cmc_string_fmt_hashmultiset = "struct %s<%s> " if (!f_val) \ return NULL; \ \ - size_t real_capacity = PFX##_impl_calculate_size(capacity / load); \ + size_t real_capacity = \ + CMC_(PFX, _impl_calculate_size)(capacity / load); \ \ struct SNAME *_set_ = alloc->malloc(sizeof(struct SNAME)); \ \ @@ -270,7 +290,7 @@ static const char *cmc_string_fmt_hashmultiset = "struct %s<%s> " return NULL; \ \ _set_->buffer = \ - alloc->calloc(real_capacity, sizeof(struct SNAME##_entry)); \ + alloc->calloc(real_capacity, sizeof(struct CMC_DEF_ENTRY(SNAME))); \ \ if (!_set_->buffer) \ { \ @@ -282,7 +302,7 @@ static const char *cmc_string_fmt_hashmultiset = "struct %s<%s> " _set_->cardinality = 0; \ _set_->capacity = real_capacity; \ _set_->load = load; \ - _set_->flag = cmc_flags.OK; \ + _set_->flag = CMC_FLAG_OK; \ _set_->f_val = f_val; \ _set_->alloc = alloc; \ _set_->callbacks = NULL; \ @@ -290,9 +310,9 @@ static const char *cmc_string_fmt_hashmultiset = "struct %s<%s> " return _set_; \ } \ \ - struct SNAME *PFX##_new_custom( \ - size_t capacity, double load, struct SNAME##_fval *f_val, \ - struct cmc_alloc_node *alloc, struct cmc_callbacks *callbacks) \ + struct SNAME *CMC_(PFX, _new_custom)( \ + size_t capacity, double load, struct CMC_DEF_FVAL(SNAME) * f_val, \ + struct cmc_alloc_node * alloc, struct cmc_callbacks * callbacks) \ { \ if (capacity == 0 || load <= 0 || load >= 1) \ return NULL; \ @@ -304,7 +324,8 @@ static const char *cmc_string_fmt_hashmultiset = "struct %s<%s> " if (!f_val) \ return NULL; \ \ - size_t real_capacity = PFX##_impl_calculate_size(capacity / load); \ + size_t real_capacity = \ + CMC_(PFX, _impl_calculate_size)(capacity / load); \ \ if (!alloc) \ alloc = &cmc_alloc_node_default; \ @@ -315,7 +336,7 @@ static const char *cmc_string_fmt_hashmultiset = "struct %s<%s> " return NULL; \ \ _set_->buffer = \ - alloc->calloc(real_capacity, sizeof(struct SNAME##_entry)); \ + alloc->calloc(real_capacity, sizeof(struct CMC_DEF_ENTRY(SNAME))); \ \ if (!_set_->buffer) \ { \ @@ -327,7 +348,7 @@ static const char *cmc_string_fmt_hashmultiset = "struct %s<%s> " _set_->cardinality = 0; \ _set_->capacity = real_capacity; \ _set_->load = load; \ - _set_->flag = cmc_flags.OK; \ + _set_->flag = CMC_FLAG_OK; \ _set_->f_val = f_val; \ _set_->alloc = alloc; \ _set_->callbacks = callbacks; \ @@ -335,13 +356,13 @@ static const char *cmc_string_fmt_hashmultiset = "struct %s<%s> " return _set_; \ } \ \ - void PFX##_clear(struct SNAME *_set_) \ + void CMC_(PFX, _clear)(struct SNAME * _set_) \ { \ if (_set_->f_val->free) \ { \ for (size_t i = 0; i < _set_->capacity; i++) \ { \ - struct SNAME##_entry *entry = &(_set_->buffer[i]); \ + struct CMC_DEF_ENTRY(SNAME) *entry = &(_set_->buffer[i]); \ \ if (entry->state == CMC_ES_FILLED) \ { \ @@ -351,19 +372,19 @@ static const char *cmc_string_fmt_hashmultiset = "struct %s<%s> " } \ \ memset(_set_->buffer, 0, \ - sizeof(struct SNAME##_entry) * _set_->capacity); \ + sizeof(struct CMC_DEF_ENTRY(SNAME)) * _set_->capacity); \ \ _set_->count = 0; \ - _set_->flag = cmc_flags.OK; \ + _set_->flag = CMC_FLAG_OK; \ } \ \ - void PFX##_free(struct SNAME *_set_) \ + void CMC_(PFX, _free)(struct SNAME * _set_) \ { \ if (_set_->f_val->free) \ { \ for (size_t i = 0; i < _set_->capacity; i++) \ { \ - struct SNAME##_entry *entry = &(_set_->buffer[i]); \ + struct CMC_DEF_ENTRY(SNAME) *entry = &(_set_->buffer[i]); \ \ if (entry->state == CMC_ES_FILLED) \ { \ @@ -376,8 +397,9 @@ static const char *cmc_string_fmt_hashmultiset = "struct %s<%s> " _set_->alloc->free(_set_); \ } \ \ - void PFX##_customize(struct SNAME *_set_, struct cmc_alloc_node *alloc, \ - struct cmc_callbacks *callbacks) \ + void CMC_(PFX, _customize)(struct SNAME * _set_, \ + struct cmc_alloc_node * alloc, \ + struct cmc_callbacks * callbacks) \ { \ if (!alloc) \ _set_->alloc = &cmc_alloc_node_default; \ @@ -386,19 +408,19 @@ static const char *cmc_string_fmt_hashmultiset = "struct %s<%s> " \ _set_->callbacks = callbacks; \ \ - _set_->flag = cmc_flags.OK; \ + _set_->flag = CMC_FLAG_OK; \ } \ \ - bool PFX##_insert(struct SNAME *_set_, V value) \ + bool CMC_(PFX, _insert)(struct SNAME * _set_, V value) \ { \ bool new_node; \ \ - struct SNAME##_entry *entry = \ - PFX##_impl_insert_and_return(_set_, value, &new_node); \ + struct CMC_DEF_ENTRY(SNAME) *entry = \ + CMC_(PFX, _impl_insert_and_return)(_set_, value, &new_node); \ \ if (!entry) \ { \ - _set_->flag = cmc_flags.ERROR; \ + _set_->flag = CMC_FLAG_ERROR; \ return false; \ } \ \ @@ -406,7 +428,7 @@ static const char *cmc_string_fmt_hashmultiset = "struct %s<%s> " entry->multiplicity++; \ \ _set_->cardinality++; \ - _set_->flag = cmc_flags.OK; \ + _set_->flag = CMC_FLAG_OK; \ \ if (_set_->callbacks && _set_->callbacks->create) \ _set_->callbacks->create(); \ @@ -414,19 +436,19 @@ static const char *cmc_string_fmt_hashmultiset = "struct %s<%s> " return true; \ } \ \ - bool PFX##_insert_many(struct SNAME *_set_, V value, size_t count) \ + bool CMC_(PFX, _insert_many)(struct SNAME * _set_, V value, size_t count) \ { \ if (count == 0) \ goto success; \ \ bool new_node; \ \ - struct SNAME##_entry *entry = \ - PFX##_impl_insert_and_return(_set_, value, &new_node); \ + struct CMC_DEF_ENTRY(SNAME) *entry = \ + CMC_(PFX, _impl_insert_and_return)(_set_, value, &new_node); \ \ if (!entry) \ { \ - _set_->flag = cmc_flags.ERROR; \ + _set_->flag = CMC_FLAG_ERROR; \ return false; \ } \ \ @@ -439,7 +461,7 @@ static const char *cmc_string_fmt_hashmultiset = "struct %s<%s> " \ success: \ \ - _set_->flag = cmc_flags.OK; \ + _set_->flag = CMC_FLAG_OK; \ \ if (_set_->callbacks && _set_->callbacks->create) \ _set_->callbacks->create(); \ @@ -447,12 +469,14 @@ static const char *cmc_string_fmt_hashmultiset = "struct %s<%s> " return true; \ } \ \ - bool PFX##_update(struct SNAME *_set_, V value, size_t multiplicity) \ + bool CMC_(PFX, _update)(struct SNAME * _set_, V value, \ + size_t multiplicity) \ { \ if (multiplicity == 0) \ { \ /* Effectively delete the entry */ \ - struct SNAME##_entry *result = PFX##_impl_get_entry(_set_, value); \ + struct CMC_DEF_ENTRY(SNAME) *result = \ + CMC_(PFX, _impl_get_entry)(_set_, value); \ \ if (!result) \ /* If no entry was found then its multiplicity is already 0 */ \ @@ -471,8 +495,8 @@ static const char *cmc_string_fmt_hashmultiset = "struct %s<%s> " \ bool new_node; \ \ - struct SNAME##_entry *entry = \ - PFX##_impl_insert_and_return(_set_, value, &new_node); \ + struct CMC_DEF_ENTRY(SNAME) *entry = \ + CMC_(PFX, _impl_insert_and_return)(_set_, value, &new_node); \ \ if (!entry) \ return false; \ @@ -487,7 +511,7 @@ static const char *cmc_string_fmt_hashmultiset = "struct %s<%s> " \ success: \ \ - _set_->flag = cmc_flags.OK; \ + _set_->flag = CMC_FLAG_OK; \ \ if (_set_->callbacks && _set_->callbacks->update) \ _set_->callbacks->update(); \ @@ -495,19 +519,20 @@ static const char *cmc_string_fmt_hashmultiset = "struct %s<%s> " return true; \ } \ \ - bool PFX##_remove(struct SNAME *_set_, V value) \ + bool CMC_(PFX, _remove)(struct SNAME * _set_, V value) \ { \ - if (PFX##_empty(_set_)) \ + if (CMC_(PFX, _empty)(_set_)) \ { \ - _set_->flag = cmc_flags.EMPTY; \ + _set_->flag = CMC_FLAG_EMPTY; \ return false; \ } \ \ - struct SNAME##_entry *result = PFX##_impl_get_entry(_set_, value); \ + struct CMC_DEF_ENTRY(SNAME) *result = \ + CMC_(PFX, _impl_get_entry)(_set_, value); \ \ if (!result) \ { \ - _set_->flag = cmc_flags.NOT_FOUND; \ + _set_->flag = CMC_FLAG_NOT_FOUND; \ return false; \ } \ \ @@ -524,7 +549,7 @@ static const char *cmc_string_fmt_hashmultiset = "struct %s<%s> " } \ \ _set_->cardinality--; \ - _set_->flag = cmc_flags.OK; \ + _set_->flag = CMC_FLAG_OK; \ \ if (_set_->callbacks && _set_->callbacks->delete) \ _set_->callbacks->delete (); \ @@ -532,19 +557,20 @@ static const char *cmc_string_fmt_hashmultiset = "struct %s<%s> " return true; \ } \ \ - size_t PFX##_remove_all(struct SNAME *_set_, V value) \ + size_t CMC_(PFX, _remove_all)(struct SNAME * _set_, V value) \ { \ - if (PFX##_empty(_set_)) \ + if (CMC_(PFX, _empty)(_set_)) \ { \ - _set_->flag = cmc_flags.EMPTY; \ + _set_->flag = CMC_FLAG_EMPTY; \ return false; \ } \ \ - struct SNAME##_entry *result = PFX##_impl_get_entry(_set_, value); \ + struct CMC_DEF_ENTRY(SNAME) *result = \ + CMC_(PFX, _impl_get_entry)(_set_, value); \ \ if (!result) \ { \ - _set_->flag = cmc_flags.NOT_FOUND; \ + _set_->flag = CMC_FLAG_NOT_FOUND; \ return 0; \ } \ \ @@ -557,7 +583,7 @@ static const char *cmc_string_fmt_hashmultiset = "struct %s<%s> " \ _set_->count--; \ _set_->cardinality -= removed; \ - _set_->flag = cmc_flags.OK; \ + _set_->flag = CMC_FLAG_OK; \ \ if (_set_->callbacks && _set_->callbacks->delete) \ _set_->callbacks->delete (); \ @@ -565,22 +591,22 @@ static const char *cmc_string_fmt_hashmultiset = "struct %s<%s> " return removed; \ } \ \ - bool PFX##_max(struct SNAME *_set_, V *value) \ + bool CMC_(PFX, _max)(struct SNAME * _set_, V * value) \ { \ - if (PFX##_empty(_set_)) \ + if (CMC_(PFX, _empty)(_set_)) \ { \ - _set_->flag = cmc_flags.EMPTY; \ + _set_->flag = CMC_FLAG_EMPTY; \ return false; \ } \ \ V max_val; \ - struct SNAME##_iter iter = PFX##_iter_start(_set_); \ + struct CMC_DEF_ITER(SNAME) iter = CMC_(PFX, _iter_start)(_set_); \ \ /* TODO transform this into a normal loop */ \ - for (; !PFX##_iter_at_end(&iter); PFX##_iter_next(&iter)) \ + for (; !CMC_(PFX, _iter_at_end)(&iter); CMC_(PFX, _iter_next)(&iter)) \ { \ - V result = PFX##_iter_value(&iter); \ - size_t index = PFX##_iter_index(&iter); \ + V result = CMC_(PFX, _iter_value)(&iter); \ + size_t index = CMC_(PFX, _iter_index)(&iter); \ \ if (index == 0) \ max_val = result; \ @@ -591,7 +617,7 @@ static const char *cmc_string_fmt_hashmultiset = "struct %s<%s> " if (value) \ *value = max_val; \ \ - _set_->flag = cmc_flags.OK; \ + _set_->flag = CMC_FLAG_OK; \ \ if (_set_->callbacks && _set_->callbacks->read) \ _set_->callbacks->read(); \ @@ -599,22 +625,22 @@ static const char *cmc_string_fmt_hashmultiset = "struct %s<%s> " return true; \ } \ \ - bool PFX##_min(struct SNAME *_set_, V *value) \ + bool CMC_(PFX, _min)(struct SNAME * _set_, V * value) \ { \ - if (PFX##_empty(_set_)) \ + if (CMC_(PFX, _empty)(_set_)) \ { \ - _set_->flag = cmc_flags.EMPTY; \ + _set_->flag = CMC_FLAG_EMPTY; \ return false; \ } \ \ V min_val; \ - struct SNAME##_iter iter = PFX##_iter_start(_set_); \ + struct CMC_DEF_ITER(SNAME) iter = CMC_(PFX, _iter_start)(_set_); \ \ /* TODO transform this into a normal loop */ \ - for (; !PFX##_iter_at_end(&iter); PFX##_iter_next(&iter)) \ + for (; !CMC_(PFX, _iter_at_end)(&iter); CMC_(PFX, _iter_next)(&iter)) \ { \ - V result = PFX##_iter_value(&iter); \ - size_t index = PFX##_iter_index(&iter); \ + V result = CMC_(PFX, _iter_value)(&iter); \ + size_t index = CMC_(PFX, _iter_index)(&iter); \ \ if (index == 0) \ min_val = result; \ @@ -625,7 +651,7 @@ static const char *cmc_string_fmt_hashmultiset = "struct %s<%s> " if (value) \ *value = min_val; \ \ - _set_->flag = cmc_flags.OK; \ + _set_->flag = CMC_FLAG_OK; \ \ if (_set_->callbacks && _set_->callbacks->read) \ _set_->callbacks->read(); \ @@ -633,11 +659,12 @@ static const char *cmc_string_fmt_hashmultiset = "struct %s<%s> " return true; \ } \ \ - size_t PFX##_multiplicity_of(struct SNAME *_set_, V value) \ + size_t CMC_(PFX, _multiplicity_of)(struct SNAME * _set_, V value) \ { \ - struct SNAME##_entry *entry = PFX##_impl_get_entry(_set_, value); \ + struct CMC_DEF_ENTRY(SNAME) *entry = \ + CMC_(PFX, _impl_get_entry)(_set_, value); \ \ - _set_->flag = cmc_flags.OK; \ + _set_->flag = CMC_FLAG_OK; \ \ if (_set_->callbacks && _set_->callbacks->read) \ _set_->callbacks->read(); \ @@ -648,11 +675,11 @@ static const char *cmc_string_fmt_hashmultiset = "struct %s<%s> " return entry->multiplicity; \ } \ \ - bool PFX##_contains(struct SNAME *_set_, V value) \ + bool CMC_(PFX, _contains)(struct SNAME * _set_, V value) \ { \ - _set_->flag = cmc_flags.OK; \ + _set_->flag = CMC_FLAG_OK; \ \ - bool result = PFX##_impl_get_entry(_set_, value) != NULL; \ + bool result = CMC_(PFX, _impl_get_entry)(_set_, value) != NULL; \ \ if (_set_->callbacks && _set_->callbacks->read) \ _set_->callbacks->read(); \ @@ -660,44 +687,44 @@ static const char *cmc_string_fmt_hashmultiset = "struct %s<%s> " return result; \ } \ \ - bool PFX##_empty(struct SNAME *_set_) \ + bool CMC_(PFX, _empty)(struct SNAME * _set_) \ { \ return _set_->count == 0; \ } \ \ - bool PFX##_full(struct SNAME *_set_) \ + bool CMC_(PFX, _full)(struct SNAME * _set_) \ { \ return (double)_set_->capacity * _set_->load <= (double)_set_->count; \ } \ \ - size_t PFX##_count(struct SNAME *_set_) \ + size_t CMC_(PFX, _count)(struct SNAME * _set_) \ { \ return _set_->count; \ } \ \ - size_t PFX##_cardinality(struct SNAME *_set_) \ + size_t CMC_(PFX, _cardinality)(struct SNAME * _set_) \ { \ return _set_->cardinality; \ } \ \ - size_t PFX##_capacity(struct SNAME *_set_) \ + size_t CMC_(PFX, _capacity)(struct SNAME * _set_) \ { \ return _set_->capacity; \ } \ \ - double PFX##_load(struct SNAME *_set_) \ + double CMC_(PFX, _load)(struct SNAME * _set_) \ { \ return _set_->load; \ } \ \ - int PFX##_flag(struct SNAME *_set_) \ + int CMC_(PFX, _flag)(struct SNAME * _set_) \ { \ return _set_->flag; \ } \ \ - bool PFX##_resize(struct SNAME *_set_, size_t capacity) \ + bool CMC_(PFX, _resize)(struct SNAME * _set_, size_t capacity) \ { \ - _set_->flag = cmc_flags.OK; \ + _set_->flag = CMC_FLAG_OK; \ \ if (_set_->capacity == capacity) \ goto success; \ @@ -708,48 +735,49 @@ static const char *cmc_string_fmt_hashmultiset = "struct %s<%s> " /* Prevent integer overflow */ \ if (capacity >= UINTMAX_MAX * _set_->load) \ { \ - _set_->flag = cmc_flags.ERROR; \ + _set_->flag = CMC_FLAG_ERROR; \ return false; \ } \ \ /* Calculate required capacity based on the prime numbers */ \ - size_t theoretical_size = PFX##_impl_calculate_size(capacity); \ + size_t theoretical_size = CMC_(PFX, _impl_calculate_size)(capacity); \ \ /* Not possible to shrink with current available prime numbers */ \ if (theoretical_size < _set_->count / _set_->load) \ { \ - _set_->flag = cmc_flags.INVALID; \ + _set_->flag = CMC_FLAG_INVALID; \ return false; \ } \ \ /* No callbacks since _new_set_ is just a temporary hashtable */ \ - struct SNAME *_new_set_ = PFX##_new_custom( \ + struct SNAME *_new_set_ = CMC_(PFX, _new_custom)( \ capacity, _set_->load, _set_->f_val, _set_->alloc, NULL); \ \ if (!_new_set_) \ { \ - _set_->flag = cmc_flags.ERROR; \ + _set_->flag = CMC_FLAG_ERROR; \ return false; \ } \ \ - struct SNAME##_iter iter = PFX##_iter_start(_set_); \ + struct CMC_DEF_ITER(SNAME) iter = CMC_(PFX, _iter_start)(_set_); \ \ /* TODO transform this into a normal loop */ \ - for (; !PFX##_iter_at_end(&iter); PFX##_iter_next(&iter)) \ + for (; !CMC_(PFX, _iter_at_end)(&iter); CMC_(PFX, _iter_next)(&iter)) \ { \ - PFX##_insert_many(_new_set_, PFX##_iter_value(&iter), \ - PFX##_iter_multiplicity(&iter)); \ + CMC_(PFX, _insert_many) \ + (_new_set_, CMC_(PFX, _iter_value)(&iter), \ + CMC_(PFX, _iter_multiplicity)(&iter)); \ } \ \ if (_set_->count != _new_set_->count) \ { \ - PFX##_free(_new_set_); \ + CMC_(PFX, _free)(_new_set_); \ \ - _set_->flag = cmc_flags.ERROR; \ + _set_->flag = CMC_FLAG_ERROR; \ return false; \ } \ \ - struct SNAME##_entry *tmp_b = _set_->buffer; \ + struct CMC_DEF_ENTRY(SNAME) *tmp_b = _set_->buffer; \ _set_->buffer = _new_set_->buffer; \ _new_set_->buffer = tmp_b; \ \ @@ -758,9 +786,9 @@ static const char *cmc_string_fmt_hashmultiset = "struct %s<%s> " _new_set_->capacity = tmp_c; \ \ /* Prevent the set from freeing the data */ \ - _new_set_->f_val = &(struct SNAME##_fval){ NULL }; \ + _new_set_->f_val = &(struct CMC_DEF_FVAL(SNAME)){ NULL }; \ \ - PFX##_free(_new_set_); \ + CMC_(PFX, _free)(_new_set_); \ \ success: \ \ @@ -770,15 +798,15 @@ static const char *cmc_string_fmt_hashmultiset = "struct %s<%s> " return true; \ } \ \ - struct SNAME *PFX##_copy_of(struct SNAME *_set_) \ + struct SNAME *CMC_(PFX, _copy_of)(struct SNAME * _set_) \ { \ - struct SNAME *result = \ - PFX##_new_custom(_set_->capacity * _set_->load, _set_->load, \ - _set_->f_val, _set_->alloc, _set_->callbacks); \ + struct SNAME *result = CMC_(PFX, _new_custom)( \ + _set_->capacity * _set_->load, _set_->load, _set_->f_val, \ + _set_->alloc, _set_->callbacks); \ \ if (!result) \ { \ - _set_->flag = cmc_flags.ERROR; \ + _set_->flag = CMC_FLAG_ERROR; \ return NULL; \ } \ \ @@ -786,11 +814,12 @@ static const char *cmc_string_fmt_hashmultiset = "struct %s<%s> " { \ for (size_t i = 0; i < _set_->capacity; i++) \ { \ - struct SNAME##_entry *scan = &(_set_->buffer[i]); \ + struct CMC_DEF_ENTRY(SNAME) *scan = &(_set_->buffer[i]); \ \ if (scan->state != CMC_ES_EMPTY) \ { \ - struct SNAME##_entry *target = &(result->buffer[i]); \ + struct CMC_DEF_ENTRY(SNAME) *target = \ + &(result->buffer[i]); \ \ if (scan->state == CMC_ES_DELETED) \ target->state = CMC_ES_DELETED; \ @@ -807,20 +836,20 @@ static const char *cmc_string_fmt_hashmultiset = "struct %s<%s> " } \ else \ memcpy(result->buffer, _set_->buffer, \ - sizeof(struct SNAME##_entry) * _set_->capacity); \ + sizeof(struct CMC_DEF_ENTRY(SNAME)) * _set_->capacity); \ \ result->count = _set_->count; \ result->cardinality = _set_->cardinality; \ \ - _set_->flag = cmc_flags.OK; \ + _set_->flag = CMC_FLAG_OK; \ \ return result; \ } \ \ - bool PFX##_equals(struct SNAME *_set1_, struct SNAME *_set2_) \ + bool CMC_(PFX, _equals)(struct SNAME * _set1_, struct SNAME * _set2_) \ { \ - _set1_->flag = cmc_flags.OK; \ - _set2_->flag = cmc_flags.OK; \ + _set1_->flag = CMC_FLAG_OK; \ + _set2_->flag = CMC_FLAG_OK; \ \ if (_set1_->count != _set2_->count) \ return false; \ @@ -831,41 +860,41 @@ static const char *cmc_string_fmt_hashmultiset = "struct %s<%s> " if (_set1_->count == 0) \ return true; \ \ - struct SNAME##_iter iter = PFX##_iter_start(_set1_); \ + struct CMC_DEF_ITER(SNAME) iter = CMC_(PFX, _iter_start)(_set1_); \ \ - for (; !PFX##_iter_at_end(&iter); PFX##_iter_next(&iter)) \ + for (; !CMC_(PFX, _iter_at_end)(&iter); CMC_(PFX, _iter_next)(&iter)) \ { \ - struct SNAME##_entry *entry = \ - PFX##_impl_get_entry(_set2_, PFX##_iter_value(&iter)); \ + struct CMC_DEF_ENTRY(SNAME) *entry = CMC_(PFX, _impl_get_entry)( \ + _set2_, CMC_(PFX, _iter_value)(&iter)); \ \ if (!entry) \ return false; \ \ - if (entry->multiplicity != PFX##_iter_multiplicity(&iter)) \ + if (entry->multiplicity != CMC_(PFX, _iter_multiplicity)(&iter)) \ return false; \ } \ \ return true; \ } \ \ - struct cmc_string PFX##_to_string(struct SNAME *_set_) \ + struct cmc_string CMC_(PFX, _to_string)(struct SNAME * _set_) \ { \ struct cmc_string str; \ struct SNAME *s_ = _set_; \ \ - int n = snprintf(str.s, cmc_string_len, cmc_string_fmt_hashmultiset, \ - #SNAME, #V, s_, s_->buffer, s_->capacity, s_->count, \ - s_->cardinality, s_->load, s_->flag, s_->f_val, \ - s_->alloc, s_->callbacks); \ + int n = snprintf( \ + str.s, cmc_string_len, cmc_cmc_string_fmt_hashmultiset, #SNAME, \ + #V, s_, s_->buffer, s_->capacity, s_->count, s_->cardinality, \ + s_->load, s_->flag, s_->f_val, s_->alloc, s_->callbacks); \ \ return n >= 0 ? str : (struct cmc_string){ 0 }; \ } \ \ - bool PFX##_print(struct SNAME *_set_, FILE *fptr) \ + bool CMC_(PFX, _print)(struct SNAME * _set_, FILE * fptr) \ { \ for (size_t i = 0; i < _set_->capacity; i++) \ { \ - struct SNAME##_entry *entry = &(_set_->buffer[i]); \ + struct CMC_DEF_ENTRY(SNAME) *entry = &(_set_->buffer[i]); \ \ if (entry->state == CMC_ES_FILLED) \ { \ @@ -877,39 +906,42 @@ static const char *cmc_string_fmt_hashmultiset = "struct %s<%s> " return true; \ } \ \ - struct SNAME *PFX##_union(struct SNAME *_set1_, struct SNAME *_set2_) \ + struct SNAME *CMC_(PFX, _union)(struct SNAME * _set1_, \ + struct SNAME * _set2_) \ { \ /* Callbacks are added later */ \ struct SNAME *_set_r_ = \ - PFX##_new_custom(_set1_->capacity, _set1_->load, _set1_->f_val, \ - _set1_->alloc, NULL); \ + CMC_(PFX, _new_custom)(_set1_->capacity, _set1_->load, \ + _set1_->f_val, _set1_->alloc, NULL); \ \ if (!_set_r_) \ return NULL; \ \ - struct SNAME##_iter iter1 = PFX##_iter_start(_set1_); \ - struct SNAME##_iter iter2 = PFX##_iter_start(_set2_); \ + struct CMC_DEF_ITER(SNAME) iter1 = CMC_(PFX, _iter_start)(_set1_); \ + struct CMC_DEF_ITER(SNAME) iter2 = CMC_(PFX, _iter_start)(_set2_); \ \ - for (; !PFX##_iter_at_end(&iter1); PFX##_iter_next(&iter1)) \ + for (; !CMC_(PFX, _iter_at_end)(&iter1); \ + CMC_(PFX, _iter_next)(&iter1)) \ { \ - V value = PFX##_iter_value(&iter1); \ + V value = CMC_(PFX, _iter_value)(&iter1); \ \ - size_t m1 = PFX##_iter_multiplicity(&iter1); \ - size_t m2 = PFX##_impl_multiplicity_of(_set2_, value); \ + size_t m1 = CMC_(PFX, _iter_multiplicity)(&iter1); \ + size_t m2 = CMC_(PFX, _impl_multiplicity_of)(_set2_, value); \ size_t max_ = m1 > m2 ? m1 : m2; \ \ - PFX##_update(_set_r_, value, max_); \ + CMC_(PFX, _update)(_set_r_, value, max_); \ } \ \ - for (; !PFX##_iter_at_end(&iter2); PFX##_iter_next(&iter2)) \ + for (; !CMC_(PFX, _iter_at_end)(&iter2); \ + CMC_(PFX, _iter_next)(&iter2)) \ { \ - V value = PFX##_iter_value(&iter2); \ + V value = CMC_(PFX, _iter_value)(&iter2); \ \ - size_t m1 = PFX##_impl_multiplicity_of(_set1_, value); \ - size_t m2 = PFX##_iter_multiplicity(&iter2); \ + size_t m1 = CMC_(PFX, _impl_multiplicity_of)(_set1_, value); \ + size_t m2 = CMC_(PFX, _iter_multiplicity)(&iter2); \ size_t max_ = m1 > m2 ? m1 : m2; \ \ - PFX##_update(_set_r_, value, max_); \ + CMC_(PFX, _update)(_set_r_, value, max_); \ } \ \ _set_r_->callbacks = _set1_->callbacks; \ @@ -917,13 +949,13 @@ static const char *cmc_string_fmt_hashmultiset = "struct %s<%s> " return _set_r_; \ } \ \ - struct SNAME *PFX##_intersection(struct SNAME *_set1_, \ - struct SNAME *_set2_) \ + struct SNAME *CMC_(PFX, _intersection)(struct SNAME * _set1_, \ + struct SNAME * _set2_) \ { \ /* Callbacks are added later */ \ struct SNAME *_set_r_ = \ - PFX##_new_custom(_set1_->capacity, _set1_->load, _set1_->f_val, \ - _set1_->alloc, NULL); \ + CMC_(PFX, _new_custom)(_set1_->capacity, _set1_->load, \ + _set1_->f_val, _set1_->alloc, NULL); \ \ if (!_set_r_) \ return NULL; \ @@ -932,17 +964,17 @@ static const char *cmc_string_fmt_hashmultiset = "struct %s<%s> " _set1_->count < _set2_->count ? _set1_ : _set2_; \ struct SNAME *_set_B_ = _set_A_ == _set1_ ? _set2_ : _set1_; \ \ - struct SNAME##_iter iter = PFX##_iter_start(_set_A_); \ + struct CMC_DEF_ITER(SNAME) iter = CMC_(PFX, _iter_start)(_set_A_); \ \ - for (; !PFX##_iter_at_end(&iter); PFX##_iter_next(&iter)) \ + for (; !CMC_(PFX, _iter_at_end)(&iter); CMC_(PFX, _iter_next)(&iter)) \ { \ - V value = PFX##_iter_value(&iter); \ + V value = CMC_(PFX, _iter_value)(&iter); \ \ - size_t m1 = PFX##_iter_multiplicity(&iter); \ - size_t m2 = PFX##_impl_multiplicity_of(_set_B_, value); \ + size_t m1 = CMC_(PFX, _iter_multiplicity)(&iter); \ + size_t m2 = CMC_(PFX, _impl_multiplicity_of)(_set_B_, value); \ size_t max_ = m1 < m2 ? m1 : m2; \ \ - PFX##_update(_set_r_, value, max_); \ + CMC_(PFX, _update)(_set_r_, value, max_); \ } \ \ _set_r_->callbacks = _set1_->callbacks; \ @@ -950,27 +982,28 @@ static const char *cmc_string_fmt_hashmultiset = "struct %s<%s> " return _set_r_; \ } \ \ - struct SNAME *PFX##_difference(struct SNAME *_set1_, struct SNAME *_set2_) \ + struct SNAME *CMC_(PFX, _difference)(struct SNAME * _set1_, \ + struct SNAME * _set2_) \ { \ /* Callbacks are added later */ \ struct SNAME *_set_r_ = \ - PFX##_new_custom(_set1_->capacity, _set1_->load, _set1_->f_val, \ - _set1_->alloc, NULL); \ + CMC_(PFX, _new_custom)(_set1_->capacity, _set1_->load, \ + _set1_->f_val, _set1_->alloc, NULL); \ \ if (!_set_r_) \ return NULL; \ \ - struct SNAME##_iter iter = PFX##_iter_start(_set1_); \ + struct CMC_DEF_ITER(SNAME) iter = CMC_(PFX, _iter_start)(_set1_); \ \ - for (; !PFX##_iter_at_end(&iter); PFX##_iter_next(&iter)) \ + for (; !CMC_(PFX, _iter_at_end)(&iter); CMC_(PFX, _iter_next)(&iter)) \ { \ - V value = PFX##_iter_value(&iter); \ + V value = CMC_(PFX, _iter_value)(&iter); \ \ - size_t m1 = PFX##_iter_multiplicity(&iter); \ - size_t m2 = PFX##_impl_multiplicity_of(_set2_, value); \ + size_t m1 = CMC_(PFX, _iter_multiplicity)(&iter); \ + size_t m2 = CMC_(PFX, _impl_multiplicity_of)(_set2_, value); \ \ if (m1 > m2) \ - PFX##_update(_set_r_, value, m1 - m2); \ + CMC_(PFX, _update)(_set_r_, value, m1 - m2); \ } \ \ _set_r_->callbacks = _set1_->callbacks; \ @@ -978,29 +1011,34 @@ static const char *cmc_string_fmt_hashmultiset = "struct %s<%s> " return _set_r_; \ } \ \ - struct SNAME *PFX##_summation(struct SNAME *_set1_, struct SNAME *_set2_) \ + struct SNAME *CMC_(PFX, _summation)(struct SNAME * _set1_, \ + struct SNAME * _set2_) \ { \ /* Callbacks are added later */ \ struct SNAME *_set_r_ = \ - PFX##_new_custom(_set1_->capacity, _set1_->load, _set1_->f_val, \ - _set1_->alloc, NULL); \ + CMC_(PFX, _new_custom)(_set1_->capacity, _set1_->load, \ + _set1_->f_val, _set1_->alloc, NULL); \ \ if (!_set_r_) \ return NULL; \ \ - struct SNAME##_iter iter1 = PFX##_iter_start(_set1_); \ - struct SNAME##_iter iter2 = PFX##_iter_start(_set2_); \ + struct CMC_DEF_ITER(SNAME) iter1 = CMC_(PFX, _iter_start)(_set1_); \ + struct CMC_DEF_ITER(SNAME) iter2 = CMC_(PFX, _iter_start)(_set2_); \ \ - for (; !PFX##_iter_at_end(&iter1); PFX##_iter_next(&iter1)) \ + for (; !CMC_(PFX, _iter_at_end)(&iter1); \ + CMC_(PFX, _iter_next)(&iter1)) \ { \ - PFX##_insert_many(_set_r_, PFX##_iter_value(&iter1), \ - PFX##_iter_multiplicity(&iter1)); \ + CMC_(PFX, _insert_many) \ + (_set_r_, CMC_(PFX, _iter_value)(&iter1), \ + CMC_(PFX, _iter_multiplicity)(&iter1)); \ } \ \ - for (; !PFX##_iter_at_end(&iter2); PFX##_iter_next(&iter2)) \ + for (; !CMC_(PFX, _iter_at_end)(&iter2); \ + CMC_(PFX, _iter_next)(&iter2)) \ { \ - PFX##_insert_many(_set_r_, PFX##_iter_value(&iter2), \ - PFX##_iter_multiplicity(&iter2)); \ + CMC_(PFX, _insert_many) \ + (_set_r_, CMC_(PFX, _iter_value)(&iter2), \ + CMC_(PFX, _iter_multiplicity)(&iter2)); \ } \ \ _set_r_->callbacks = _set1_->callbacks; \ @@ -1008,48 +1046,50 @@ static const char *cmc_string_fmt_hashmultiset = "struct %s<%s> " return _set_r_; \ } \ \ - struct SNAME *PFX##_symmetric_difference(struct SNAME *_set1_, \ - struct SNAME *_set2_) \ + struct SNAME *CMC_(PFX, _symmetric_difference)(struct SNAME * _set1_, \ + struct SNAME * _set2_) \ { \ /* Callbacks are added later */ \ struct SNAME *_set_r_ = \ - PFX##_new_custom(_set1_->capacity, _set1_->load, _set1_->f_val, \ - _set1_->alloc, NULL); \ + CMC_(PFX, _new_custom)(_set1_->capacity, _set1_->load, \ + _set1_->f_val, _set1_->alloc, NULL); \ \ if (!_set_r_) \ return NULL; \ - struct SNAME##_iter iter1 = PFX##_iter_start(_set1_); \ - struct SNAME##_iter iter2 = PFX##_iter_start(_set2_); \ + struct CMC_DEF_ITER(SNAME) iter1 = CMC_(PFX, _iter_start)(_set1_); \ + struct CMC_DEF_ITER(SNAME) iter2 = CMC_(PFX, _iter_start)(_set2_); \ \ - for (; !PFX##_iter_at_end(&iter1); PFX##_iter_next(&iter1)) \ + for (; !CMC_(PFX, _iter_at_end)(&iter1); \ + CMC_(PFX, _iter_next)(&iter1)) \ { \ - V value = PFX##_iter_value(&iter1); \ + V value = CMC_(PFX, _iter_value)(&iter1); \ \ - size_t m1 = PFX##_iter_multiplicity(&iter1); \ - size_t m2 = PFX##_impl_multiplicity_of(_set2_, value); \ + size_t m1 = CMC_(PFX, _iter_multiplicity)(&iter1); \ + size_t m2 = CMC_(PFX, _impl_multiplicity_of)(_set2_, value); \ \ if (m1 != m2) \ { \ if (m1 > m2) \ - PFX##_update(_set_r_, value, m1 - m2); \ + CMC_(PFX, _update)(_set_r_, value, m1 - m2); \ else \ - PFX##_update(_set_r_, value, m2 - m1); \ + CMC_(PFX, _update)(_set_r_, value, m2 - m1); \ } \ } \ \ - for (; !PFX##_iter_at_end(&iter2); PFX##_iter_next(&iter2)) \ + for (; !CMC_(PFX, _iter_at_end)(&iter2); \ + CMC_(PFX, _iter_next)(&iter2)) \ { \ - V value = PFX##_iter_value(&iter2); \ + V value = CMC_(PFX, _iter_value)(&iter2); \ \ - size_t m1 = PFX##_impl_multiplicity_of(_set1_, value); \ - size_t m2 = PFX##_iter_multiplicity(&iter2); \ + size_t m1 = CMC_(PFX, _impl_multiplicity_of)(_set1_, value); \ + size_t m2 = CMC_(PFX, _iter_multiplicity)(&iter2); \ \ if (m1 != m2) \ { \ if (m1 > m2) \ - PFX##_update(_set_r_, value, m1 - m2); \ + CMC_(PFX, _update)(_set_r_, value, m1 - m2); \ else \ - PFX##_update(_set_r_, value, m2 - m1); \ + CMC_(PFX, _update)(_set_r_, value, m2 - m1); \ } \ } \ \ @@ -1058,22 +1098,22 @@ static const char *cmc_string_fmt_hashmultiset = "struct %s<%s> " return _set_r_; \ } \ \ - bool PFX##_is_subset(struct SNAME *_set1_, struct SNAME *_set2_) \ + bool CMC_(PFX, _is_subset)(struct SNAME * _set1_, struct SNAME * _set2_) \ { \ if (_set1_->count > _set2_->count) \ return false; \ \ - if (PFX##_empty(_set1_)) \ + if (CMC_(PFX, _empty)(_set1_)) \ return true; \ \ - struct SNAME##_iter iter = PFX##_iter_start(_set1_); \ + struct CMC_DEF_ITER(SNAME) iter = CMC_(PFX, _iter_start)(_set1_); \ \ - for (; !PFX##_iter_at_end(&iter); PFX##_iter_next(&iter)) \ + for (; !CMC_(PFX, _iter_at_end)(&iter); CMC_(PFX, _iter_next)(&iter)) \ { \ - V value = PFX##_iter_value(&iter); \ + V value = CMC_(PFX, _iter_value)(&iter); \ \ - size_t m1 = PFX##_iter_multiplicity(&iter); \ - size_t m2 = PFX##_impl_multiplicity_of(_set2_, value); \ + size_t m1 = CMC_(PFX, _iter_multiplicity)(&iter); \ + size_t m2 = CMC_(PFX, _impl_multiplicity_of)(_set2_, value); \ \ if (m1 > m2) \ return false; \ @@ -1082,32 +1122,33 @@ static const char *cmc_string_fmt_hashmultiset = "struct %s<%s> " return true; \ } \ \ - bool PFX##_is_superset(struct SNAME *_set1_, struct SNAME *_set2_) \ + bool CMC_(PFX, _is_superset)(struct SNAME * _set1_, struct SNAME * _set2_) \ { \ - return PFX##_is_subset(_set2_, _set1_); \ + return CMC_(PFX, _is_subset)(_set2_, _set1_); \ } \ \ - bool PFX##_is_proper_subset(struct SNAME *_set1_, struct SNAME *_set2_) \ + bool CMC_(PFX, _is_proper_subset)(struct SNAME * _set1_, \ + struct SNAME * _set2_) \ { \ if (_set1_->count >= _set2_->count) \ return false; \ \ - if (PFX##_empty(_set1_)) \ + if (CMC_(PFX, _empty)(_set1_)) \ { \ - if (!PFX##_empty(_set2_)) \ + if (!CMC_(PFX, _empty)(_set2_)) \ return true; \ else \ return false; \ } \ \ - struct SNAME##_iter iter = PFX##_iter_start(_set1_); \ + struct CMC_DEF_ITER(SNAME) iter = CMC_(PFX, _iter_start)(_set1_); \ \ - for (; !PFX##_iter_at_end(&iter); PFX##_iter_next(&iter)) \ + for (; !CMC_(PFX, _iter_at_end)(&iter); CMC_(PFX, _iter_next)(&iter)) \ { \ - V value = PFX##_iter_value(&iter); \ + V value = CMC_(PFX, _iter_value)(&iter); \ \ - size_t m1 = PFX##_iter_multiplicity(&iter); \ - size_t m2 = PFX##_impl_multiplicity_of(_set2_, value); \ + size_t m1 = CMC_(PFX, _iter_multiplicity)(&iter); \ + size_t m2 = CMC_(PFX, _impl_multiplicity_of)(_set2_, value); \ \ if (m1 >= m2) \ return false; \ @@ -1116,32 +1157,34 @@ static const char *cmc_string_fmt_hashmultiset = "struct %s<%s> " return true; \ } \ \ - bool PFX##_is_proper_superset(struct SNAME *_set1_, struct SNAME *_set2_) \ + bool CMC_(PFX, _is_proper_superset)(struct SNAME * _set1_, \ + struct SNAME * _set2_) \ { \ - return PFX##_is_proper_subset(_set2_, _set1_); \ + return CMC_(PFX, _is_proper_subset)(_set2_, _set1_); \ } \ \ - bool PFX##_is_disjointset(struct SNAME *_set1_, struct SNAME *_set2_) \ + bool CMC_(PFX, _is_disjointset)(struct SNAME * _set1_, \ + struct SNAME * _set2_) \ { \ - if (PFX##_empty(_set1_)) \ + if (CMC_(PFX, _empty)(_set1_)) \ return true; \ \ - struct SNAME##_iter iter = PFX##_iter_start(_set1_); \ + struct CMC_DEF_ITER(SNAME) iter = CMC_(PFX, _iter_start)(_set1_); \ \ - for (; !PFX##_iter_at_end(&iter); PFX##_iter_next(&iter)) \ + for (; !CMC_(PFX, _iter_at_end)(&iter); CMC_(PFX, _iter_next)(&iter)) \ { \ - V value = PFX##_iter_value(&iter); \ + V value = CMC_(PFX, _iter_value)(&iter); \ \ - if (PFX##_impl_get_entry(_set2_, value) != NULL) \ + if (CMC_(PFX, _impl_get_entry)(_set2_, value) != NULL) \ return false; \ } \ \ return true; \ } \ \ - struct SNAME##_iter PFX##_iter_start(struct SNAME *target) \ + struct CMC_DEF_ITER(SNAME) CMC_(PFX, _iter_start)(struct SNAME * target) \ { \ - struct SNAME##_iter iter; \ + struct CMC_DEF_ITER(SNAME) iter; \ \ iter.target = target; \ iter.cursor = 0; \ @@ -1149,9 +1192,9 @@ static const char *cmc_string_fmt_hashmultiset = "struct %s<%s> " iter.first = 0; \ iter.last = 0; \ iter.start = true; \ - iter.end = PFX##_empty(target); \ + iter.end = CMC_(PFX, _empty)(target); \ \ - if (!PFX##_empty(target)) \ + if (!CMC_(PFX, _empty)(target)) \ { \ for (size_t i = 0; i < target->capacity; i++) \ { \ @@ -1177,19 +1220,19 @@ static const char *cmc_string_fmt_hashmultiset = "struct %s<%s> " return iter; \ } \ \ - struct SNAME##_iter PFX##_iter_end(struct SNAME *target) \ + struct CMC_DEF_ITER(SNAME) CMC_(PFX, _iter_end)(struct SNAME * target) \ { \ - struct SNAME##_iter iter; \ + struct CMC_DEF_ITER(SNAME) iter; \ \ iter.target = target; \ iter.cursor = 0; \ iter.index = 0; \ iter.first = 0; \ iter.last = 0; \ - iter.start = PFX##_empty(target); \ + iter.start = CMC_(PFX, _empty)(target); \ iter.end = true; \ \ - if (!PFX##_empty(target)) \ + if (!CMC_(PFX, _empty)(target)) \ { \ for (size_t i = 0; i < target->capacity; i++) \ { \ @@ -1216,24 +1259,24 @@ static const char *cmc_string_fmt_hashmultiset = "struct %s<%s> " return iter; \ } \ \ - bool PFX##_iter_at_start(struct SNAME##_iter *iter) \ + bool CMC_(PFX, _iter_at_start)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ - return PFX##_empty(iter->target) || iter->start; \ + return CMC_(PFX, _empty)(iter->target) || iter->start; \ } \ \ - bool PFX##_iter_at_end(struct SNAME##_iter *iter) \ + bool CMC_(PFX, _iter_at_end)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ - return PFX##_empty(iter->target) || iter->end; \ + return CMC_(PFX, _empty)(iter->target) || iter->end; \ } \ \ - bool PFX##_iter_to_start(struct SNAME##_iter *iter) \ + bool CMC_(PFX, _iter_to_start)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ - if (!PFX##_empty(iter->target)) \ + if (!CMC_(PFX, _empty)(iter->target)) \ { \ iter->cursor = iter->first; \ iter->index = 0; \ iter->start = true; \ - iter->end = PFX##_empty(iter->target); \ + iter->end = CMC_(PFX, _empty)(iter->target); \ \ return true; \ } \ @@ -1241,13 +1284,13 @@ static const char *cmc_string_fmt_hashmultiset = "struct %s<%s> " return false; \ } \ \ - bool PFX##_iter_to_end(struct SNAME##_iter *iter) \ + bool CMC_(PFX, _iter_to_end)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ - if (!PFX##_empty(iter->target)) \ + if (!CMC_(PFX, _empty)(iter->target)) \ { \ iter->cursor = iter->last; \ iter->index = iter->target->count - 1; \ - iter->start = PFX##_empty(iter->target); \ + iter->start = CMC_(PFX, _empty)(iter->target); \ iter->end = true; \ \ return true; \ @@ -1256,7 +1299,7 @@ static const char *cmc_string_fmt_hashmultiset = "struct %s<%s> " return false; \ } \ \ - bool PFX##_iter_next(struct SNAME##_iter *iter) \ + bool CMC_(PFX, _iter_next)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ if (iter->end) \ return false; \ @@ -1267,9 +1310,10 @@ static const char *cmc_string_fmt_hashmultiset = "struct %s<%s> " return false; \ } \ \ - iter->start = PFX##_empty(iter->target); \ + iter->start = CMC_(PFX, _empty)(iter->target); \ \ - struct SNAME##_entry *scan = &(iter->target->buffer[iter->cursor]); \ + struct CMC_DEF_ENTRY(SNAME) *scan = \ + &(iter->target->buffer[iter->cursor]); \ \ iter->index++; \ \ @@ -1285,7 +1329,7 @@ static const char *cmc_string_fmt_hashmultiset = "struct %s<%s> " return true; \ } \ \ - bool PFX##_iter_prev(struct SNAME##_iter *iter) \ + bool CMC_(PFX, _iter_prev)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ if (iter->start) \ return false; \ @@ -1296,9 +1340,10 @@ static const char *cmc_string_fmt_hashmultiset = "struct %s<%s> " return false; \ } \ \ - iter->end = PFX##_empty(iter->target); \ + iter->end = CMC_(PFX, _empty)(iter->target); \ \ - struct SNAME##_entry *scan = &(iter->target->buffer[iter->cursor]); \ + struct CMC_DEF_ENTRY(SNAME) *scan = \ + &(iter->target->buffer[iter->cursor]); \ \ iter->index--; \ \ @@ -1315,7 +1360,8 @@ static const char *cmc_string_fmt_hashmultiset = "struct %s<%s> " } \ \ /* Returns true only if the iterator moved */ \ - bool PFX##_iter_advance(struct SNAME##_iter *iter, size_t steps) \ + bool CMC_(PFX, _iter_advance)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t steps) \ { \ if (iter->end) \ return false; \ @@ -1330,13 +1376,14 @@ static const char *cmc_string_fmt_hashmultiset = "struct %s<%s> " return false; \ \ for (size_t i = 0; i < steps; i++) \ - PFX##_iter_next(iter); \ + CMC_(PFX, _iter_next)(iter); \ \ return true; \ } \ \ /* Returns true only if the iterator moved */ \ - bool PFX##_iter_rewind(struct SNAME##_iter *iter, size_t steps) \ + bool CMC_(PFX, _iter_rewind)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t steps) \ { \ if (iter->start) \ return false; \ @@ -1351,50 +1398,53 @@ static const char *cmc_string_fmt_hashmultiset = "struct %s<%s> " return false; \ \ for (size_t i = 0; i < steps; i++) \ - PFX##_iter_prev(iter); \ + CMC_(PFX, _iter_prev)(iter); \ \ return true; \ } \ \ /* Returns true only if the iterator was able to be positioned at the */ \ /* given index */ \ - bool PFX##_iter_go_to(struct SNAME##_iter *iter, size_t index) \ + bool CMC_(PFX, _iter_go_to)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t index) \ { \ if (index >= iter->target->count) \ return false; \ \ if (iter->index > index) \ - return PFX##_iter_rewind(iter, iter->index - index); \ + return CMC_(PFX, _iter_rewind)(iter, iter->index - index); \ else if (iter->index < index) \ - return PFX##_iter_advance(iter, index - iter->index); \ + return CMC_(PFX, _iter_advance)(iter, index - iter->index); \ \ return true; \ } \ \ - V PFX##_iter_value(struct SNAME##_iter *iter) \ + V CMC_(PFX, _iter_value)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ - if (PFX##_empty(iter->target)) \ + if (CMC_(PFX, _empty)(iter->target)) \ return (V){ 0 }; \ \ return iter->target->buffer[iter->cursor].value; \ } \ \ - size_t PFX##_iter_multiplicity(struct SNAME##_iter *iter) \ + size_t CMC_(PFX, _iter_multiplicity)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ - if (PFX##_empty(iter->target)) \ + if (CMC_(PFX, _empty)(iter->target)) \ return 0; \ \ return iter->target->buffer[iter->cursor].multiplicity; \ } \ \ - size_t PFX##_iter_index(struct SNAME##_iter *iter) \ + size_t CMC_(PFX, _iter_index)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ return iter->index; \ } \ \ - static size_t PFX##_impl_multiplicity_of(struct SNAME *_set_, V value) \ + static size_t CMC_(PFX, _impl_multiplicity_of)(struct SNAME * _set_, \ + V value) \ { \ - struct SNAME##_entry *entry = PFX##_impl_get_entry(_set_, value); \ + struct CMC_DEF_ENTRY(SNAME) *entry = \ + CMC_(PFX, _impl_get_entry)(_set_, value); \ \ if (!entry) \ return 0; \ @@ -1402,8 +1452,9 @@ static const char *cmc_string_fmt_hashmultiset = "struct %s<%s> " return entry->multiplicity; \ } \ \ - static struct SNAME##_entry *PFX##_impl_insert_and_return( \ - struct SNAME *_set_, V value, bool *new_node) \ + static struct CMC_DEF_ENTRY(SNAME) * \ + CMC_(PFX, _impl_insert_and_return)(struct SNAME * _set_, V value, \ + bool *new_node) \ { \ /* If the entry already exists simply return it as we might do */ \ /* something with it. This function only guarantees that there is */ \ @@ -1411,16 +1462,17 @@ static const char *cmc_string_fmt_hashmultiset = "struct %s<%s> " \ *new_node = false; \ \ - struct SNAME##_entry *entry = PFX##_impl_get_entry(_set_, value); \ + struct CMC_DEF_ENTRY(SNAME) *entry = \ + CMC_(PFX, _impl_get_entry)(_set_, value); \ \ if (entry != NULL) \ return entry; \ \ *new_node = true; \ \ - if (PFX##_full(_set_)) \ + if (CMC_(PFX, _full)(_set_)) \ { \ - if (!PFX##_resize(_set_, _set_->capacity + 1)) \ + if (!CMC_(PFX, _resize)(_set_, _set_->capacity + 1)) \ return NULL; \ } \ \ @@ -1430,8 +1482,8 @@ static const char *cmc_string_fmt_hashmultiset = "struct %s<%s> " /* Current multiplicity. Might change due to robin hood hashing */ \ size_t curr_mul = 1; \ \ - struct SNAME##_entry *target = &(_set_->buffer[pos]); \ - struct SNAME##_entry *to_return = NULL; \ + struct CMC_DEF_ENTRY(SNAME) *target = &(_set_->buffer[pos]); \ + struct CMC_DEF_ENTRY(SNAME) *to_return = NULL; \ \ if (target->state == CMC_ES_EMPTY || target->state == CMC_ES_DELETED) \ { \ @@ -1488,13 +1540,13 @@ static const char *cmc_string_fmt_hashmultiset = "struct %s<%s> " return to_return; \ } \ \ - static struct SNAME##_entry *PFX##_impl_get_entry(struct SNAME *_set_, \ - V value) \ + static struct CMC_DEF_ENTRY(SNAME) * \ + CMC_(PFX, _impl_get_entry)(struct SNAME * _set_, V value) \ { \ size_t hash = _set_->f_val->hash(value); \ size_t pos = hash % _set_->capacity; \ \ - struct SNAME##_entry *target = &(_set_->buffer[pos]); \ + struct CMC_DEF_ENTRY(SNAME) *target = &(_set_->buffer[pos]); \ \ while (target->state == CMC_ES_FILLED || \ target->state == CMC_ES_DELETED) \ @@ -1509,7 +1561,7 @@ static const char *cmc_string_fmt_hashmultiset = "struct %s<%s> " return NULL; \ } \ \ - static size_t PFX##_impl_calculate_size(size_t required) \ + static size_t CMC_(PFX, _impl_calculate_size)(size_t required) \ { \ const size_t count = \ sizeof(cmc_hashtable_primes) / sizeof(cmc_hashtable_primes[0]); \ @@ -1524,4 +1576,4 @@ static const char *cmc_string_fmt_hashmultiset = "struct %s<%s> " return cmc_hashtable_primes[i]; \ } -#endif /* CMC_HASHMULTISET_H */ +#endif /* CMC_CMC_HASHMULTISET_H */ diff --git a/src/cmc/hashset.h b/src/cmc/hashset.h index 086bc0e..1cbf3c0 100644 --- a/src/cmc/hashset.h +++ b/src/cmc/hashset.h @@ -16,8 +16,8 @@ * hood hashing. */ -#ifndef CMC_HASHSET_H -#define CMC_HASHSET_H +#ifndef CMC_CMC_HASHSET_H +#define CMC_CMC_HASHSET_H /* ------------------------------------------------------------------------- * Core functionalities of the C Macro Collections Library @@ -33,200 +33,216 @@ * HashSet specific * ------------------------------------------------------------------------- */ /* to_string format */ -static const char *cmc_string_fmt_hashset = "struct %s<%s> " - "at %p { " - "buffer:%p, " - "capacity:%" PRIuMAX ", " - "count:%" PRIuMAX ", " - "load:%lf, " - "flag:%d, " - "f_val:%p, " - "alloc:%p, " - "callbacks: %p }"; +static const char *cmc_cmc_string_fmt_hashset = "struct %s<%s> " + "at %p { " + "buffer:%p, " + "capacity:%" PRIuMAX ", " + "count:%" PRIuMAX ", " + "load:%lf, " + "flag:%d, " + "f_val:%p, " + "alloc:%p, " + "callbacks: %p }"; -#define CMC_GENERATE_HASHSET(PFX, SNAME, V) \ - CMC_GENERATE_HASHSET_HEADER(PFX, SNAME, V) \ - CMC_GENERATE_HASHSET_SOURCE(PFX, SNAME, V) +/** + * Core HashSet implementation + */ +#define CMC_CMC_HASHSET_CORE(BODY) \ + CMC_CMC_HASHSET_CORE_HEADER(BODY) \ + CMC_CMC_HASHSET_CORE_SOURCE(BODY) -#define CMC_WRAPGEN_HASHSET_HEADER(PFX, SNAME, K, V) \ - CMC_GENERATE_HASHSET_HEADER(PFX, SNAME, V) +#define CMC_CMC_HASHSET_CORE_HEADER(BODY) \ + CMC_CMC_HASHSET_CORE_HEADER_(CMC_PARAM_PFX(BODY), CMC_PARAM_SNAME(BODY), \ + CMC_PARAM_V(BODY)) -#define CMC_WRAPGEN_HASHSET_SOURCE(PFX, SNAME, K, V) \ - CMC_GENERATE_HASHSET_SOURCE(PFX, SNAME, V) +#define CMC_CMC_HASHSET_CORE_SOURCE(BODY) \ + CMC_CMC_HASHSET_CORE_SOURCE_(CMC_PARAM_PFX(BODY), CMC_PARAM_SNAME(BODY), \ + CMC_PARAM_V(BODY)) /* ------------------------------------------------------------------------- * Header * ------------------------------------------------------------------------- */ -#define CMC_GENERATE_HASHSET_HEADER(PFX, SNAME, V) \ - \ - /* Hashset Structure */ \ - struct SNAME \ - { \ - /* Array of Entries */ \ - struct SNAME##_entry *buffer; \ - \ - /* Current Array Capcity */ \ - size_t capacity; \ - \ - /* Current amount of elements */ \ - size_t count; \ - \ - /* Load factor in range (0.0, 1.0) */ \ - double load; \ - \ - /* Flags indicating errors or success */ \ - int flag; \ - \ - /* Value function table */ \ - struct SNAME##_fval *f_val; \ - \ - /* Custom allocation functions */ \ - struct cmc_alloc_node *alloc; \ - \ - /* Custom callback functions */ \ - struct cmc_callbacks *callbacks; \ - }; \ - \ - struct SNAME##_entry \ - { \ - /* Entry value */ \ - V value; \ - \ - /* The distance of this node to its original position, used by */ \ - /* robin-hood hashing */ \ - size_t dist; \ - \ - /* The sate of this node (DELETED, EMPTY, FILLED) */ \ - enum cmc_entry_state state; \ - }; \ - \ - /* Value struct function table */ \ - struct SNAME##_fval \ - { \ - /* Comparator function */ \ - int (*cmp)(V, V); \ - \ - /* Copy function */ \ - V (*cpy)(V); \ - \ - /* To string function */ \ - bool (*str)(FILE *, V); \ - \ - /* Free from memory function */ \ - void (*free)(V); \ - \ - /* Hash function */ \ - size_t (*hash)(V); \ - \ - /* Priority function */ \ - int (*pri)(V, V); \ - }; \ - \ - /* Hashset Iterator */ \ - struct SNAME##_iter \ - { \ - /* Target Hashset */ \ - struct SNAME *target; \ - \ - /* Cursor's position (index) */ \ - size_t cursor; \ - \ - /* Keeps track of relative index to the iteration of elements */ \ - size_t index; \ - \ - /* The index of the first element */ \ - size_t first; \ - \ - /* The index of the last element */ \ - size_t last; \ - \ - /* If the iterator has reached the start of the iteration */ \ - bool start; \ - \ - /* If the iterator has reached the end of the iteration */ \ - bool end; \ - }; \ - \ - /* Collection Functions */ \ - /* Collection Allocation and Deallocation */ \ - struct SNAME *PFX##_new(size_t capacity, double load, \ - struct SNAME##_fval *f_val); \ - struct SNAME *PFX##_new_custom( \ - size_t capacity, double load, struct SNAME##_fval *f_val, \ - struct cmc_alloc_node *alloc, struct cmc_callbacks *callbacks); \ - void PFX##_clear(struct SNAME *_set_); \ - void PFX##_free(struct SNAME *_set_); \ - /* Customization of Allocation and Callbacks */ \ - void PFX##_customize(struct SNAME *_set_, struct cmc_alloc_node *alloc, \ - struct cmc_callbacks *callbacks); \ - /* Collection Input and Output */ \ - bool PFX##_insert(struct SNAME *_set_, V value); \ - bool PFX##_remove(struct SNAME *_set_, V value); \ - /* Element Access */ \ - bool PFX##_max(struct SNAME *_set_, V *value); \ - bool PFX##_min(struct SNAME *_set_, V *value); \ - /* Collection State */ \ - bool PFX##_contains(struct SNAME *_set_, V value); \ - bool PFX##_empty(struct SNAME *_set_); \ - bool PFX##_full(struct SNAME *_set_); \ - size_t PFX##_count(struct SNAME *_set_); \ - size_t PFX##_capacity(struct SNAME *_set_); \ - double PFX##_load(struct SNAME *_set_); \ - int PFX##_flag(struct SNAME *_set_); \ - /* Collection Utility */ \ - bool PFX##_resize(struct SNAME *_set_, size_t capacity); \ - struct SNAME *PFX##_copy_of(struct SNAME *_set_); \ - bool PFX##_equals(struct SNAME *_set1_, struct SNAME *_set2_); \ - struct cmc_string PFX##_to_string(struct SNAME *_set_); \ - bool PFX##_print(struct SNAME *_set_, FILE *fptr); \ - \ - /* Set Operations */ \ - struct SNAME *PFX##_union(struct SNAME *_set1_, struct SNAME *_set2_); \ - struct SNAME *PFX##_intersection(struct SNAME *_set1_, \ - struct SNAME *_set2_); \ - struct SNAME *PFX##_difference(struct SNAME *_set1_, \ - struct SNAME *_set2_); \ - struct SNAME *PFX##_symmetric_difference(struct SNAME *_set1_, \ - struct SNAME *_set2_); \ - bool PFX##_is_subset(struct SNAME *_set1_, struct SNAME *_set2_); \ - bool PFX##_is_superset(struct SNAME *_set1_, struct SNAME *_set2_); \ - bool PFX##_is_proper_subset(struct SNAME *_set1_, struct SNAME *_set2_); \ - bool PFX##_is_proper_superset(struct SNAME *_set1_, struct SNAME *_set2_); \ - bool PFX##_is_disjointset(struct SNAME *_set1_, struct SNAME *_set2_); \ - \ - /* Iterator Functions */ \ - /* Iterator Initialization */ \ - struct SNAME##_iter PFX##_iter_start(struct SNAME *target); \ - struct SNAME##_iter PFX##_iter_end(struct SNAME *target); \ - /* Iterator State */ \ - bool PFX##_iter_at_start(struct SNAME##_iter *iter); \ - bool PFX##_iter_at_end(struct SNAME##_iter *iter); \ - /* Iterator Movement */ \ - bool PFX##_iter_to_start(struct SNAME##_iter *iter); \ - bool PFX##_iter_to_end(struct SNAME##_iter *iter); \ - bool PFX##_iter_next(struct SNAME##_iter *iter); \ - bool PFX##_iter_prev(struct SNAME##_iter *iter); \ - bool PFX##_iter_advance(struct SNAME##_iter *iter, size_t steps); \ - bool PFX##_iter_rewind(struct SNAME##_iter *iter, size_t steps); \ - bool PFX##_iter_go_to(struct SNAME##_iter *iter, size_t index); \ - /* Iterator Access */ \ - V PFX##_iter_value(struct SNAME##_iter *iter); \ - size_t PFX##_iter_index(struct SNAME##_iter *iter); +#define CMC_CMC_HASHSET_CORE_HEADER_(PFX, SNAME, V) \ + \ + /* Hashset Structure */ \ + struct SNAME \ + { \ + /* Array of Entries */ \ + struct CMC_DEF_ENTRY(SNAME) * buffer; \ + \ + /* Current Array Capcity */ \ + size_t capacity; \ + \ + /* Current amount of elements */ \ + size_t count; \ + \ + /* Load factor in range (0.0, 1.0) */ \ + double load; \ + \ + /* Flags indicating errors or success */ \ + int flag; \ + \ + /* Value function table */ \ + struct CMC_DEF_FVAL(SNAME) * f_val; \ + \ + /* Custom allocation functions */ \ + struct cmc_alloc_node *alloc; \ + \ + /* Custom callback functions */ \ + struct cmc_callbacks *callbacks; \ + }; \ + \ + struct CMC_DEF_ENTRY(SNAME) \ + { \ + /* Entry value */ \ + V value; \ + \ + /* The distance of this node to its original position, used by */ \ + /* robin-hood hashing */ \ + size_t dist; \ + \ + /* The sate of this node (DELETED, EMPTY, FILLED) */ \ + enum cmc_entry_state state; \ + }; \ + \ + /* Value struct function table */ \ + struct CMC_DEF_FVAL(SNAME) \ + { \ + /* Comparator function */ \ + int (*cmp)(V, V); \ + \ + /* Copy function */ \ + V (*cpy)(V); \ + \ + /* To string function */ \ + bool (*str)(FILE *, V); \ + \ + /* Free from memory function */ \ + void (*free)(V); \ + \ + /* Hash function */ \ + size_t (*hash)(V); \ + \ + /* Priority function */ \ + int (*pri)(V, V); \ + }; \ + \ + /* Hashset Iterator */ \ + struct CMC_DEF_ITER(SNAME) \ + { \ + /* Target Hashset */ \ + struct SNAME *target; \ + \ + /* Cursor's position (index) */ \ + size_t cursor; \ + \ + /* Keeps track of relative index to the iteration of elements */ \ + size_t index; \ + \ + /* The index of the first element */ \ + size_t first; \ + \ + /* The index of the last element */ \ + size_t last; \ + \ + /* If the iterator has reached the start of the iteration */ \ + bool start; \ + \ + /* If the iterator has reached the end of the iteration */ \ + bool end; \ + }; \ + \ + /* Collection Functions */ \ + /* Collection Allocation and Deallocation */ \ + struct SNAME *CMC_(PFX, _new)(size_t capacity, double load, \ + struct CMC_DEF_FVAL(SNAME) * f_val); \ + struct SNAME *CMC_(PFX, _new_custom)( \ + size_t capacity, double load, struct CMC_DEF_FVAL(SNAME) * f_val, \ + struct cmc_alloc_node * alloc, struct cmc_callbacks * callbacks); \ + void CMC_(PFX, _clear)(struct SNAME * _set_); \ + void CMC_(PFX, _free)(struct SNAME * _set_); \ + /* Customization of Allocation and Callbacks */ \ + void CMC_(PFX, _customize)(struct SNAME * _set_, \ + struct cmc_alloc_node * alloc, \ + struct cmc_callbacks * callbacks); \ + /* Collection Input and Output */ \ + bool CMC_(PFX, _insert)(struct SNAME * _set_, V value); \ + bool CMC_(PFX, _remove)(struct SNAME * _set_, V value); \ + /* Element Access */ \ + bool CMC_(PFX, _max)(struct SNAME * _set_, V * value); \ + bool CMC_(PFX, _min)(struct SNAME * _set_, V * value); \ + /* Collection State */ \ + bool CMC_(PFX, _contains)(struct SNAME * _set_, V value); \ + bool CMC_(PFX, _empty)(struct SNAME * _set_); \ + bool CMC_(PFX, _full)(struct SNAME * _set_); \ + size_t CMC_(PFX, _count)(struct SNAME * _set_); \ + size_t CMC_(PFX, _capacity)(struct SNAME * _set_); \ + double CMC_(PFX, _load)(struct SNAME * _set_); \ + int CMC_(PFX, _flag)(struct SNAME * _set_); \ + /* Collection Utility */ \ + bool CMC_(PFX, _resize)(struct SNAME * _set_, size_t capacity); \ + struct SNAME *CMC_(PFX, _copy_of)(struct SNAME * _set_); \ + bool CMC_(PFX, _equals)(struct SNAME * _set1_, struct SNAME * _set2_); \ + struct cmc_string CMC_(PFX, _to_string)(struct SNAME * _set_); \ + bool CMC_(PFX, _print)(struct SNAME * _set_, FILE * fptr); \ + \ + /* Set Operations */ \ + struct SNAME *CMC_(PFX, _union)(struct SNAME * _set1_, \ + struct SNAME * _set2_); \ + struct SNAME *CMC_(PFX, _intersection)(struct SNAME * _set1_, \ + struct SNAME * _set2_); \ + struct SNAME *CMC_(PFX, _difference)(struct SNAME * _set1_, \ + struct SNAME * _set2_); \ + struct SNAME *CMC_(PFX, _symmetric_difference)(struct SNAME * _set1_, \ + struct SNAME * _set2_); \ + bool CMC_(PFX, _is_subset)(struct SNAME * _set1_, struct SNAME * _set2_); \ + bool CMC_(PFX, _is_superset)(struct SNAME * _set1_, \ + struct SNAME * _set2_); \ + bool CMC_(PFX, _is_proper_subset)(struct SNAME * _set1_, \ + struct SNAME * _set2_); \ + bool CMC_(PFX, _is_proper_superset)(struct SNAME * _set1_, \ + struct SNAME * _set2_); \ + bool CMC_(PFX, _is_disjointset)(struct SNAME * _set1_, \ + struct SNAME * _set2_); \ + \ + /* Iterator Functions */ \ + /* Iterator Initialization */ \ + struct CMC_DEF_ITER(SNAME) CMC_(PFX, _iter_start)(struct SNAME * target); \ + struct CMC_DEF_ITER(SNAME) CMC_(PFX, _iter_end)(struct SNAME * target); \ + /* Iterator State */ \ + bool CMC_(PFX, _iter_at_start)(struct CMC_DEF_ITER(SNAME) * iter); \ + bool CMC_(PFX, _iter_at_end)(struct CMC_DEF_ITER(SNAME) * iter); \ + /* Iterator Movement */ \ + bool CMC_(PFX, _iter_to_start)(struct CMC_DEF_ITER(SNAME) * iter); \ + bool CMC_(PFX, _iter_to_end)(struct CMC_DEF_ITER(SNAME) * iter); \ + bool CMC_(PFX, _iter_next)(struct CMC_DEF_ITER(SNAME) * iter); \ + bool CMC_(PFX, _iter_prev)(struct CMC_DEF_ITER(SNAME) * iter); \ + bool CMC_(PFX, _iter_advance)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t steps); \ + bool CMC_(PFX, _iter_rewind)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t steps); \ + bool CMC_(PFX, _iter_go_to)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t index); \ + /* Iterator Access */ \ + V CMC_(PFX, _iter_value)(struct CMC_DEF_ITER(SNAME) * iter); \ + size_t CMC_(PFX, _iter_index)(struct CMC_DEF_ITER(SNAME) * iter); /* ------------------------------------------------------------------------- * Source * ------------------------------------------------------------------------- */ -#define CMC_GENERATE_HASHSET_SOURCE(PFX, SNAME, V) \ +#define CMC_CMC_HASHSET_CORE_SOURCE_(PFX, SNAME, V) \ \ /* Implementation Detail Functions */ \ - static struct SNAME##_entry *PFX##_impl_get_entry(struct SNAME *_set_, \ - V value); \ - static size_t PFX##_impl_calculate_size(size_t required); \ - static struct SNAME##_iter PFX##_impl_it_start(struct SNAME *_set_); \ - static struct SNAME##_iter PFX##_impl_it_end(struct SNAME *_set_); \ + static struct CMC_DEF_ENTRY(SNAME) * \ + CMC_(PFX, _impl_get_entry)(struct SNAME * _set_, V value); \ + static size_t CMC_(PFX, _impl_calculate_size)(size_t required); \ + static struct CMC_DEF_ITER(SNAME) \ + CMC_(PFX, _impl_it_start)(struct SNAME * _set_); \ + static struct CMC_DEF_ITER(SNAME) \ + CMC_(PFX, _impl_it_end)(struct SNAME * _set_); \ \ - struct SNAME *PFX##_new(size_t capacity, double load, \ - struct SNAME##_fval *f_val) \ + struct SNAME *CMC_(PFX, _new)(size_t capacity, double load, \ + struct CMC_DEF_FVAL(SNAME) * f_val) \ { \ struct cmc_alloc_node *alloc = &cmc_alloc_node_default; \ \ @@ -240,7 +256,8 @@ static const char *cmc_string_fmt_hashset = "struct %s<%s> " if (!f_val) \ return NULL; \ \ - size_t real_capacity = PFX##_impl_calculate_size(capacity / load); \ + size_t real_capacity = \ + CMC_(PFX, _impl_calculate_size)(capacity / load); \ \ struct SNAME *_set_ = alloc->malloc(sizeof(struct SNAME)); \ \ @@ -248,7 +265,7 @@ static const char *cmc_string_fmt_hashset = "struct %s<%s> " return NULL; \ \ _set_->buffer = \ - alloc->calloc(real_capacity, sizeof(struct SNAME##_entry)); \ + alloc->calloc(real_capacity, sizeof(struct CMC_DEF_ENTRY(SNAME))); \ \ if (!_set_->buffer) \ { \ @@ -259,7 +276,7 @@ static const char *cmc_string_fmt_hashset = "struct %s<%s> " _set_->count = 0; \ _set_->capacity = real_capacity; \ _set_->load = load; \ - _set_->flag = cmc_flags.OK; \ + _set_->flag = CMC_FLAG_OK; \ _set_->f_val = f_val; \ _set_->alloc = alloc; \ _set_->callbacks = NULL; \ @@ -267,9 +284,9 @@ static const char *cmc_string_fmt_hashset = "struct %s<%s> " return _set_; \ } \ \ - struct SNAME *PFX##_new_custom( \ - size_t capacity, double load, struct SNAME##_fval *f_val, \ - struct cmc_alloc_node *alloc, struct cmc_callbacks *callbacks) \ + struct SNAME *CMC_(PFX, _new_custom)( \ + size_t capacity, double load, struct CMC_DEF_FVAL(SNAME) * f_val, \ + struct cmc_alloc_node * alloc, struct cmc_callbacks * callbacks) \ { \ if (capacity == 0 || load <= 0 || load >= 1) \ return NULL; \ @@ -281,7 +298,8 @@ static const char *cmc_string_fmt_hashset = "struct %s<%s> " if (!f_val) \ return NULL; \ \ - size_t real_capacity = PFX##_impl_calculate_size(capacity / load); \ + size_t real_capacity = \ + CMC_(PFX, _impl_calculate_size)(capacity / load); \ \ if (!alloc) \ alloc = &cmc_alloc_node_default; \ @@ -292,7 +310,7 @@ static const char *cmc_string_fmt_hashset = "struct %s<%s> " return NULL; \ \ _set_->buffer = \ - alloc->calloc(real_capacity, sizeof(struct SNAME##_entry)); \ + alloc->calloc(real_capacity, sizeof(struct CMC_DEF_ENTRY(SNAME))); \ \ if (!_set_->buffer) \ { \ @@ -303,7 +321,7 @@ static const char *cmc_string_fmt_hashset = "struct %s<%s> " _set_->count = 0; \ _set_->capacity = real_capacity; \ _set_->load = load; \ - _set_->flag = cmc_flags.OK; \ + _set_->flag = CMC_FLAG_OK; \ _set_->f_val = f_val; \ _set_->alloc = alloc; \ _set_->callbacks = callbacks; \ @@ -311,13 +329,13 @@ static const char *cmc_string_fmt_hashset = "struct %s<%s> " return _set_; \ } \ \ - void PFX##_clear(struct SNAME *_set_) \ + void CMC_(PFX, _clear)(struct SNAME * _set_) \ { \ if (_set_->f_val->free) \ { \ for (size_t i = 0; i < _set_->capacity; i++) \ { \ - struct SNAME##_entry *entry = &(_set_->buffer[i]); \ + struct CMC_DEF_ENTRY(SNAME) *entry = &(_set_->buffer[i]); \ \ if (entry->state == CMC_ES_FILLED) \ { \ @@ -327,19 +345,19 @@ static const char *cmc_string_fmt_hashset = "struct %s<%s> " } \ \ memset(_set_->buffer, 0, \ - sizeof(struct SNAME##_entry) * _set_->capacity); \ + sizeof(struct CMC_DEF_ENTRY(SNAME)) * _set_->capacity); \ \ _set_->count = 0; \ - _set_->flag = cmc_flags.OK; \ + _set_->flag = CMC_FLAG_OK; \ } \ \ - void PFX##_free(struct SNAME *_set_) \ + void CMC_(PFX, _free)(struct SNAME * _set_) \ { \ if (_set_->f_val->free) \ { \ for (size_t i = 0; i < _set_->capacity; i++) \ { \ - struct SNAME##_entry *entry = &(_set_->buffer[i]); \ + struct CMC_DEF_ENTRY(SNAME) *entry = &(_set_->buffer[i]); \ \ if (entry->state == CMC_ES_FILLED) \ { \ @@ -352,8 +370,9 @@ static const char *cmc_string_fmt_hashset = "struct %s<%s> " _set_->alloc->free(_set_); \ } \ \ - void PFX##_customize(struct SNAME *_set_, struct cmc_alloc_node *alloc, \ - struct cmc_callbacks *callbacks) \ + void CMC_(PFX, _customize)(struct SNAME * _set_, \ + struct cmc_alloc_node * alloc, \ + struct cmc_callbacks * callbacks) \ { \ if (!alloc) \ _set_->alloc = &cmc_alloc_node_default; \ @@ -362,20 +381,20 @@ static const char *cmc_string_fmt_hashset = "struct %s<%s> " \ _set_->callbacks = callbacks; \ \ - _set_->flag = cmc_flags.OK; \ + _set_->flag = CMC_FLAG_OK; \ } \ \ - bool PFX##_insert(struct SNAME *_set_, V value) \ + bool CMC_(PFX, _insert)(struct SNAME * _set_, V value) \ { \ - if (PFX##_full(_set_)) \ + if (CMC_(PFX, _full)(_set_)) \ { \ - if (!PFX##_resize(_set_, _set_->capacity + 1)) \ + if (!CMC_(PFX, _resize)(_set_, _set_->capacity + 1)) \ return false; \ } \ \ - if (PFX##_impl_get_entry(_set_, value) != NULL) \ + if (CMC_(PFX, _impl_get_entry)(_set_, value) != NULL) \ { \ - _set_->flag = cmc_flags.DUPLICATE; \ + _set_->flag = CMC_FLAG_DUPLICATE; \ return false; \ } \ \ @@ -383,7 +402,7 @@ static const char *cmc_string_fmt_hashset = "struct %s<%s> " size_t original_pos = hash % _set_->capacity; \ size_t pos = original_pos; \ \ - struct SNAME##_entry *target = &(_set_->buffer[pos]); \ + struct CMC_DEF_ENTRY(SNAME) *target = &(_set_->buffer[pos]); \ \ if (target->state == CMC_ES_EMPTY || target->state == CMC_ES_DELETED) \ { \ @@ -422,7 +441,7 @@ static const char *cmc_string_fmt_hashset = "struct %s<%s> " } \ \ _set_->count++; \ - _set_->flag = cmc_flags.OK; \ + _set_->flag = CMC_FLAG_OK; \ \ if (_set_->callbacks && _set_->callbacks->create) \ _set_->callbacks->create(); \ @@ -430,19 +449,20 @@ static const char *cmc_string_fmt_hashset = "struct %s<%s> " return true; \ } \ \ - bool PFX##_remove(struct SNAME *_set_, V value) \ + bool CMC_(PFX, _remove)(struct SNAME * _set_, V value) \ { \ - if (PFX##_empty(_set_)) \ + if (CMC_(PFX, _empty)(_set_)) \ { \ - _set_->flag = cmc_flags.EMPTY; \ + _set_->flag = CMC_FLAG_EMPTY; \ return false; \ } \ \ - struct SNAME##_entry *result = PFX##_impl_get_entry(_set_, value); \ + struct CMC_DEF_ENTRY(SNAME) *result = \ + CMC_(PFX, _impl_get_entry)(_set_, value); \ \ if (result == NULL) \ { \ - _set_->flag = cmc_flags.NOT_FOUND; \ + _set_->flag = CMC_FLAG_NOT_FOUND; \ return false; \ } \ \ @@ -451,7 +471,7 @@ static const char *cmc_string_fmt_hashset = "struct %s<%s> " result->state = CMC_ES_DELETED; \ \ _set_->count--; \ - _set_->flag = cmc_flags.OK; \ + _set_->flag = CMC_FLAG_OK; \ \ if (_set_->callbacks && _set_->callbacks->delete) \ _set_->callbacks->delete (); \ @@ -459,22 +479,22 @@ static const char *cmc_string_fmt_hashset = "struct %s<%s> " return true; \ } \ \ - bool PFX##_max(struct SNAME *_set_, V *value) \ + bool CMC_(PFX, _max)(struct SNAME * _set_, V * value) \ { \ - if (PFX##_empty(_set_)) \ + if (CMC_(PFX, _empty)(_set_)) \ { \ - _set_->flag = cmc_flags.EMPTY; \ + _set_->flag = CMC_FLAG_EMPTY; \ return false; \ } \ \ V max_value; \ - struct SNAME##_iter iter = PFX##_iter_start(_set_); \ + struct CMC_DEF_ITER(SNAME) iter = CMC_(PFX, _iter_start)(_set_); \ \ /* TODO turn this into a normal loop */ \ - for (; !PFX##_iter_at_end(&iter); PFX##_iter_next(&iter)) \ + for (; !CMC_(PFX, _iter_at_end)(&iter); CMC_(PFX, _iter_next)(&iter)) \ { \ - V result = PFX##_iter_value(&iter); \ - size_t index = PFX##_iter_index(&iter); \ + V result = CMC_(PFX, _iter_value)(&iter); \ + size_t index = CMC_(PFX, _iter_index)(&iter); \ \ if (index == 0) \ max_value = result; \ @@ -485,7 +505,7 @@ static const char *cmc_string_fmt_hashset = "struct %s<%s> " if (value) \ *value = max_value; \ \ - _set_->flag = cmc_flags.OK; \ + _set_->flag = CMC_FLAG_OK; \ \ if (_set_->callbacks && _set_->callbacks->read) \ _set_->callbacks->read(); \ @@ -493,22 +513,22 @@ static const char *cmc_string_fmt_hashset = "struct %s<%s> " return true; \ } \ \ - bool PFX##_min(struct SNAME *_set_, V *value) \ + bool CMC_(PFX, _min)(struct SNAME * _set_, V * value) \ { \ - if (PFX##_empty(_set_)) \ + if (CMC_(PFX, _empty)(_set_)) \ { \ - _set_->flag = cmc_flags.EMPTY; \ + _set_->flag = CMC_FLAG_EMPTY; \ return false; \ } \ \ V min_value; \ - struct SNAME##_iter iter = PFX##_iter_start(_set_); \ + struct CMC_DEF_ITER(SNAME) iter = CMC_(PFX, _iter_start)(_set_); \ \ /* TODO turn this into a normal loop */ \ - for (; !PFX##_iter_at_end(&iter); PFX##_iter_next(&iter)) \ + for (; !CMC_(PFX, _iter_at_end)(&iter); CMC_(PFX, _iter_next)(&iter)) \ { \ - V result = PFX##_iter_value(&iter); \ - size_t index = PFX##_iter_index(&iter); \ + V result = CMC_(PFX, _iter_value)(&iter); \ + size_t index = CMC_(PFX, _iter_index)(&iter); \ \ if (index == 0) \ min_value = result; \ @@ -519,7 +539,7 @@ static const char *cmc_string_fmt_hashset = "struct %s<%s> " if (value) \ *value = min_value; \ \ - _set_->flag = cmc_flags.OK; \ + _set_->flag = CMC_FLAG_OK; \ \ if (_set_->callbacks && _set_->callbacks->read) \ _set_->callbacks->read(); \ @@ -527,11 +547,11 @@ static const char *cmc_string_fmt_hashset = "struct %s<%s> " return true; \ } \ \ - bool PFX##_contains(struct SNAME *_set_, V value) \ + bool CMC_(PFX, _contains)(struct SNAME * _set_, V value) \ { \ - _set_->flag = cmc_flags.OK; \ + _set_->flag = CMC_FLAG_OK; \ \ - bool result = PFX##_impl_get_entry(_set_, value) != NULL; \ + bool result = CMC_(PFX, _impl_get_entry)(_set_, value) != NULL; \ \ if (_set_->callbacks && _set_->callbacks->read) \ _set_->callbacks->read(); \ @@ -539,39 +559,39 @@ static const char *cmc_string_fmt_hashset = "struct %s<%s> " return result; \ } \ \ - bool PFX##_empty(struct SNAME *_set_) \ + bool CMC_(PFX, _empty)(struct SNAME * _set_) \ { \ return _set_->count == 0; \ } \ \ - bool PFX##_full(struct SNAME *_set_) \ + bool CMC_(PFX, _full)(struct SNAME * _set_) \ { \ return (double)_set_->capacity * _set_->load <= (double)_set_->count; \ } \ \ - size_t PFX##_count(struct SNAME *_set_) \ + size_t CMC_(PFX, _count)(struct SNAME * _set_) \ { \ return _set_->count; \ } \ \ - size_t PFX##_capacity(struct SNAME *_set_) \ + size_t CMC_(PFX, _capacity)(struct SNAME * _set_) \ { \ return _set_->capacity; \ } \ \ - double PFX##_load(struct SNAME *_set_) \ + double CMC_(PFX, _load)(struct SNAME * _set_) \ { \ return _set_->load; \ } \ \ - int PFX##_flag(struct SNAME *_set_) \ + int CMC_(PFX, _flag)(struct SNAME * _set_) \ { \ return _set_->flag; \ } \ \ - bool PFX##_resize(struct SNAME *_set_, size_t capacity) \ + bool CMC_(PFX, _resize)(struct SNAME * _set_, size_t capacity) \ { \ - _set_->flag = cmc_flags.OK; \ + _set_->flag = CMC_FLAG_OK; \ \ if (_set_->capacity == capacity) \ goto success; \ @@ -582,51 +602,51 @@ static const char *cmc_string_fmt_hashset = "struct %s<%s> " /* Prevent integer overflow */ \ if (capacity >= UINTMAX_MAX * _set_->load) \ { \ - _set_->flag = cmc_flags.ERROR; \ + _set_->flag = CMC_FLAG_ERROR; \ return false; \ } \ \ /* Calculate required capacity based on the prime numbers */ \ - size_t theoretical_size = PFX##_impl_calculate_size(capacity); \ + size_t theoretical_size = CMC_(PFX, _impl_calculate_size)(capacity); \ \ /* Not possible to shrink with current available prime numbers */ \ if (theoretical_size < _set_->count / _set_->load) \ { \ - _set_->flag = cmc_flags.INVALID; \ + _set_->flag = CMC_FLAG_INVALID; \ return false; \ } \ \ /* No callbacks since _new_set_ is just a temporary hashtable */ \ - struct SNAME *_new_set_ = PFX##_new_custom( \ + struct SNAME *_new_set_ = CMC_(PFX, _new_custom)( \ capacity, _set_->load, _set_->f_val, _set_->alloc, NULL); \ \ if (!_new_set_) \ { \ - _set_->flag = cmc_flags.ALLOC; \ + _set_->flag = CMC_FLAG_ALLOC; \ return false; \ } \ \ - struct SNAME##_iter iter = PFX##_iter_start(_set_); \ + struct CMC_DEF_ITER(SNAME) iter = CMC_(PFX, _iter_start)(_set_); \ \ /* TODO turn this into a normal loop */ \ - for (; !PFX##_iter_at_end(&iter); PFX##_iter_next(&iter)) \ + for (; !CMC_(PFX, _iter_at_end)(&iter); CMC_(PFX, _iter_next)(&iter)) \ { \ - V value = PFX##_iter_value(&iter); \ + V value = CMC_(PFX, _iter_value)(&iter); \ \ /* TODO check for error */ \ - PFX##_insert(_new_set_, value); \ + CMC_(PFX, _insert)(_new_set_, value); \ } \ \ /* Unlikely */ \ if (_set_->count != _new_set_->count) \ { \ - PFX##_free(_new_set_); \ + CMC_(PFX, _free)(_new_set_); \ \ - _set_->flag = cmc_flags.ERROR; \ + _set_->flag = CMC_FLAG_ERROR; \ return false; \ } \ \ - struct SNAME##_entry *tmp_b = _set_->buffer; \ + struct CMC_DEF_ENTRY(SNAME) *tmp_b = _set_->buffer; \ _set_->buffer = _new_set_->buffer; \ _new_set_->buffer = tmp_b; \ \ @@ -635,9 +655,9 @@ static const char *cmc_string_fmt_hashset = "struct %s<%s> " _new_set_->capacity = tmp_c; \ \ /* Prevent the set from freeing the data */ \ - _new_set_->f_val = &(struct SNAME##_fval){ NULL }; \ + _new_set_->f_val = &(struct CMC_DEF_FVAL(SNAME)){ NULL }; \ \ - PFX##_free(_new_set_); \ + CMC_(PFX, _free)(_new_set_); \ \ success: \ \ @@ -647,15 +667,15 @@ static const char *cmc_string_fmt_hashset = "struct %s<%s> " return true; \ } \ \ - struct SNAME *PFX##_copy_of(struct SNAME *_set_) \ + struct SNAME *CMC_(PFX, _copy_of)(struct SNAME * _set_) \ { \ - struct SNAME *result = \ - PFX##_new_custom(_set_->capacity * _set_->load, _set_->load, \ - _set_->f_val, _set_->alloc, _set_->callbacks); \ + struct SNAME *result = CMC_(PFX, _new_custom)( \ + _set_->capacity * _set_->load, _set_->load, _set_->f_val, \ + _set_->alloc, _set_->callbacks); \ \ if (!result) \ { \ - _set_->flag = cmc_flags.ERROR; \ + _set_->flag = CMC_FLAG_ERROR; \ return NULL; \ } \ \ @@ -663,11 +683,12 @@ static const char *cmc_string_fmt_hashset = "struct %s<%s> " { \ for (size_t i = 0; i < _set_->capacity; i++) \ { \ - struct SNAME##_entry *scan = &(_set_->buffer[i]); \ + struct CMC_DEF_ENTRY(SNAME) *scan = &(_set_->buffer[i]); \ \ if (scan->state != CMC_ES_EMPTY) \ { \ - struct SNAME##_entry *target = &(result->buffer[i]); \ + struct CMC_DEF_ENTRY(SNAME) *target = \ + &(result->buffer[i]); \ \ if (scan->state == CMC_ES_DELETED) \ target->state = CMC_ES_DELETED; \ @@ -683,19 +704,19 @@ static const char *cmc_string_fmt_hashset = "struct %s<%s> " } \ else \ memcpy(result->buffer, _set_->buffer, \ - sizeof(struct SNAME##_entry) * _set_->capacity); \ + sizeof(struct CMC_DEF_ENTRY(SNAME)) * _set_->capacity); \ \ result->count = _set_->count; \ \ - _set_->flag = cmc_flags.OK; \ + _set_->flag = CMC_FLAG_OK; \ \ return result; \ } \ \ - bool PFX##_equals(struct SNAME *_set1_, struct SNAME *_set2_) \ + bool CMC_(PFX, _equals)(struct SNAME * _set1_, struct SNAME * _set2_) \ { \ - _set1_->flag = cmc_flags.OK; \ - _set2_->flag = cmc_flags.OK; \ + _set1_->flag = CMC_FLAG_OK; \ + _set2_->flag = CMC_FLAG_OK; \ \ if (_set1_->count != _set2_->count) \ return false; \ @@ -703,36 +724,37 @@ static const char *cmc_string_fmt_hashset = "struct %s<%s> " if (_set1_->count == 0) \ return true; \ \ - struct SNAME##_iter iter = PFX##_iter_start(_set1_); \ + struct CMC_DEF_ITER(SNAME) iter = CMC_(PFX, _iter_start)(_set1_); \ \ /* TODO optimize this loop */ \ - for (; !PFX##_iter_at_end(&iter); PFX##_iter_next(&iter)) \ + for (; !CMC_(PFX, _iter_at_end)(&iter); CMC_(PFX, _iter_next)(&iter)) \ { \ - if (PFX##_impl_get_entry(_set2_, PFX##_iter_value(&iter)) == NULL) \ + if (CMC_(PFX, _impl_get_entry)( \ + _set2_, CMC_(PFX, _iter_value)(&iter)) == NULL) \ return false; \ } \ \ return true; \ } \ \ - struct cmc_string PFX##_to_string(struct SNAME *_set_) \ + struct cmc_string CMC_(PFX, _to_string)(struct SNAME * _set_) \ { \ struct cmc_string str; \ struct SNAME *s_ = _set_; \ \ int n = \ - snprintf(str.s, cmc_string_len, cmc_string_fmt_hashset, #SNAME, \ - #V, s_, s_->buffer, s_->capacity, s_->count, s_->load, \ - s_->flag, s_->f_val, s_->alloc, s_->callbacks); \ + snprintf(str.s, cmc_string_len, cmc_cmc_string_fmt_hashset, \ + #SNAME, #V, s_, s_->buffer, s_->capacity, s_->count, \ + s_->load, s_->flag, s_->f_val, s_->alloc, s_->callbacks); \ \ return n >= 0 ? str : (struct cmc_string){ 0 }; \ } \ \ - bool PFX##_print(struct SNAME *_set_, FILE *fptr) \ + bool CMC_(PFX, _print)(struct SNAME * _set_, FILE * fptr) \ { \ for (size_t i = 0; i < _set_->capacity; i++) \ { \ - struct SNAME##_entry *entry = &(_set_->buffer[i]); \ + struct CMC_DEF_ENTRY(SNAME) *entry = &(_set_->buffer[i]); \ \ if (entry->state == CMC_ES_FILLED) \ { \ @@ -744,32 +766,35 @@ static const char *cmc_string_fmt_hashset = "struct %s<%s> " return true; \ } \ \ - struct SNAME *PFX##_union(struct SNAME *_set1_, struct SNAME *_set2_) \ + struct SNAME *CMC_(PFX, _union)(struct SNAME * _set1_, \ + struct SNAME * _set2_) \ { \ /* Callbacks are added later */ \ struct SNAME *_set_r_ = \ - PFX##_new_custom(_set1_->capacity, _set1_->load, _set1_->f_val, \ - _set1_->alloc, NULL); \ + CMC_(PFX, _new_custom)(_set1_->capacity, _set1_->load, \ + _set1_->f_val, _set1_->alloc, NULL); \ \ if (!_set_r_) \ { \ - _set1_->flag = cmc_flags.ALLOC; \ - _set2_->flag = cmc_flags.ALLOC; \ + _set1_->flag = CMC_FLAG_ALLOC; \ + _set2_->flag = CMC_FLAG_ALLOC; \ return NULL; \ } \ \ - struct SNAME##_iter iter1 = PFX##_iter_start(_set1_); \ - struct SNAME##_iter iter2 = PFX##_iter_start(_set2_); \ + struct CMC_DEF_ITER(SNAME) iter1 = CMC_(PFX, _iter_start)(_set1_); \ + struct CMC_DEF_ITER(SNAME) iter2 = CMC_(PFX, _iter_start)(_set2_); \ \ /* TODO turn this into a normal loop and check for errors */ \ - for (; !PFX##_iter_at_end(&iter1); PFX##_iter_next(&iter1)) \ + for (; !CMC_(PFX, _iter_at_end)(&iter1); \ + CMC_(PFX, _iter_next)(&iter1)) \ { \ - PFX##_insert(_set_r_, PFX##_iter_value(&iter1)); \ + CMC_(PFX, _insert)(_set_r_, CMC_(PFX, _iter_value)(&iter1)); \ } \ \ - for (; !PFX##_iter_at_end(&iter2); PFX##_iter_next(&iter2)) \ + for (; !CMC_(PFX, _iter_at_end)(&iter2); \ + CMC_(PFX, _iter_next)(&iter2)) \ { \ - PFX##_insert(_set_r_, PFX##_iter_value(&iter2)); \ + CMC_(PFX, _insert)(_set_r_, CMC_(PFX, _iter_value)(&iter2)); \ } \ \ _set_r_->callbacks = _set1_->callbacks; \ @@ -777,18 +802,18 @@ static const char *cmc_string_fmt_hashset = "struct %s<%s> " return _set_r_; \ } \ \ - struct SNAME *PFX##_intersection(struct SNAME *_set1_, \ - struct SNAME *_set2_) \ + struct SNAME *CMC_(PFX, _intersection)(struct SNAME * _set1_, \ + struct SNAME * _set2_) \ { \ /* Callbacks are added later */ \ struct SNAME *_set_r_ = \ - PFX##_new_custom(_set1_->capacity, _set1_->load, _set1_->f_val, \ - _set1_->alloc, NULL); \ + CMC_(PFX, _new_custom)(_set1_->capacity, _set1_->load, \ + _set1_->f_val, _set1_->alloc, NULL); \ \ if (!_set_r_) \ { \ - _set1_->flag = cmc_flags.ALLOC; \ - _set2_->flag = cmc_flags.ALLOC; \ + _set1_->flag = CMC_FLAG_ALLOC; \ + _set2_->flag = CMC_FLAG_ALLOC; \ return NULL; \ } \ \ @@ -796,14 +821,14 @@ static const char *cmc_string_fmt_hashset = "struct %s<%s> " _set1_->count < _set2_->count ? _set1_ : _set2_; \ struct SNAME *_set_B_ = _set_A_ == _set1_ ? _set2_ : _set1_; \ \ - struct SNAME##_iter iter = PFX##_iter_start(_set_A_); \ + struct CMC_DEF_ITER(SNAME) iter = CMC_(PFX, _iter_start)(_set_A_); \ \ - for (; !PFX##_iter_at_end(&iter); PFX##_iter_next(&iter)) \ + for (; !CMC_(PFX, _iter_at_end)(&iter); CMC_(PFX, _iter_next)(&iter)) \ { \ - V value = PFX##_iter_value(&iter); \ + V value = CMC_(PFX, _iter_value)(&iter); \ \ - if (PFX##_impl_get_entry(_set_B_, value) != NULL) \ - PFX##_insert(_set_r_, value); \ + if (CMC_(PFX, _impl_get_entry)(_set_B_, value) != NULL) \ + CMC_(PFX, _insert)(_set_r_, value); \ } \ \ _set_r_->callbacks = _set1_->callbacks; \ @@ -811,28 +836,29 @@ static const char *cmc_string_fmt_hashset = "struct %s<%s> " return _set_r_; \ } \ \ - struct SNAME *PFX##_difference(struct SNAME *_set1_, struct SNAME *_set2_) \ + struct SNAME *CMC_(PFX, _difference)(struct SNAME * _set1_, \ + struct SNAME * _set2_) \ { \ /* Callbacks are added later */ \ struct SNAME *_set_r_ = \ - PFX##_new_custom(_set1_->capacity, _set1_->load, _set1_->f_val, \ - _set1_->alloc, NULL); \ + CMC_(PFX, _new_custom)(_set1_->capacity, _set1_->load, \ + _set1_->f_val, _set1_->alloc, NULL); \ \ if (!_set_r_) \ { \ - _set1_->flag = cmc_flags.ALLOC; \ - _set2_->flag = cmc_flags.ALLOC; \ + _set1_->flag = CMC_FLAG_ALLOC; \ + _set2_->flag = CMC_FLAG_ALLOC; \ return NULL; \ } \ \ - struct SNAME##_iter iter = PFX##_iter_start(_set1_); \ + struct CMC_DEF_ITER(SNAME) iter = CMC_(PFX, _iter_start)(_set1_); \ \ - for (; !PFX##_iter_at_end(&iter); PFX##_iter_next(&iter)) \ + for (; !CMC_(PFX, _iter_at_end)(&iter); CMC_(PFX, _iter_next)(&iter)) \ { \ - V value = PFX##_iter_value(&iter); \ + V value = CMC_(PFX, _iter_value)(&iter); \ \ - if (PFX##_impl_get_entry(_set2_, value) == NULL) \ - PFX##_insert(_set_r_, value); \ + if (CMC_(PFX, _impl_get_entry)(_set2_, value) == NULL) \ + CMC_(PFX, _insert)(_set_r_, value); \ } \ \ _set_r_->callbacks = _set1_->callbacks; \ @@ -840,38 +866,40 @@ static const char *cmc_string_fmt_hashset = "struct %s<%s> " return _set_r_; \ } \ \ - struct SNAME *PFX##_symmetric_difference(struct SNAME *_set1_, \ - struct SNAME *_set2_) \ + struct SNAME *CMC_(PFX, _symmetric_difference)(struct SNAME * _set1_, \ + struct SNAME * _set2_) \ { \ /* Callbacks are added later */ \ struct SNAME *_set_r_ = \ - PFX##_new_custom(_set1_->capacity, _set1_->load, _set1_->f_val, \ - _set1_->alloc, NULL); \ + CMC_(PFX, _new_custom)(_set1_->capacity, _set1_->load, \ + _set1_->f_val, _set1_->alloc, NULL); \ \ if (!_set_r_) \ { \ - _set1_->flag = cmc_flags.ALLOC; \ - _set2_->flag = cmc_flags.ALLOC; \ + _set1_->flag = CMC_FLAG_ALLOC; \ + _set2_->flag = CMC_FLAG_ALLOC; \ return NULL; \ } \ \ - struct SNAME##_iter iter1 = PFX##_iter_start(_set1_); \ - struct SNAME##_iter iter2 = PFX##_iter_start(_set2_); \ + struct CMC_DEF_ITER(SNAME) iter1 = CMC_(PFX, _iter_start)(_set1_); \ + struct CMC_DEF_ITER(SNAME) iter2 = CMC_(PFX, _iter_start)(_set2_); \ \ - for (; !PFX##_iter_at_end(&iter1); PFX##_iter_next(&iter1)) \ + for (; !CMC_(PFX, _iter_at_end)(&iter1); \ + CMC_(PFX, _iter_next)(&iter1)) \ { \ - V value = PFX##_iter_value(&iter1); \ + V value = CMC_(PFX, _iter_value)(&iter1); \ \ - if (PFX##_impl_get_entry(_set2_, value) == NULL) \ - PFX##_insert(_set_r_, value); \ + if (CMC_(PFX, _impl_get_entry)(_set2_, value) == NULL) \ + CMC_(PFX, _insert)(_set_r_, value); \ } \ \ - for (; !PFX##_iter_at_end(&iter2); PFX##_iter_next(&iter2)) \ + for (; !CMC_(PFX, _iter_at_end)(&iter2); \ + CMC_(PFX, _iter_next)(&iter2)) \ { \ - V value = PFX##_iter_value(&iter2); \ + V value = CMC_(PFX, _iter_value)(&iter2); \ \ - if (PFX##_impl_get_entry(_set1_, value) == NULL) \ - PFX##_insert(_set_r_, value); \ + if (CMC_(PFX, _impl_get_entry)(_set1_, value) == NULL) \ + CMC_(PFX, _insert)(_set_r_, value); \ } \ \ _set_r_->callbacks = _set1_->callbacks; \ @@ -882,10 +910,10 @@ static const char *cmc_string_fmt_hashset = "struct %s<%s> " /* Is _set1_ a subset of _set2_ ? */ \ /* A set X is a subset of a set Y when: X <= Y */ \ /* If X is a subset of Y, then Y is a superset of X */ \ - bool PFX##_is_subset(struct SNAME *_set1_, struct SNAME *_set2_) \ + bool CMC_(PFX, _is_subset)(struct SNAME * _set1_, struct SNAME * _set2_) \ { \ - _set1_->flag = cmc_flags.OK; \ - _set2_->flag = cmc_flags.OK; \ + _set1_->flag = CMC_FLAG_OK; \ + _set2_->flag = CMC_FLAG_OK; \ \ /* If the cardinality of _set1_ is greater than that of _set2_, */ \ /* then it is safe to say that _set1_ can't be a subset of _set2_ */ \ @@ -893,16 +921,16 @@ static const char *cmc_string_fmt_hashset = "struct %s<%s> " return false; \ \ /* The empty set is a subset of all sets */ \ - if (PFX##_empty(_set1_)) \ + if (CMC_(PFX, _empty)(_set1_)) \ return true; \ \ - struct SNAME##_iter iter = PFX##_iter_start(_set1_); \ + struct CMC_DEF_ITER(SNAME) iter = CMC_(PFX, _iter_start)(_set1_); \ \ - for (; !PFX##_iter_at_end(&iter); PFX##_iter_next(&iter)) \ + for (; !CMC_(PFX, _iter_at_end)(&iter); CMC_(PFX, _iter_next)(&iter)) \ { \ - V value = PFX##_iter_value(&iter); \ + V value = CMC_(PFX, _iter_value)(&iter); \ \ - if (PFX##_impl_get_entry(_set2_, value) == NULL) \ + if (CMC_(PFX, _impl_get_entry)(_set2_, value) == NULL) \ return false; \ } \ \ @@ -912,18 +940,19 @@ static const char *cmc_string_fmt_hashset = "struct %s<%s> " /* Is _set1_ a superset of _set2_ ? */ \ /* A set X is a superset of a set Y when: X >= Y */ \ /* If X is a superset of Y, then Y is a subset of X */ \ - bool PFX##_is_superset(struct SNAME *_set1_, struct SNAME *_set2_) \ + bool CMC_(PFX, _is_superset)(struct SNAME * _set1_, struct SNAME * _set2_) \ { \ - return PFX##_is_subset(_set2_, _set1_); \ + return CMC_(PFX, _is_subset)(_set2_, _set1_); \ } \ \ /* Is _set1_ a proper subset of _set2_ ? */ \ /* A set X is a proper subset of a set Y when: X < Y */ \ /* If X is a proper subset of Y, then Y is a proper superset of X */ \ - bool PFX##_is_proper_subset(struct SNAME *_set1_, struct SNAME *_set2_) \ + bool CMC_(PFX, _is_proper_subset)(struct SNAME * _set1_, \ + struct SNAME * _set2_) \ { \ - _set1_->flag = cmc_flags.OK; \ - _set2_->flag = cmc_flags.OK; \ + _set1_->flag = CMC_FLAG_OK; \ + _set2_->flag = CMC_FLAG_OK; \ \ /* If the cardinality of _set1_ is greater than or equal to that of */ \ /* _set2_, then it is safe to say that _set1_ can't be a proper */ \ @@ -931,10 +960,10 @@ static const char *cmc_string_fmt_hashset = "struct %s<%s> " if (_set1_->count >= _set2_->count) \ return false; \ \ - if (PFX##_empty(_set1_)) \ + if (CMC_(PFX, _empty)(_set1_)) \ { \ /* The empty set is a proper subset of all non-empty sets */ \ - if (!PFX##_empty(_set2_)) \ + if (!CMC_(PFX, _empty)(_set2_)) \ return true; \ /* The empty set is not a proper subset of itself (this is true */ \ /* for any set) */ \ @@ -942,13 +971,13 @@ static const char *cmc_string_fmt_hashset = "struct %s<%s> " return false; \ } \ \ - struct SNAME##_iter iter = PFX##_iter_start(_set1_); \ + struct CMC_DEF_ITER(SNAME) iter = CMC_(PFX, _iter_start)(_set1_); \ \ - for (; !PFX##_iter_at_end(&iter); PFX##_iter_next(&iter)) \ + for (; !CMC_(PFX, _iter_at_end)(&iter); CMC_(PFX, _iter_next)(&iter)) \ { \ - V value = PFX##_iter_value(&iter); \ + V value = CMC_(PFX, _iter_value)(&iter); \ \ - if (PFX##_impl_get_entry(_set2_, value) == NULL) \ + if (CMC_(PFX, _impl_get_entry)(_set2_, value) == NULL) \ return false; \ } \ \ @@ -958,40 +987,42 @@ static const char *cmc_string_fmt_hashset = "struct %s<%s> " /* Is _set1_ a proper superset of _set2_ ? */ \ /* A set X is a proper superset of a set Y when: X > Y */ \ /* If X is a proper superset of Y, then Y is a proper subset of X */ \ - bool PFX##_is_proper_superset(struct SNAME *_set1_, struct SNAME *_set2_) \ + bool CMC_(PFX, _is_proper_superset)(struct SNAME * _set1_, \ + struct SNAME * _set2_) \ { \ - return PFX##_is_proper_subset(_set2_, _set1_); \ + return CMC_(PFX, _is_proper_subset)(_set2_, _set1_); \ } \ \ /* Is _set1_ a disjointset of _set2_ ? */ \ /* A set X is a disjointset of a set Y if their intersection is empty, */ \ /* that is, if there are no elements in common between the two */ \ - bool PFX##_is_disjointset(struct SNAME *_set1_, struct SNAME *_set2_) \ + bool CMC_(PFX, _is_disjointset)(struct SNAME * _set1_, \ + struct SNAME * _set2_) \ { \ - _set1_->flag = cmc_flags.OK; \ - _set2_->flag = cmc_flags.OK; \ + _set1_->flag = CMC_FLAG_OK; \ + _set2_->flag = CMC_FLAG_OK; \ \ /* The intersection of an empty set with any other set will result */ \ /* in an empty set */ \ - if (PFX##_empty(_set1_)) \ + if (CMC_(PFX, _empty)(_set1_)) \ return true; \ \ - struct SNAME##_iter iter = PFX##_iter_start(_set1_); \ + struct CMC_DEF_ITER(SNAME) iter = CMC_(PFX, _iter_start)(_set1_); \ \ - for (; !PFX##_iter_at_end(&iter); PFX##_iter_next(&iter)) \ + for (; !CMC_(PFX, _iter_at_end)(&iter); CMC_(PFX, _iter_next)(&iter)) \ { \ - V value = PFX##_iter_value(&iter); \ + V value = CMC_(PFX, _iter_value)(&iter); \ \ - if (PFX##_impl_get_entry(_set2_, value) != NULL) \ + if (CMC_(PFX, _impl_get_entry)(_set2_, value) != NULL) \ return false; \ } \ \ return true; \ } \ \ - struct SNAME##_iter PFX##_iter_start(struct SNAME *target) \ + struct CMC_DEF_ITER(SNAME) CMC_(PFX, _iter_start)(struct SNAME * target) \ { \ - struct SNAME##_iter iter; \ + struct CMC_DEF_ITER(SNAME) iter; \ \ iter.target = target; \ iter.cursor = 0; \ @@ -999,9 +1030,9 @@ static const char *cmc_string_fmt_hashset = "struct %s<%s> " iter.first = 0; \ iter.last = 0; \ iter.start = true; \ - iter.end = PFX##_empty(target); \ + iter.end = CMC_(PFX, _empty)(target); \ \ - if (!PFX##_empty(target)) \ + if (!CMC_(PFX, _empty)(target)) \ { \ for (size_t i = 0; i < target->capacity; i++) \ { \ @@ -1027,19 +1058,19 @@ static const char *cmc_string_fmt_hashset = "struct %s<%s> " return iter; \ } \ \ - struct SNAME##_iter PFX##_iter_end(struct SNAME *target) \ + struct CMC_DEF_ITER(SNAME) CMC_(PFX, _iter_end)(struct SNAME * target) \ { \ - struct SNAME##_iter iter; \ + struct CMC_DEF_ITER(SNAME) iter; \ \ iter.target = target; \ iter.cursor = 0; \ iter.index = 0; \ iter.first = 0; \ iter.last = 0; \ - iter.start = PFX##_empty(target); \ + iter.start = CMC_(PFX, _empty)(target); \ iter.end = true; \ \ - if (!PFX##_empty(target)) \ + if (!CMC_(PFX, _empty)(target)) \ { \ for (size_t i = 0; i < target->capacity; i++) \ { \ @@ -1066,24 +1097,24 @@ static const char *cmc_string_fmt_hashset = "struct %s<%s> " return iter; \ } \ \ - bool PFX##_iter_at_start(struct SNAME##_iter *iter) \ + bool CMC_(PFX, _iter_at_start)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ - return PFX##_empty(iter->target) || iter->start; \ + return CMC_(PFX, _empty)(iter->target) || iter->start; \ } \ \ - bool PFX##_iter_at_end(struct SNAME##_iter *iter) \ + bool CMC_(PFX, _iter_at_end)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ - return PFX##_empty(iter->target) || iter->end; \ + return CMC_(PFX, _empty)(iter->target) || iter->end; \ } \ \ - bool PFX##_iter_to_start(struct SNAME##_iter *iter) \ + bool CMC_(PFX, _iter_to_start)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ - if (!PFX##_empty(iter->target)) \ + if (!CMC_(PFX, _empty)(iter->target)) \ { \ iter->cursor = iter->first; \ iter->index = 0; \ iter->start = true; \ - iter->end = PFX##_empty(iter->target); \ + iter->end = CMC_(PFX, _empty)(iter->target); \ \ return true; \ } \ @@ -1091,13 +1122,13 @@ static const char *cmc_string_fmt_hashset = "struct %s<%s> " return false; \ } \ \ - bool PFX##_iter_to_end(struct SNAME##_iter *iter) \ + bool CMC_(PFX, _iter_to_end)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ - if (!PFX##_empty(iter->target)) \ + if (!CMC_(PFX, _empty)(iter->target)) \ { \ iter->cursor = iter->last; \ iter->index = iter->target->count - 1; \ - iter->start = PFX##_empty(iter->target); \ + iter->start = CMC_(PFX, _empty)(iter->target); \ iter->end = true; \ \ return true; \ @@ -1106,7 +1137,7 @@ static const char *cmc_string_fmt_hashset = "struct %s<%s> " return false; \ } \ \ - bool PFX##_iter_next(struct SNAME##_iter *iter) \ + bool CMC_(PFX, _iter_next)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ if (iter->end) \ return false; \ @@ -1117,9 +1148,10 @@ static const char *cmc_string_fmt_hashset = "struct %s<%s> " return false; \ } \ \ - iter->start = PFX##_empty(iter->target); \ + iter->start = CMC_(PFX, _empty)(iter->target); \ \ - struct SNAME##_entry *scan = &(iter->target->buffer[iter->cursor]); \ + struct CMC_DEF_ENTRY(SNAME) *scan = \ + &(iter->target->buffer[iter->cursor]); \ \ iter->index++; \ \ @@ -1135,7 +1167,7 @@ static const char *cmc_string_fmt_hashset = "struct %s<%s> " return true; \ } \ \ - bool PFX##_iter_prev(struct SNAME##_iter *iter) \ + bool CMC_(PFX, _iter_prev)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ if (iter->start) \ return false; \ @@ -1146,9 +1178,10 @@ static const char *cmc_string_fmt_hashset = "struct %s<%s> " return false; \ } \ \ - iter->end = PFX##_empty(iter->target); \ + iter->end = CMC_(PFX, _empty)(iter->target); \ \ - struct SNAME##_entry *scan = &(iter->target->buffer[iter->cursor]); \ + struct CMC_DEF_ENTRY(SNAME) *scan = \ + &(iter->target->buffer[iter->cursor]); \ \ iter->index--; \ \ @@ -1165,7 +1198,8 @@ static const char *cmc_string_fmt_hashset = "struct %s<%s> " } \ \ /* Returns true only if the iterator moved */ \ - bool PFX##_iter_advance(struct SNAME##_iter *iter, size_t steps) \ + bool CMC_(PFX, _iter_advance)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t steps) \ { \ if (iter->end) \ return false; \ @@ -1180,13 +1214,14 @@ static const char *cmc_string_fmt_hashset = "struct %s<%s> " return false; \ \ for (size_t i = 0; i < steps; i++) \ - PFX##_iter_next(iter); \ + CMC_(PFX, _iter_next)(iter); \ \ return true; \ } \ \ /* Returns true only if the iterator moved */ \ - bool PFX##_iter_rewind(struct SNAME##_iter *iter, size_t steps) \ + bool CMC_(PFX, _iter_rewind)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t steps) \ { \ if (iter->start) \ return false; \ @@ -1201,46 +1236,47 @@ static const char *cmc_string_fmt_hashset = "struct %s<%s> " return false; \ \ for (size_t i = 0; i < steps; i++) \ - PFX##_iter_prev(iter); \ + CMC_(PFX, _iter_prev)(iter); \ \ return true; \ } \ \ /* Returns true only if the iterator was able to be positioned at the */ \ /* given index */ \ - bool PFX##_iter_go_to(struct SNAME##_iter *iter, size_t index) \ + bool CMC_(PFX, _iter_go_to)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t index) \ { \ if (index >= iter->target->count) \ return false; \ \ if (iter->index > index) \ - return PFX##_iter_rewind(iter, iter->index - index); \ + return CMC_(PFX, _iter_rewind)(iter, iter->index - index); \ else if (iter->index < index) \ - return PFX##_iter_advance(iter, index - iter->index); \ + return CMC_(PFX, _iter_advance)(iter, index - iter->index); \ \ return true; \ } \ \ - V PFX##_iter_value(struct SNAME##_iter *iter) \ + V CMC_(PFX, _iter_value)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ - if (PFX##_empty(iter->target)) \ + if (CMC_(PFX, _empty)(iter->target)) \ return (V){ 0 }; \ \ return iter->target->buffer[iter->cursor].value; \ } \ \ - size_t PFX##_iter_index(struct SNAME##_iter *iter) \ + size_t CMC_(PFX, _iter_index)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ return iter->index; \ } \ \ - static struct SNAME##_entry *PFX##_impl_get_entry(struct SNAME *_set_, \ - V value) \ + static struct CMC_DEF_ENTRY(SNAME) * \ + CMC_(PFX, _impl_get_entry)(struct SNAME * _set_, V value) \ { \ size_t hash = _set_->f_val->hash(value); \ size_t pos = hash % _set_->capacity; \ \ - struct SNAME##_entry *target = &(_set_->buffer[pos]); \ + struct CMC_DEF_ENTRY(SNAME) *target = &(_set_->buffer[pos]); \ \ while (target->state == CMC_ES_FILLED || \ target->state == CMC_ES_DELETED) \ @@ -1255,7 +1291,7 @@ static const char *cmc_string_fmt_hashset = "struct %s<%s> " return NULL; \ } \ \ - static size_t PFX##_impl_calculate_size(size_t required) \ + static size_t CMC_(PFX, _impl_calculate_size)(size_t required) \ { \ const size_t count = \ sizeof(cmc_hashtable_primes) / sizeof(cmc_hashtable_primes[0]); \ @@ -1270,4 +1306,4 @@ static const char *cmc_string_fmt_hashset = "struct %s<%s> " return cmc_hashtable_primes[i]; \ } -#endif /* CMC_HASHSET_H */ +#endif /* CMC_CMC_HASHSET_H */ diff --git a/src/cmc/heap.h b/src/cmc/heap.h index 0effac2..71fbaf7 100644 --- a/src/cmc/heap.h +++ b/src/cmc/heap.h @@ -27,8 +27,8 @@ * - min/max : Accesses the min/max element from the heap */ -#ifndef CMC_HEAP_H -#define CMC_HEAP_H +#ifndef CMC_CMC_HEAP_H +#define CMC_CMC_HEAP_H /* ------------------------------------------------------------------------- * Core functionalities of the C Macro Collections Library @@ -55,159 +55,171 @@ enum cmc_heap_order * Heap specific * ------------------------------------------------------------------------- */ /* to_string format */ -static const char *cmc_string_fmt_heap = "struct %s<%s> " - "at %p { " - "buffer:%p, " - "capacity:%" PRIuMAX ", " - "count:%" PRIuMAX ", " - "type:%s, " - "flag:%d, " - "f_val:%p, " - "alloc:%p, " - "callbacks: %p}"; +static const char *cmc_cmc_string_fmt_heap = "struct %s<%s> " + "at %p { " + "buffer:%p, " + "capacity:%" PRIuMAX ", " + "count:%" PRIuMAX ", " + "type:%s, " + "flag:%d, " + "f_val:%p, " + "alloc:%p, " + "callbacks: %p}"; -#define CMC_GENERATE_HEAP(PFX, SNAME, V) \ - CMC_GENERATE_HEAP_HEADER(PFX, SNAME, V) \ - CMC_GENERATE_HEAP_SOURCE(PFX, SNAME, V) +/** + * Core Heap implementation + */ +#define CMC_CMC_HEAP_CORE(BODY) \ + CMC_CMC_HEAP_CORE_HEADER(BODY) \ + CMC_CMC_HEAP_CORE_SOURCE(BODY) -#define CMC_WRAPGEN_HEAP_HEADER(PFX, SNAME, K, V) \ - CMC_GENERATE_HEAP_HEADER(PFX, SNAME, V) +#define CMC_CMC_HEAP_CORE_HEADER(BODY) \ + CMC_CMC_HEAP_CORE_HEADER_(CMC_PARAM_PFX(BODY), CMC_PARAM_SNAME(BODY), \ + CMC_PARAM_V(BODY)) -#define CMC_WRAPGEN_HEAP_SOURCE(PFX, SNAME, K, V) \ - CMC_GENERATE_HEAP_SOURCE(PFX, SNAME, V) +#define CMC_CMC_HEAP_CORE_SOURCE(BODY) \ + CMC_CMC_HEAP_CORE_SOURCE_(CMC_PARAM_PFX(BODY), CMC_PARAM_SNAME(BODY), \ + CMC_PARAM_V(BODY)) /* ------------------------------------------------------------------------- * Header * ------------------------------------------------------------------------- */ -#define CMC_GENERATE_HEAP_HEADER(PFX, SNAME, V) \ - \ - /* Heap Structure */ \ - struct SNAME \ - { \ - /* Dynamic array of elements */ \ - V *buffer; \ - \ - /* Current array capacity */ \ - size_t capacity; \ - \ - /* Current amount of elements in the heap */ \ - size_t count; \ - \ - /* Heap order (MaxHeap or MinHeap) */ \ - enum cmc_heap_order HO; \ - \ - /* Flags indicating errors or success */ \ - int flag; \ - \ - /* Value function table */ \ - struct SNAME##_fval *f_val; \ - \ - /* Custom allocation functions */ \ - struct cmc_alloc_node *alloc; \ - \ - /* Custom callback functions */ \ - struct cmc_callbacks *callbacks; \ - }; \ - \ - /* Value struct function table */ \ - struct SNAME##_fval \ - { \ - /* Comparator function */ \ - int (*cmp)(V, V); \ - \ - /* Copy function */ \ - V (*cpy)(V); \ - \ - /* To string function */ \ - bool (*str)(FILE *, V); \ - \ - /* Free from memory function */ \ - void (*free)(V); \ - \ - /* Hash function */ \ - size_t (*hash)(V); \ - \ - /* Priority function */ \ - int (*pri)(V, V); \ - }; \ - \ - /* Heap Iterator */ \ - struct SNAME##_iter \ - { \ - /* Target heap */ \ - struct SNAME *target; \ - \ - /* Cursor's position (index) */ \ - size_t cursor; \ - \ - /* If the iterator has reached the start of the iteration */ \ - bool start; \ - \ - /* If the iterator has reached the end of the iteration */ \ - bool end; \ - }; \ - \ - /* Collection Functions */ \ - /* Collection Allocation and Deallocation */ \ - struct SNAME *PFX##_new(size_t capacity, enum cmc_heap_order HO, \ - struct SNAME##_fval *f_val); \ - struct SNAME *PFX##_new_custom( \ - size_t capacity, enum cmc_heap_order HO, struct SNAME##_fval *f_val, \ - struct cmc_alloc_node *alloc, struct cmc_callbacks *callbacks); \ - void PFX##_clear(struct SNAME *_heap_); \ - void PFX##_free(struct SNAME *_heap_); \ - /* Customization of Allocation and Callbacks */ \ - void PFX##_customize(struct SNAME *_heap_, struct cmc_alloc_node *alloc, \ - struct cmc_callbacks *callbacks); \ - /* Collection Input and Output */ \ - bool PFX##_insert(struct SNAME *_heap_, V value); \ - bool PFX##_remove(struct SNAME *_heap_); \ - /* Element Access */ \ - V PFX##_peek(struct SNAME *_heap_); \ - /* Collection State */ \ - bool PFX##_contains(struct SNAME *_heap_, V value); \ - bool PFX##_empty(struct SNAME *_heap_); \ - bool PFX##_full(struct SNAME *_heap_); \ - size_t PFX##_count(struct SNAME *_heap_); \ - size_t PFX##_capacity(struct SNAME *_heap_); \ - int PFX##_flag(struct SNAME *_heap_); \ - /* Collection Utility */ \ - bool PFX##_resize(struct SNAME *_heap_, size_t capacity); \ - struct SNAME *PFX##_copy_of(struct SNAME *_heap_); \ - bool PFX##_equals(struct SNAME *_heap1_, struct SNAME *_heap2_); \ - struct cmc_string PFX##_to_string(struct SNAME *_heap_); \ - bool PFX##_print(struct SNAME *_heap_, FILE *fptr); \ - \ - /* Iterator Functions */ \ - /* Iterator Initialization */ \ - struct SNAME##_iter PFX##_iter_start(struct SNAME *target); \ - struct SNAME##_iter PFX##_iter_end(struct SNAME *target); \ - /* Iterator State */ \ - bool PFX##_iter_at_start(struct SNAME##_iter *iter); \ - bool PFX##_iter_at_end(struct SNAME##_iter *iter); \ - /* Iterator Movement */ \ - bool PFX##_iter_to_start(struct SNAME##_iter *iter); \ - bool PFX##_iter_to_end(struct SNAME##_iter *iter); \ - bool PFX##_iter_next(struct SNAME##_iter *iter); \ - bool PFX##_iter_prev(struct SNAME##_iter *iter); \ - bool PFX##_iter_advance(struct SNAME##_iter *iter, size_t steps); \ - bool PFX##_iter_rewind(struct SNAME##_iter *iter, size_t steps); \ - bool PFX##_iter_go_to(struct SNAME##_iter *iter, size_t index); \ - /* Iterator Access */ \ - V PFX##_iter_value(struct SNAME##_iter *iter); \ - size_t PFX##_iter_index(struct SNAME##_iter *iter); +#define CMC_CMC_HEAP_CORE_HEADER_(PFX, SNAME, V) \ + \ + /* Heap Structure */ \ + struct SNAME \ + { \ + /* Dynamic array of elements */ \ + V *buffer; \ + \ + /* Current array capacity */ \ + size_t capacity; \ + \ + /* Current amount of elements in the heap */ \ + size_t count; \ + \ + /* Heap order (MaxHeap or MinHeap) */ \ + enum cmc_heap_order HO; \ + \ + /* Flags indicating errors or success */ \ + int flag; \ + \ + /* Value function table */ \ + struct CMC_DEF_FVAL(SNAME) * f_val; \ + \ + /* Custom allocation functions */ \ + struct cmc_alloc_node *alloc; \ + \ + /* Custom callback functions */ \ + struct cmc_callbacks *callbacks; \ + }; \ + \ + /* Value struct function table */ \ + struct CMC_DEF_FVAL(SNAME) \ + { \ + /* Comparator function */ \ + int (*cmp)(V, V); \ + \ + /* Copy function */ \ + V (*cpy)(V); \ + \ + /* To string function */ \ + bool (*str)(FILE *, V); \ + \ + /* Free from memory function */ \ + void (*free)(V); \ + \ + /* Hash function */ \ + size_t (*hash)(V); \ + \ + /* Priority function */ \ + int (*pri)(V, V); \ + }; \ + \ + /* Heap Iterator */ \ + struct CMC_DEF_ITER(SNAME) \ + { \ + /* Target heap */ \ + struct SNAME *target; \ + \ + /* Cursor's position (index) */ \ + size_t cursor; \ + \ + /* If the iterator has reached the start of the iteration */ \ + bool start; \ + \ + /* If the iterator has reached the end of the iteration */ \ + bool end; \ + }; \ + \ + /* Collection Functions */ \ + /* Collection Allocation and Deallocation */ \ + struct SNAME *CMC_(PFX, _new)(size_t capacity, enum cmc_heap_order HO, \ + struct CMC_DEF_FVAL(SNAME) * f_val); \ + struct SNAME *CMC_(PFX, _new_custom)( \ + size_t capacity, enum cmc_heap_order HO, \ + struct CMC_DEF_FVAL(SNAME) * f_val, struct cmc_alloc_node * alloc, \ + struct cmc_callbacks * callbacks); \ + void CMC_(PFX, _clear)(struct SNAME * _heap_); \ + void CMC_(PFX, _free)(struct SNAME * _heap_); \ + /* Customization of Allocation and Callbacks */ \ + void CMC_(PFX, _customize)(struct SNAME * _heap_, \ + struct cmc_alloc_node * alloc, \ + struct cmc_callbacks * callbacks); \ + /* Collection Input and Output */ \ + bool CMC_(PFX, _insert)(struct SNAME * _heap_, V value); \ + bool CMC_(PFX, _remove)(struct SNAME * _heap_); \ + /* Element Access */ \ + V CMC_(PFX, _peek)(struct SNAME * _heap_); \ + /* Collection State */ \ + bool CMC_(PFX, _contains)(struct SNAME * _heap_, V value); \ + bool CMC_(PFX, _empty)(struct SNAME * _heap_); \ + bool CMC_(PFX, _full)(struct SNAME * _heap_); \ + size_t CMC_(PFX, _count)(struct SNAME * _heap_); \ + size_t CMC_(PFX, _capacity)(struct SNAME * _heap_); \ + int CMC_(PFX, _flag)(struct SNAME * _heap_); \ + /* Collection Utility */ \ + bool CMC_(PFX, _resize)(struct SNAME * _heap_, size_t capacity); \ + struct SNAME *CMC_(PFX, _copy_of)(struct SNAME * _heap_); \ + bool CMC_(PFX, _equals)(struct SNAME * _heap1_, struct SNAME * _heap2_); \ + struct cmc_string CMC_(PFX, _to_string)(struct SNAME * _heap_); \ + bool CMC_(PFX, _print)(struct SNAME * _heap_, FILE * fptr); \ + \ + /* Iterator Functions */ \ + /* Iterator Initialization */ \ + struct CMC_DEF_ITER(SNAME) CMC_(PFX, _iter_start)(struct SNAME * target); \ + struct CMC_DEF_ITER(SNAME) CMC_(PFX, _iter_end)(struct SNAME * target); \ + /* Iterator State */ \ + bool CMC_(PFX, _iter_at_start)(struct CMC_DEF_ITER(SNAME) * iter); \ + bool CMC_(PFX, _iter_at_end)(struct CMC_DEF_ITER(SNAME) * iter); \ + /* Iterator Movement */ \ + bool CMC_(PFX, _iter_to_start)(struct CMC_DEF_ITER(SNAME) * iter); \ + bool CMC_(PFX, _iter_to_end)(struct CMC_DEF_ITER(SNAME) * iter); \ + bool CMC_(PFX, _iter_next)(struct CMC_DEF_ITER(SNAME) * iter); \ + bool CMC_(PFX, _iter_prev)(struct CMC_DEF_ITER(SNAME) * iter); \ + bool CMC_(PFX, _iter_advance)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t steps); \ + bool CMC_(PFX, _iter_rewind)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t steps); \ + bool CMC_(PFX, _iter_go_to)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t index); \ + /* Iterator Access */ \ + V CMC_(PFX, _iter_value)(struct CMC_DEF_ITER(SNAME) * iter); \ + size_t CMC_(PFX, _iter_index)(struct CMC_DEF_ITER(SNAME) * iter); /* ------------------------------------------------------------------------- * Source * ------------------------------------------------------------------------- */ -#define CMC_GENERATE_HEAP_SOURCE(PFX, SNAME, V) \ +#define CMC_CMC_HEAP_CORE_SOURCE_(PFX, SNAME, V) \ \ /* Implementation Detail Functions */ \ - static void PFX##_impl_float_up(struct SNAME *_heap_, size_t index); \ - static void PFX##_impl_float_down(struct SNAME *_heap_, size_t index); \ + static void CMC_(PFX, _impl_float_up)(struct SNAME * _heap_, \ + size_t index); \ + static void CMC_(PFX, _impl_float_down)(struct SNAME * _heap_, \ + size_t index); \ \ - struct SNAME *PFX##_new(size_t capacity, enum cmc_heap_order HO, \ - struct SNAME##_fval *f_val) \ + struct SNAME *CMC_(PFX, _new)(size_t capacity, enum cmc_heap_order HO, \ + struct CMC_DEF_FVAL(SNAME) * f_val) \ { \ struct cmc_alloc_node *alloc = &cmc_alloc_node_default; \ \ @@ -236,7 +248,7 @@ static const char *cmc_string_fmt_heap = "struct %s<%s> " _heap_->capacity = capacity; \ _heap_->count = 0; \ _heap_->HO = HO; \ - _heap_->flag = cmc_flags.OK; \ + _heap_->flag = CMC_FLAG_OK; \ _heap_->f_val = f_val; \ _heap_->alloc = alloc; \ _heap_->callbacks = NULL; \ @@ -244,9 +256,10 @@ static const char *cmc_string_fmt_heap = "struct %s<%s> " return _heap_; \ } \ \ - struct SNAME *PFX##_new_custom( \ - size_t capacity, enum cmc_heap_order HO, struct SNAME##_fval *f_val, \ - struct cmc_alloc_node *alloc, struct cmc_callbacks *callbacks) \ + struct SNAME *CMC_(PFX, _new_custom)( \ + size_t capacity, enum cmc_heap_order HO, \ + struct CMC_DEF_FVAL(SNAME) * f_val, struct cmc_alloc_node * alloc, \ + struct cmc_callbacks * callbacks) \ { \ if (capacity < 1) \ return NULL; \ @@ -276,7 +289,7 @@ static const char *cmc_string_fmt_heap = "struct %s<%s> " _heap_->capacity = capacity; \ _heap_->count = 0; \ _heap_->HO = HO; \ - _heap_->flag = cmc_flags.OK; \ + _heap_->flag = CMC_FLAG_OK; \ _heap_->f_val = f_val; \ _heap_->alloc = alloc; \ _heap_->callbacks = callbacks; \ @@ -284,7 +297,7 @@ static const char *cmc_string_fmt_heap = "struct %s<%s> " return _heap_; \ } \ \ - void PFX##_clear(struct SNAME *_heap_) \ + void CMC_(PFX, _clear)(struct SNAME * _heap_) \ { \ if (_heap_->f_val->free) \ { \ @@ -297,10 +310,10 @@ static const char *cmc_string_fmt_heap = "struct %s<%s> " memset(_heap_->buffer, 0, sizeof(V) * _heap_->capacity); \ \ _heap_->count = 0; \ - _heap_->flag = cmc_flags.OK; \ + _heap_->flag = CMC_FLAG_OK; \ } \ \ - void PFX##_free(struct SNAME *_heap_) \ + void CMC_(PFX, _free)(struct SNAME * _heap_) \ { \ if (_heap_->f_val->free) \ { \ @@ -314,8 +327,9 @@ static const char *cmc_string_fmt_heap = "struct %s<%s> " _heap_->alloc->free(_heap_); \ } \ \ - void PFX##_customize(struct SNAME *_heap_, struct cmc_alloc_node *alloc, \ - struct cmc_callbacks *callbacks) \ + void CMC_(PFX, _customize)(struct SNAME * _heap_, \ + struct cmc_alloc_node * alloc, \ + struct cmc_callbacks * callbacks) \ { \ if (!alloc) \ _heap_->alloc = &cmc_alloc_node_default; \ @@ -324,14 +338,14 @@ static const char *cmc_string_fmt_heap = "struct %s<%s> " \ _heap_->callbacks = callbacks; \ \ - _heap_->flag = cmc_flags.OK; \ + _heap_->flag = CMC_FLAG_OK; \ } \ \ - bool PFX##_insert(struct SNAME *_heap_, V value) \ + bool CMC_(PFX, _insert)(struct SNAME * _heap_, V value) \ { \ - if (PFX##_full(_heap_)) \ + if (CMC_(PFX, _full)(_heap_)) \ { \ - if (!PFX##_resize(_heap_, _heap_->count * 2)) \ + if (!CMC_(PFX, _resize)(_heap_, _heap_->count * 2)) \ return false; \ } \ \ @@ -339,10 +353,10 @@ static const char *cmc_string_fmt_heap = "struct %s<%s> " \ if (_heap_->count > 1) \ { \ - PFX##_impl_float_up(_heap_, _heap_->count - 1); \ + CMC_(PFX, _impl_float_up)(_heap_, _heap_->count - 1); \ } \ \ - _heap_->flag = cmc_flags.OK; \ + _heap_->flag = CMC_FLAG_OK; \ \ if (_heap_->callbacks && _heap_->callbacks->create) \ _heap_->callbacks->create(); \ @@ -350,11 +364,11 @@ static const char *cmc_string_fmt_heap = "struct %s<%s> " return true; \ } \ \ - bool PFX##_remove(struct SNAME *_heap_) \ + bool CMC_(PFX, _remove)(struct SNAME * _heap_) \ { \ - if (PFX##_empty(_heap_)) \ + if (CMC_(PFX, _empty)(_heap_)) \ { \ - _heap_->flag = cmc_flags.EMPTY; \ + _heap_->flag = CMC_FLAG_EMPTY; \ return false; \ } \ \ @@ -363,9 +377,9 @@ static const char *cmc_string_fmt_heap = "struct %s<%s> " \ _heap_->count--; \ \ - PFX##_impl_float_down(_heap_, 0); \ + CMC_(PFX, _impl_float_down)(_heap_, 0); \ \ - _heap_->flag = cmc_flags.OK; \ + _heap_->flag = CMC_FLAG_OK; \ \ if (_heap_->callbacks && _heap_->callbacks->delete) \ _heap_->callbacks->delete (); \ @@ -373,15 +387,15 @@ static const char *cmc_string_fmt_heap = "struct %s<%s> " return true; \ } \ \ - V PFX##_peek(struct SNAME *_heap_) \ + V CMC_(PFX, _peek)(struct SNAME * _heap_) \ { \ - if (PFX##_empty(_heap_)) \ + if (CMC_(PFX, _empty)(_heap_)) \ { \ - _heap_->flag = cmc_flags.EMPTY; \ + _heap_->flag = CMC_FLAG_EMPTY; \ return (V){ 0 }; \ } \ \ - _heap_->flag = cmc_flags.OK; \ + _heap_->flag = CMC_FLAG_OK; \ \ if (_heap_->callbacks && _heap_->callbacks->read) \ _heap_->callbacks->read(); \ @@ -389,9 +403,9 @@ static const char *cmc_string_fmt_heap = "struct %s<%s> " return _heap_->buffer[0]; \ } \ \ - bool PFX##_contains(struct SNAME *_heap_, V value) \ + bool CMC_(PFX, _contains)(struct SNAME * _heap_, V value) \ { \ - _heap_->flag = cmc_flags.OK; \ + _heap_->flag = CMC_FLAG_OK; \ \ bool result = false; \ \ @@ -410,41 +424,41 @@ static const char *cmc_string_fmt_heap = "struct %s<%s> " return result; \ } \ \ - bool PFX##_empty(struct SNAME *_heap_) \ + bool CMC_(PFX, _empty)(struct SNAME * _heap_) \ { \ return _heap_->count == 0; \ } \ \ - bool PFX##_full(struct SNAME *_heap_) \ + bool CMC_(PFX, _full)(struct SNAME * _heap_) \ { \ return _heap_->count >= _heap_->capacity; \ } \ \ - size_t PFX##_count(struct SNAME *_heap_) \ + size_t CMC_(PFX, _count)(struct SNAME * _heap_) \ { \ return _heap_->count; \ } \ \ - size_t PFX##_capacity(struct SNAME *_heap_) \ + size_t CMC_(PFX, _capacity)(struct SNAME * _heap_) \ { \ return _heap_->capacity; \ } \ \ - int PFX##_flag(struct SNAME *_heap_) \ + int CMC_(PFX, _flag)(struct SNAME * _heap_) \ { \ return _heap_->flag; \ } \ \ - bool PFX##_resize(struct SNAME *_heap_, size_t capacity) \ + bool CMC_(PFX, _resize)(struct SNAME * _heap_, size_t capacity) \ { \ - _heap_->flag = cmc_flags.OK; \ + _heap_->flag = CMC_FLAG_OK; \ \ if (_heap_->capacity == capacity) \ goto success; \ \ if (capacity < _heap_->count) \ { \ - _heap_->flag = cmc_flags.INVALID; \ + _heap_->flag = CMC_FLAG_INVALID; \ return false; \ } \ \ @@ -453,7 +467,7 @@ static const char *cmc_string_fmt_heap = "struct %s<%s> " \ if (!new_buffer) \ { \ - _heap_->flag = cmc_flags.ALLOC; \ + _heap_->flag = CMC_FLAG_ALLOC; \ return false; \ } \ \ @@ -470,15 +484,15 @@ static const char *cmc_string_fmt_heap = "struct %s<%s> " return true; \ } \ \ - struct SNAME *PFX##_copy_of(struct SNAME *_heap_) \ + struct SNAME *CMC_(PFX, _copy_of)(struct SNAME * _heap_) \ { \ - struct SNAME *result = \ - PFX##_new_custom(_heap_->capacity, _heap_->HO, _heap_->f_val, \ - _heap_->alloc, _heap_->callbacks); \ + struct SNAME *result = CMC_(PFX, _new_custom)( \ + _heap_->capacity, _heap_->HO, _heap_->f_val, _heap_->alloc, \ + _heap_->callbacks); \ \ if (!result) \ { \ - _heap_->flag = cmc_flags.ERROR; \ + _heap_->flag = CMC_FLAG_ERROR; \ return NULL; \ } \ \ @@ -492,15 +506,15 @@ static const char *cmc_string_fmt_heap = "struct %s<%s> " \ result->count = _heap_->count; \ \ - _heap_->flag = cmc_flags.OK; \ + _heap_->flag = CMC_FLAG_OK; \ \ return result; \ } \ \ - bool PFX##_equals(struct SNAME *_heap1_, struct SNAME *_heap2_) \ + bool CMC_(PFX, _equals)(struct SNAME * _heap1_, struct SNAME * _heap2_) \ { \ - _heap1_->flag = cmc_flags.OK; \ - _heap2_->flag = cmc_flags.OK; \ + _heap1_->flag = CMC_FLAG_OK; \ + _heap2_->flag = CMC_FLAG_OK; \ \ if (_heap1_->count != _heap2_->count) \ return false; \ @@ -515,20 +529,20 @@ static const char *cmc_string_fmt_heap = "struct %s<%s> " return true; \ } \ \ - struct cmc_string PFX##_to_string(struct SNAME *_heap_) \ + struct cmc_string CMC_(PFX, _to_string)(struct SNAME * _heap_) \ { \ struct cmc_string str; \ struct SNAME *h_ = _heap_; \ const char *t = h_->HO == 1 ? "MaxHeap" : "MinHeap"; \ \ - int n = snprintf(str.s, cmc_string_len, cmc_string_fmt_heap, #SNAME, \ - #V, h_, h_->buffer, h_->capacity, h_->count, t, \ - h_->flag, h_->f_val, h_->alloc, h_->callbacks); \ + int n = snprintf(str.s, cmc_string_len, cmc_cmc_string_fmt_heap, \ + #SNAME, #V, h_, h_->buffer, h_->capacity, h_->count, \ + t, h_->flag, h_->f_val, h_->alloc, h_->callbacks); \ \ return n >= 0 ? str : (struct cmc_string){ 0 }; \ } \ \ - bool PFX##_print(struct SNAME *_heap_, FILE *fptr) \ + bool CMC_(PFX, _print)(struct SNAME * _heap_, FILE * fptr) \ { \ for (size_t i = 0; i < _heap_->count; i++) \ { \ @@ -539,50 +553,50 @@ static const char *cmc_string_fmt_heap = "struct %s<%s> " return true; \ } \ \ - struct SNAME##_iter PFX##_iter_start(struct SNAME *target) \ + struct CMC_DEF_ITER(SNAME) CMC_(PFX, _iter_start)(struct SNAME * target) \ { \ - struct SNAME##_iter iter; \ + struct CMC_DEF_ITER(SNAME) iter; \ \ iter.target = target; \ iter.cursor = 0; \ iter.start = true; \ - iter.end = PFX##_empty(target); \ + iter.end = CMC_(PFX, _empty)(target); \ \ return iter; \ } \ \ - struct SNAME##_iter PFX##_iter_end(struct SNAME *target) \ + struct CMC_DEF_ITER(SNAME) CMC_(PFX, _iter_end)(struct SNAME * target) \ { \ - struct SNAME##_iter iter; \ + struct CMC_DEF_ITER(SNAME) iter; \ \ iter.target = target; \ iter.cursor = 0; \ - iter.start = PFX##_empty(target); \ + iter.start = CMC_(PFX, _empty)(target); \ iter.end = true; \ \ - if (!PFX##_empty(target)) \ + if (!CMC_(PFX, _empty)(target)) \ iter.cursor = target->count - 1; \ \ return iter; \ } \ \ - bool PFX##_iter_at_start(struct SNAME##_iter *iter) \ + bool CMC_(PFX, _iter_at_start)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ - return PFX##_empty(iter->target) || iter->start; \ + return CMC_(PFX, _empty)(iter->target) || iter->start; \ } \ \ - bool PFX##_iter_at_end(struct SNAME##_iter *iter) \ + bool CMC_(PFX, _iter_at_end)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ - return PFX##_empty(iter->target) || iter->end; \ + return CMC_(PFX, _empty)(iter->target) || iter->end; \ } \ \ - bool PFX##_iter_to_start(struct SNAME##_iter *iter) \ + bool CMC_(PFX, _iter_to_start)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ - if (!PFX##_empty(iter->target)) \ + if (!CMC_(PFX, _empty)(iter->target)) \ { \ iter->cursor = 0; \ iter->start = true; \ - iter->end = PFX##_empty(iter->target); \ + iter->end = CMC_(PFX, _empty)(iter->target); \ \ return true; \ } \ @@ -590,12 +604,12 @@ static const char *cmc_string_fmt_heap = "struct %s<%s> " return false; \ } \ \ - bool PFX##_iter_to_end(struct SNAME##_iter *iter) \ + bool CMC_(PFX, _iter_to_end)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ - if (!PFX##_empty(iter->target)) \ + if (!CMC_(PFX, _empty)(iter->target)) \ { \ iter->cursor = iter->target->count - 1; \ - iter->start = PFX##_empty(iter->target); \ + iter->start = CMC_(PFX, _empty)(iter->target); \ iter->end = true; \ \ return true; \ @@ -604,7 +618,7 @@ static const char *cmc_string_fmt_heap = "struct %s<%s> " return false; \ } \ \ - bool PFX##_iter_next(struct SNAME##_iter *iter) \ + bool CMC_(PFX, _iter_next)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ if (iter->end) \ return false; \ @@ -615,14 +629,14 @@ static const char *cmc_string_fmt_heap = "struct %s<%s> " return false; \ } \ \ - iter->start = PFX##_empty(iter->target); \ + iter->start = CMC_(PFX, _empty)(iter->target); \ \ iter->cursor++; \ \ return true; \ } \ \ - bool PFX##_iter_prev(struct SNAME##_iter *iter) \ + bool CMC_(PFX, _iter_prev)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ if (iter->start) \ return false; \ @@ -633,7 +647,7 @@ static const char *cmc_string_fmt_heap = "struct %s<%s> " return false; \ } \ \ - iter->end = PFX##_empty(iter->target); \ + iter->end = CMC_(PFX, _empty)(iter->target); \ \ iter->cursor--; \ \ @@ -641,7 +655,8 @@ static const char *cmc_string_fmt_heap = "struct %s<%s> " } \ \ /* Returns true only if the iterator moved */ \ - bool PFX##_iter_advance(struct SNAME##_iter *iter, size_t steps) \ + bool CMC_(PFX, _iter_advance)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t steps) \ { \ if (iter->end) \ return false; \ @@ -658,7 +673,7 @@ static const char *cmc_string_fmt_heap = "struct %s<%s> " if (iter->end) \ return false; \ \ - iter->start = PFX##_empty(iter->target); \ + iter->start = CMC_(PFX, _empty)(iter->target); \ \ iter->cursor += steps; \ \ @@ -666,7 +681,8 @@ static const char *cmc_string_fmt_heap = "struct %s<%s> " } \ \ /* Returns true only if the iterator moved */ \ - bool PFX##_iter_rewind(struct SNAME##_iter *iter, size_t steps) \ + bool CMC_(PFX, _iter_rewind)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t steps) \ { \ if (iter->start) \ return false; \ @@ -680,7 +696,7 @@ static const char *cmc_string_fmt_heap = "struct %s<%s> " if (steps == 0 || iter->cursor < steps) \ return false; \ \ - iter->end = PFX##_empty(iter->target); \ + iter->end = CMC_(PFX, _empty)(iter->target); \ \ iter->cursor -= steps; \ \ @@ -689,33 +705,34 @@ static const char *cmc_string_fmt_heap = "struct %s<%s> " \ /* Returns true only if the iterator was able to be positioned at the */ \ /* given index */ \ - bool PFX##_iter_go_to(struct SNAME##_iter *iter, size_t index) \ + bool CMC_(PFX, _iter_go_to)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t index) \ { \ if (index >= iter->target->count) \ return false; \ \ if (iter->cursor > index) \ - return PFX##_iter_rewind(iter, iter->cursor - index); \ + return CMC_(PFX, _iter_rewind)(iter, iter->cursor - index); \ else if (iter->cursor < index) \ - return PFX##_iter_advance(iter, index - iter->cursor); \ + return CMC_(PFX, _iter_advance)(iter, index - iter->cursor); \ \ return true; \ } \ \ - V PFX##_iter_value(struct SNAME##_iter *iter) \ + V CMC_(PFX, _iter_value)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ - if (PFX##_empty(iter->target)) \ + if (CMC_(PFX, _empty)(iter->target)) \ return (V){ 0 }; \ \ return iter->target->buffer[iter->cursor]; \ } \ \ - size_t PFX##_iter_index(struct SNAME##_iter *iter) \ + size_t CMC_(PFX, _iter_index)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ return iter->cursor; \ } \ \ - static void PFX##_impl_float_up(struct SNAME *_heap_, size_t index) \ + static void CMC_(PFX, _impl_float_up)(struct SNAME * _heap_, size_t index) \ { \ /* Current index */ \ size_t C = index; \ @@ -743,7 +760,8 @@ static const char *cmc_string_fmt_heap = "struct %s<%s> " } \ } \ \ - static void PFX##_impl_float_down(struct SNAME *_heap_, size_t index) \ + static void CMC_(PFX, _impl_float_down)(struct SNAME * _heap_, \ + size_t index) \ { \ int mod = _heap_->HO; \ \ @@ -784,4 +802,4 @@ static const char *cmc_string_fmt_heap = "struct %s<%s> " } \ } -#endif /* CMC_HEAP_H */ +#endif /* CMC_CMC_HEAP_H */ diff --git a/src/cmc/intervalheap.h b/src/cmc/intervalheap.h index 2b99a30..db61308 100644 --- a/src/cmc/intervalheap.h +++ b/src/cmc/intervalheap.h @@ -18,8 +18,8 @@ * - O(log n) - Remove Max */ -#ifndef CMC_INTERVALHEAP_H -#define CMC_INTERVALHEAP_H +#ifndef CMC_CMC_INTERVALHEAP_H +#define CMC_CMC_INTERVALHEAP_H /* ------------------------------------------------------------------------- * Core functionalities of the C Macro Collections Library @@ -30,165 +30,176 @@ * IntervalHeap specific * ------------------------------------------------------------------------- */ /* to_string format */ -static const char *cmc_string_fmt_intervalheap = "struct %s<%s> " - "at %p { " - "buffer:%p, " - "capacity:%" PRIuMAX ", " - "size:%" PRIuMAX ", " - "count:%" PRIuMAX ", " - "flag:%d, " - "f_val:%p, " - "alloc:%p, " - "callbacks:%p }"; +static const char *cmc_cmc_string_fmt_intervalheap = "struct %s<%s> " + "at %p { " + "buffer:%p, " + "capacity:%" PRIuMAX ", " + "size:%" PRIuMAX ", " + "count:%" PRIuMAX ", " + "flag:%d, " + "f_val:%p, " + "alloc:%p, " + "callbacks:%p }"; -#define CMC_GENERATE_INTERVALHEAP(PFX, SNAME, V) \ - CMC_GENERATE_INTERVALHEAP_HEADER(PFX, SNAME, V) \ - CMC_GENERATE_INTERVALHEAP_SOURCE(PFX, SNAME, V) +/** + * Core IntervalHeap implementation + */ +#define CMC_CMC_INTERVALHEAP_CORE(BODY) \ + CMC_CMC_INTERVALHEAP_CORE_HEADER(BODY) \ + CMC_CMC_INTERVALHEAP_CORE_SOURCE(BODY) -#define CMC_WRAPGEN_INTERVALHEAP_HEADER(PFX, SNAME, K, V) \ - CMC_GENERATE_INTERVALHEAP_HEADER(PFX, SNAME, V) +#define CMC_CMC_INTERVALHEAP_CORE_HEADER(BODY) \ + CMC_CMC_INTERVALHEAP_CORE_HEADER_( \ + CMC_PARAM_PFX(BODY), CMC_PARAM_SNAME(BODY), CMC_PARAM_V(BODY)) -#define CMC_WRAPGEN_INTERVALHEAP_SOURCE(PFX, SNAME, K, V) \ - CMC_GENERATE_INTERVALHEAP_SOURCE(PFX, SNAME, V) +#define CMC_CMC_INTERVALHEAP_CORE_SOURCE(BODY) \ + CMC_CMC_INTERVALHEAP_CORE_SOURCE_( \ + CMC_PARAM_PFX(BODY), CMC_PARAM_SNAME(BODY), CMC_PARAM_V(BODY)) /* ------------------------------------------------------------------------- * Header * ------------------------------------------------------------------------- */ -#define CMC_GENERATE_INTERVALHEAP_HEADER(PFX, SNAME, V) \ - \ - /* Heap Structure */ \ - struct SNAME \ - { \ - /* Dynamic array of elements */ \ - /* buffer[n][0] is MinHeap and buffer[n][1] is MaxHeap */ \ - V (*buffer)[2]; \ - \ - /* Current array capacity */ \ - size_t capacity; \ - \ - /* Current amount of pairs of values in the array */ \ - size_t size; \ - \ - /* Current amount of elements in the heap */ \ - size_t count; \ - \ - /* Flags indicating errors or success */ \ - int flag; \ - \ - /* Value function table */ \ - struct SNAME##_fval *f_val; \ - \ - /* Custom allocation functions */ \ - struct cmc_alloc_node *alloc; \ - \ - /* Custom callback functions */ \ - struct cmc_callbacks *callbacks; \ - }; \ - \ - /* Value struct function table */ \ - struct SNAME##_fval \ - { \ - /* Comparator function */ \ - int (*cmp)(V, V); \ - \ - /* Copy function */ \ - V (*cpy)(V); \ - \ - /* To string function */ \ - bool (*str)(FILE *, V); \ - \ - /* Free from memory function */ \ - void (*free)(V); \ - \ - /* Hash function */ \ - size_t (*hash)(V); \ - \ - /* Priority function */ \ - int (*pri)(V, V); \ - }; \ - \ - /* Heap Iterator */ \ - struct SNAME##_iter \ - { \ - /* Target heap */ \ - struct SNAME *target; \ - \ - /* Cursor's position (index) */ \ - size_t cursor; \ - \ - /* If the iterator has reached the start of the iteration */ \ - bool start; \ - \ - /* If the iterator has reached the end of the iteration */ \ - bool end; \ - }; \ - \ - /* Collection Functions */ \ - /* Collection Allocation and Deallocation */ \ - struct SNAME *PFX##_new(size_t capacity, struct SNAME##_fval *f_val); \ - struct SNAME *PFX##_new_custom( \ - size_t capacity, struct SNAME##_fval *f_val, \ - struct cmc_alloc_node *alloc, struct cmc_callbacks *callbacks); \ - void PFX##_clear(struct SNAME *_heap_); \ - void PFX##_free(struct SNAME *_heap_); \ - /* Customization of Allocation and Callbacks */ \ - void PFX##_customize(struct SNAME *_heap_, struct cmc_alloc_node *alloc, \ - struct cmc_callbacks *callbacks); \ - /* Collection Input and Output */ \ - bool PFX##_insert(struct SNAME *_heap_, V value); \ - bool PFX##_remove_max(struct SNAME *_heap_); \ - bool PFX##_remove_min(struct SNAME *_heap_); \ - /* Collection Update */ \ - bool PFX##_update_max(struct SNAME *_heap_, V value); \ - bool PFX##_update_min(struct SNAME *_heap_, V value); \ - /* Element Access */ \ - V PFX##_max(struct SNAME *_heap_); \ - V PFX##_min(struct SNAME *_heap_); \ - /* Collection State */ \ - bool PFX##_contains(struct SNAME *_heap_, V value); \ - bool PFX##_empty(struct SNAME *_heap_); \ - bool PFX##_full(struct SNAME *_heap_); \ - size_t PFX##_count(struct SNAME *_heap_); \ - size_t PFX##_capacity(struct SNAME *_heap_); \ - int PFX##_flag(struct SNAME *_heap_); \ - /* Collection Utility */ \ - bool PFX##_resize(struct SNAME *_heap_, size_t capacity); \ - struct SNAME *PFX##_copy_of(struct SNAME *_set_); \ - bool PFX##_equals(struct SNAME *_heap1_, struct SNAME *_heap2_); \ - struct cmc_string PFX##_to_string(struct SNAME *_heap_); \ - bool PFX##_print(struct SNAME *_heap_, FILE *fptr); \ - \ - /* Iterator Functions */ \ - /* Iterator Initialization */ \ - struct SNAME##_iter PFX##_iter_start(struct SNAME *target); \ - struct SNAME##_iter PFX##_iter_end(struct SNAME *target); \ - /* Iterator State */ \ - bool PFX##_iter_at_start(struct SNAME##_iter *iter); \ - bool PFX##_iter_at_end(struct SNAME##_iter *iter); \ - /* Iterator Movement */ \ - bool PFX##_iter_to_start(struct SNAME##_iter *iter); \ - bool PFX##_iter_to_end(struct SNAME##_iter *iter); \ - bool PFX##_iter_next(struct SNAME##_iter *iter); \ - bool PFX##_iter_prev(struct SNAME##_iter *iter); \ - bool PFX##_iter_advance(struct SNAME##_iter *iter, size_t steps); \ - bool PFX##_iter_rewind(struct SNAME##_iter *iter, size_t steps); \ - bool PFX##_iter_go_to(struct SNAME##_iter *iter, size_t index); \ - /* Iterator Access */ \ - V PFX##_iter_value(struct SNAME##_iter *iter); \ - size_t PFX##_iter_index(struct SNAME##_iter *iter); +#define CMC_CMC_INTERVALHEAP_CORE_HEADER_(PFX, SNAME, V) \ + \ + /* Heap Structure */ \ + struct SNAME \ + { \ + /* Dynamic array of elements */ \ + /* buffer[n][0] is MinHeap and buffer[n][1] is MaxHeap */ \ + V (*buffer)[2]; \ + \ + /* Current array capacity */ \ + size_t capacity; \ + \ + /* Current amount of pairs of values in the array */ \ + size_t size; \ + \ + /* Current amount of elements in the heap */ \ + size_t count; \ + \ + /* Flags indicating errors or success */ \ + int flag; \ + \ + /* Value function table */ \ + struct CMC_DEF_FVAL(SNAME) * f_val; \ + \ + /* Custom allocation functions */ \ + struct cmc_alloc_node *alloc; \ + \ + /* Custom callback functions */ \ + struct cmc_callbacks *callbacks; \ + }; \ + \ + /* Value struct function table */ \ + struct CMC_DEF_FVAL(SNAME) \ + { \ + /* Comparator function */ \ + int (*cmp)(V, V); \ + \ + /* Copy function */ \ + V (*cpy)(V); \ + \ + /* To string function */ \ + bool (*str)(FILE *, V); \ + \ + /* Free from memory function */ \ + void (*free)(V); \ + \ + /* Hash function */ \ + size_t (*hash)(V); \ + \ + /* Priority function */ \ + int (*pri)(V, V); \ + }; \ + \ + /* Heap Iterator */ \ + struct CMC_DEF_ITER(SNAME) \ + { \ + /* Target heap */ \ + struct SNAME *target; \ + \ + /* Cursor's position (index) */ \ + size_t cursor; \ + \ + /* If the iterator has reached the start of the iteration */ \ + bool start; \ + \ + /* If the iterator has reached the end of the iteration */ \ + bool end; \ + }; \ + \ + /* Collection Functions */ \ + /* Collection Allocation and Deallocation */ \ + struct SNAME *CMC_(PFX, _new)(size_t capacity, \ + struct CMC_DEF_FVAL(SNAME) * f_val); \ + struct SNAME *CMC_(PFX, _new_custom)( \ + size_t capacity, struct CMC_DEF_FVAL(SNAME) * f_val, \ + struct cmc_alloc_node * alloc, struct cmc_callbacks * callbacks); \ + void CMC_(PFX, _clear)(struct SNAME * _heap_); \ + void CMC_(PFX, _free)(struct SNAME * _heap_); \ + /* Customization of Allocation and Callbacks */ \ + void CMC_(PFX, _customize)(struct SNAME * _heap_, \ + struct cmc_alloc_node * alloc, \ + struct cmc_callbacks * callbacks); \ + /* Collection Input and Output */ \ + bool CMC_(PFX, _insert)(struct SNAME * _heap_, V value); \ + bool CMC_(PFX, _remove_max)(struct SNAME * _heap_); \ + bool CMC_(PFX, _remove_min)(struct SNAME * _heap_); \ + /* Collection Update */ \ + bool CMC_(PFX, _update_max)(struct SNAME * _heap_, V value); \ + bool CMC_(PFX, _update_min)(struct SNAME * _heap_, V value); \ + /* Element Access */ \ + V CMC_(PFX, _max)(struct SNAME * _heap_); \ + V CMC_(PFX, _min)(struct SNAME * _heap_); \ + /* Collection State */ \ + bool CMC_(PFX, _contains)(struct SNAME * _heap_, V value); \ + bool CMC_(PFX, _empty)(struct SNAME * _heap_); \ + bool CMC_(PFX, _full)(struct SNAME * _heap_); \ + size_t CMC_(PFX, _count)(struct SNAME * _heap_); \ + size_t CMC_(PFX, _capacity)(struct SNAME * _heap_); \ + int CMC_(PFX, _flag)(struct SNAME * _heap_); \ + /* Collection Utility */ \ + bool CMC_(PFX, _resize)(struct SNAME * _heap_, size_t capacity); \ + struct SNAME *CMC_(PFX, _copy_of)(struct SNAME * _set_); \ + bool CMC_(PFX, _equals)(struct SNAME * _heap1_, struct SNAME * _heap2_); \ + struct cmc_string CMC_(PFX, _to_string)(struct SNAME * _heap_); \ + bool CMC_(PFX, _print)(struct SNAME * _heap_, FILE * fptr); \ + \ + /* Iterator Functions */ \ + /* Iterator Initialization */ \ + struct CMC_DEF_ITER(SNAME) CMC_(PFX, _iter_start)(struct SNAME * target); \ + struct CMC_DEF_ITER(SNAME) CMC_(PFX, _iter_end)(struct SNAME * target); \ + /* Iterator State */ \ + bool CMC_(PFX, _iter_at_start)(struct CMC_DEF_ITER(SNAME) * iter); \ + bool CMC_(PFX, _iter_at_end)(struct CMC_DEF_ITER(SNAME) * iter); \ + /* Iterator Movement */ \ + bool CMC_(PFX, _iter_to_start)(struct CMC_DEF_ITER(SNAME) * iter); \ + bool CMC_(PFX, _iter_to_end)(struct CMC_DEF_ITER(SNAME) * iter); \ + bool CMC_(PFX, _iter_next)(struct CMC_DEF_ITER(SNAME) * iter); \ + bool CMC_(PFX, _iter_prev)(struct CMC_DEF_ITER(SNAME) * iter); \ + bool CMC_(PFX, _iter_advance)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t steps); \ + bool CMC_(PFX, _iter_rewind)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t steps); \ + bool CMC_(PFX, _iter_go_to)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t index); \ + /* Iterator Access */ \ + V CMC_(PFX, _iter_value)(struct CMC_DEF_ITER(SNAME) * iter); \ + size_t CMC_(PFX, _iter_index)(struct CMC_DEF_ITER(SNAME) * iter); /* ------------------------------------------------------------------------- * Source * ------------------------------------------------------------------------- */ -#define CMC_GENERATE_INTERVALHEAP_SOURCE(PFX, SNAME, V) \ +#define CMC_CMC_INTERVALHEAP_CORE_SOURCE_(PFX, SNAME, V) \ \ /* Implementation Detail Functions */ \ - static void PFX##_impl_float_up_max(struct SNAME *_heap_); \ - static void PFX##_impl_float_up_min(struct SNAME *_heap_); \ - static void PFX##_impl_float_down_max(struct SNAME *_heap_); \ - static void PFX##_impl_float_down_min(struct SNAME *_heap_); \ + static void CMC_(PFX, _impl_float_up_max)(struct SNAME * _heap_); \ + static void CMC_(PFX, _impl_float_up_min)(struct SNAME * _heap_); \ + static void CMC_(PFX, _impl_float_down_max)(struct SNAME * _heap_); \ + static void CMC_(PFX, _impl_float_down_min)(struct SNAME * _heap_); \ \ - struct SNAME *PFX##_new(size_t capacity, struct SNAME##_fval *f_val) \ + struct SNAME *CMC_(PFX, _new)(size_t capacity, \ + struct CMC_DEF_FVAL(SNAME) * f_val) \ { \ struct cmc_alloc_node *alloc = &cmc_alloc_node_default; \ \ @@ -216,7 +227,7 @@ static const char *cmc_string_fmt_intervalheap = "struct %s<%s> " _heap_->capacity = capacity; \ _heap_->size = 0; \ _heap_->count = 0; \ - _heap_->flag = cmc_flags.OK; \ + _heap_->flag = CMC_FLAG_OK; \ _heap_->f_val = f_val; \ _heap_->alloc = alloc; \ _heap_->callbacks = NULL; \ @@ -224,9 +235,9 @@ static const char *cmc_string_fmt_intervalheap = "struct %s<%s> " return _heap_; \ } \ \ - struct SNAME *PFX##_new_custom( \ - size_t capacity, struct SNAME##_fval *f_val, \ - struct cmc_alloc_node *alloc, struct cmc_callbacks *callbacks) \ + struct SNAME *CMC_(PFX, _new_custom)( \ + size_t capacity, struct CMC_DEF_FVAL(SNAME) * f_val, \ + struct cmc_alloc_node * alloc, struct cmc_callbacks * callbacks) \ { \ if (capacity == 0 || capacity == UINTMAX_MAX) \ return NULL; \ @@ -255,7 +266,7 @@ static const char *cmc_string_fmt_intervalheap = "struct %s<%s> " _heap_->capacity = capacity; \ _heap_->size = 0; \ _heap_->count = 0; \ - _heap_->flag = cmc_flags.OK; \ + _heap_->flag = CMC_FLAG_OK; \ _heap_->f_val = f_val; \ _heap_->alloc = alloc; \ _heap_->callbacks = callbacks; \ @@ -263,7 +274,7 @@ static const char *cmc_string_fmt_intervalheap = "struct %s<%s> " return _heap_; \ } \ \ - void PFX##_clear(struct SNAME *_heap_) \ + void CMC_(PFX, _clear)(struct SNAME * _heap_) \ { \ if (_heap_->f_val->free) \ { \ @@ -277,10 +288,10 @@ static const char *cmc_string_fmt_intervalheap = "struct %s<%s> " \ _heap_->size = 0; \ _heap_->count = 0; \ - _heap_->flag = cmc_flags.OK; \ + _heap_->flag = CMC_FLAG_OK; \ } \ \ - void PFX##_free(struct SNAME *_heap_) \ + void CMC_(PFX, _free)(struct SNAME * _heap_) \ { \ if (_heap_->f_val->free) \ { \ @@ -295,8 +306,9 @@ static const char *cmc_string_fmt_intervalheap = "struct %s<%s> " _heap_->alloc->free(_heap_); \ } \ \ - void PFX##_customize(struct SNAME *_heap_, struct cmc_alloc_node *alloc, \ - struct cmc_callbacks *callbacks) \ + void CMC_(PFX, _customize)(struct SNAME * _heap_, \ + struct cmc_alloc_node * alloc, \ + struct cmc_callbacks * callbacks) \ { \ if (!alloc) \ _heap_->alloc = &cmc_alloc_node_default; \ @@ -305,14 +317,14 @@ static const char *cmc_string_fmt_intervalheap = "struct %s<%s> " \ _heap_->callbacks = callbacks; \ \ - _heap_->flag = cmc_flags.OK; \ + _heap_->flag = CMC_FLAG_OK; \ } \ \ - bool PFX##_insert(struct SNAME *_heap_, V value) \ + bool CMC_(PFX, _insert)(struct SNAME * _heap_, V value) \ { \ - if (PFX##_full(_heap_)) \ + if (CMC_(PFX, _full)(_heap_)) \ { \ - if (!PFX##_resize(_heap_, _heap_->capacity * 4)) \ + if (!CMC_(PFX, _resize)(_heap_, _heap_->capacity * 4)) \ return false; \ } \ \ @@ -343,7 +355,7 @@ static const char *cmc_string_fmt_intervalheap = "struct %s<%s> " } \ \ _heap_->count++; \ - _heap_->flag = cmc_flags.OK; \ + _heap_->flag = CMC_FLAG_OK; \ \ if (_heap_->count > 2) \ { \ @@ -353,9 +365,9 @@ static const char *cmc_string_fmt_intervalheap = "struct %s<%s> " V(*parent)[2] = &(_heap_->buffer[(_heap_->size - 2) / 2]); \ \ if (_heap_->f_val->cmp((*parent)[0], value) > 0) \ - PFX##_impl_float_up_min(_heap_); \ + CMC_(PFX, _impl_float_up_min)(_heap_); \ else if (_heap_->f_val->cmp((*parent)[1], value) < 0) \ - PFX##_impl_float_up_max(_heap_); \ + CMC_(PFX, _impl_float_up_max)(_heap_); \ /* else no float up required */ \ } \ \ @@ -365,11 +377,11 @@ static const char *cmc_string_fmt_intervalheap = "struct %s<%s> " return true; \ } \ \ - bool PFX##_remove_max(struct SNAME *_heap_) \ + bool CMC_(PFX, _remove_max)(struct SNAME * _heap_) \ { \ - if (PFX##_empty(_heap_)) \ + if (CMC_(PFX, _empty)(_heap_)) \ { \ - _heap_->flag = cmc_flags.EMPTY; \ + _heap_->flag = CMC_FLAG_EMPTY; \ return false; \ } \ \ @@ -406,11 +418,11 @@ static const char *cmc_string_fmt_intervalheap = "struct %s<%s> " _heap_->count--; \ \ /* FLoat Down on the MaxHeap */ \ - PFX##_impl_float_down_max(_heap_); \ + CMC_(PFX, _impl_float_down_max)(_heap_); \ \ success: \ \ - _heap_->flag = cmc_flags.OK; \ + _heap_->flag = CMC_FLAG_OK; \ \ if (_heap_->callbacks && _heap_->callbacks->delete) \ _heap_->callbacks->delete (); \ @@ -418,11 +430,11 @@ static const char *cmc_string_fmt_intervalheap = "struct %s<%s> " return true; \ } \ \ - bool PFX##_remove_min(struct SNAME *_heap_) \ + bool CMC_(PFX, _remove_min)(struct SNAME * _heap_) \ { \ - if (PFX##_empty(_heap_)) \ + if (CMC_(PFX, _empty)(_heap_)) \ { \ - _heap_->flag = cmc_flags.EMPTY; \ + _heap_->flag = CMC_FLAG_EMPTY; \ return false; \ } \ \ @@ -459,11 +471,11 @@ static const char *cmc_string_fmt_intervalheap = "struct %s<%s> " _heap_->count--; \ \ /* FLoat Down on the MinHeap */ \ - PFX##_impl_float_down_min(_heap_); \ + CMC_(PFX, _impl_float_down_min)(_heap_); \ \ success: \ \ - _heap_->flag = cmc_flags.OK; \ + _heap_->flag = CMC_FLAG_OK; \ \ if (_heap_->callbacks && _heap_->callbacks->delete) \ _heap_->callbacks->delete (); \ @@ -471,11 +483,11 @@ static const char *cmc_string_fmt_intervalheap = "struct %s<%s> " return true; \ } \ \ - bool PFX##_update_max(struct SNAME *_heap_, V value) \ + bool CMC_(PFX, _update_max)(struct SNAME * _heap_, V value) \ { \ - if (PFX##_empty(_heap_)) \ + if (CMC_(PFX, _empty)(_heap_)) \ { \ - _heap_->flag = cmc_flags.EMPTY; \ + _heap_->flag = CMC_FLAG_EMPTY; \ return false; \ } \ \ @@ -490,17 +502,17 @@ static const char *cmc_string_fmt_intervalheap = "struct %s<%s> " _heap_->buffer[0][1] = _heap_->buffer[0][0]; \ _heap_->buffer[0][0] = value; \ \ - PFX##_impl_float_down_max(_heap_); \ + CMC_(PFX, _impl_float_down_max)(_heap_); \ } \ else \ { \ /* Update Max element and float it down */ \ _heap_->buffer[0][1] = value; \ \ - PFX##_impl_float_down_max(_heap_); \ + CMC_(PFX, _impl_float_down_max)(_heap_); \ } \ \ - _heap_->flag = cmc_flags.OK; \ + _heap_->flag = CMC_FLAG_OK; \ \ if (_heap_->callbacks && _heap_->callbacks->update) \ _heap_->callbacks->update(); \ @@ -508,11 +520,11 @@ static const char *cmc_string_fmt_intervalheap = "struct %s<%s> " return true; \ } \ \ - bool PFX##_update_min(struct SNAME *_heap_, V value) \ + bool CMC_(PFX, _update_min)(struct SNAME * _heap_, V value) \ { \ - if (PFX##_empty(_heap_)) \ + if (CMC_(PFX, _empty)(_heap_)) \ { \ - _heap_->flag = cmc_flags.EMPTY; \ + _heap_->flag = CMC_FLAG_EMPTY; \ return false; \ } \ \ @@ -527,17 +539,17 @@ static const char *cmc_string_fmt_intervalheap = "struct %s<%s> " _heap_->buffer[0][0] = _heap_->buffer[0][1]; \ _heap_->buffer[0][1] = value; \ \ - PFX##_impl_float_down_min(_heap_); \ + CMC_(PFX, _impl_float_down_min)(_heap_); \ } \ else \ { \ /* Update Min element and float it down */ \ _heap_->buffer[0][0] = value; \ \ - PFX##_impl_float_down_min(_heap_); \ + CMC_(PFX, _impl_float_down_min)(_heap_); \ } \ \ - _heap_->flag = cmc_flags.OK; \ + _heap_->flag = CMC_FLAG_OK; \ \ if (_heap_->callbacks && _heap_->callbacks->update) \ _heap_->callbacks->update(); \ @@ -545,15 +557,15 @@ static const char *cmc_string_fmt_intervalheap = "struct %s<%s> " return true; \ } \ \ - V PFX##_max(struct SNAME *_heap_) \ + V CMC_(PFX, _max)(struct SNAME * _heap_) \ { \ - if (PFX##_empty(_heap_)) \ + if (CMC_(PFX, _empty)(_heap_)) \ { \ - _heap_->flag = cmc_flags.EMPTY; \ + _heap_->flag = CMC_FLAG_EMPTY; \ return (V){ 0 }; \ } \ \ - _heap_->flag = cmc_flags.OK; \ + _heap_->flag = CMC_FLAG_OK; \ \ if (_heap_->callbacks && _heap_->callbacks->read) \ _heap_->callbacks->read(); \ @@ -566,15 +578,15 @@ static const char *cmc_string_fmt_intervalheap = "struct %s<%s> " return _heap_->buffer[0][1]; \ } \ \ - V PFX##_min(struct SNAME *_heap_) \ + V CMC_(PFX, _min)(struct SNAME * _heap_) \ { \ - if (PFX##_empty(_heap_)) \ + if (CMC_(PFX, _empty)(_heap_)) \ { \ - _heap_->flag = cmc_flags.EMPTY; \ + _heap_->flag = CMC_FLAG_EMPTY; \ return (V){ 0 }; \ } \ \ - _heap_->flag = cmc_flags.OK; \ + _heap_->flag = CMC_FLAG_OK; \ \ if (_heap_->callbacks && _heap_->callbacks->read) \ _heap_->callbacks->read(); \ @@ -582,9 +594,9 @@ static const char *cmc_string_fmt_intervalheap = "struct %s<%s> " return _heap_->buffer[0][0]; \ } \ \ - bool PFX##_contains(struct SNAME *_heap_, V value) \ + bool CMC_(PFX, _contains)(struct SNAME * _heap_, V value) \ { \ - _heap_->flag = cmc_flags.OK; \ + _heap_->flag = CMC_FLAG_OK; \ \ bool result = false; \ \ @@ -603,47 +615,47 @@ static const char *cmc_string_fmt_intervalheap = "struct %s<%s> " return result; \ } \ \ - bool PFX##_empty(struct SNAME *_heap_) \ + bool CMC_(PFX, _empty)(struct SNAME * _heap_) \ { \ return _heap_->count == 0; \ } \ \ - bool PFX##_full(struct SNAME *_heap_) \ + bool CMC_(PFX, _full)(struct SNAME * _heap_) \ { \ /* The heap is full if all nodes are completely filled */ \ return _heap_->size >= _heap_->capacity && _heap_->count % 2 == 0; \ } \ \ - size_t PFX##_count(struct SNAME *_heap_) \ + size_t CMC_(PFX, _count)(struct SNAME * _heap_) \ { \ return _heap_->count; \ } \ \ - size_t PFX##_capacity(struct SNAME *_heap_) \ + size_t CMC_(PFX, _capacity)(struct SNAME * _heap_) \ { \ return _heap_->capacity; \ } \ \ - int PFX##_flag(struct SNAME *_heap_) \ + int CMC_(PFX, _flag)(struct SNAME * _heap_) \ { \ return _heap_->flag; \ } \ \ - bool PFX##_resize(struct SNAME *_heap_, size_t capacity) \ + bool CMC_(PFX, _resize)(struct SNAME * _heap_, size_t capacity) \ { \ if (_heap_->capacity == capacity) \ goto success; \ \ if (capacity < _heap_->count) \ { \ - _heap_->flag = cmc_flags.INVALID; \ + _heap_->flag = CMC_FLAG_INVALID; \ return false; \ } \ \ /* Prevent overflow */ \ if (capacity == UINTMAX_MAX) \ { \ - _heap_->flag = cmc_flags.ERROR; \ + _heap_->flag = CMC_FLAG_ERROR; \ return false; \ } \ \ @@ -654,7 +666,7 @@ static const char *cmc_string_fmt_intervalheap = "struct %s<%s> " \ if (!new_buffer) \ { \ - _heap_->flag = cmc_flags.ALLOC; \ + _heap_->flag = CMC_FLAG_ALLOC; \ return false; \ } \ \ @@ -669,7 +681,7 @@ static const char *cmc_string_fmt_intervalheap = "struct %s<%s> " \ success: \ \ - _heap_->flag = cmc_flags.OK; \ + _heap_->flag = CMC_FLAG_OK; \ \ if (_heap_->callbacks && _heap_->callbacks->resize) \ _heap_->callbacks->resize(); \ @@ -677,13 +689,13 @@ static const char *cmc_string_fmt_intervalheap = "struct %s<%s> " return true; \ } \ \ - struct SNAME *PFX##_copy_of(struct SNAME *_heap_) \ + struct SNAME *CMC_(PFX, _copy_of)(struct SNAME * _heap_) \ { \ struct SNAME *result = _heap_->alloc->malloc(sizeof(struct SNAME)); \ \ if (!result) \ { \ - _heap_->flag = cmc_flags.ALLOC; \ + _heap_->flag = CMC_FLAG_ALLOC; \ return NULL; \ } \ \ @@ -695,7 +707,7 @@ static const char *cmc_string_fmt_intervalheap = "struct %s<%s> " if (!result->buffer) \ { \ _heap_->alloc->free(result); \ - _heap_->flag = cmc_flags.ALLOC; \ + _heap_->flag = CMC_FLAG_ALLOC; \ return NULL; \ } \ \ @@ -712,20 +724,20 @@ static const char *cmc_string_fmt_intervalheap = "struct %s<%s> " result->capacity = _heap_->capacity; \ result->size = _heap_->size; \ result->count = _heap_->count; \ - result->flag = cmc_flags.OK; \ + result->flag = CMC_FLAG_OK; \ result->f_val = _heap_->f_val; \ result->alloc = _heap_->alloc; \ result->callbacks = _heap_->callbacks; \ \ - _heap_->flag = cmc_flags.OK; \ + _heap_->flag = CMC_FLAG_OK; \ \ return result; \ } \ \ - bool PFX##_equals(struct SNAME *_heap1_, struct SNAME *_heap2_) \ + bool CMC_(PFX, _equals)(struct SNAME * _heap1_, struct SNAME * _heap2_) \ { \ - _heap1_->flag = cmc_flags.OK; \ - _heap2_->flag = cmc_flags.OK; \ + _heap1_->flag = CMC_FLAG_OK; \ + _heap2_->flag = CMC_FLAG_OK; \ \ if (_heap1_->count != _heap2_->count) \ return false; \ @@ -742,20 +754,20 @@ static const char *cmc_string_fmt_intervalheap = "struct %s<%s> " return true; \ } \ \ - struct cmc_string PFX##_to_string(struct SNAME *_heap_) \ + struct cmc_string CMC_(PFX, _to_string)(struct SNAME * _heap_) \ { \ struct cmc_string str; \ struct SNAME *h_ = _heap_; \ \ - int n = snprintf(str.s, cmc_string_len, cmc_string_fmt_intervalheap, \ - #SNAME, #V, h_, h_->buffer, h_->capacity, h_->size, \ - h_->count, h_->flag, h_->f_val, h_->alloc, \ - h_->callbacks); \ + int n = snprintf(str.s, cmc_string_len, \ + cmc_cmc_string_fmt_intervalheap, #SNAME, #V, h_, \ + h_->buffer, h_->capacity, h_->size, h_->count, \ + h_->flag, h_->f_val, h_->alloc, h_->callbacks); \ \ return n >= 0 ? str : (struct cmc_string){ 0 }; \ } \ \ - bool PFX##_print(struct SNAME *_heap_, FILE *fptr) \ + bool CMC_(PFX, _print)(struct SNAME * _heap_, FILE * fptr) \ { \ for (size_t i = 0; i < _heap_->count; i++) \ { \ @@ -766,50 +778,50 @@ static const char *cmc_string_fmt_intervalheap = "struct %s<%s> " return true; \ } \ \ - struct SNAME##_iter PFX##_iter_start(struct SNAME *target) \ + struct CMC_DEF_ITER(SNAME) CMC_(PFX, _iter_start)(struct SNAME * target) \ { \ - struct SNAME##_iter iter; \ + struct CMC_DEF_ITER(SNAME) iter; \ \ iter.target = target; \ iter.cursor = 0; \ iter.start = true; \ - iter.end = PFX##_empty(target); \ + iter.end = CMC_(PFX, _empty)(target); \ \ return iter; \ } \ \ - struct SNAME##_iter PFX##_iter_end(struct SNAME *target) \ + struct CMC_DEF_ITER(SNAME) CMC_(PFX, _iter_end)(struct SNAME * target) \ { \ - struct SNAME##_iter iter; \ + struct CMC_DEF_ITER(SNAME) iter; \ \ iter.target = target; \ iter.cursor = 0; \ - iter.start = PFX##_empty(target); \ + iter.start = CMC_(PFX, _empty)(target); \ iter.end = true; \ \ - if (!PFX##_empty(target)) \ + if (!CMC_(PFX, _empty)(target)) \ iter.cursor = target->count - 1; \ \ return iter; \ } \ \ - bool PFX##_iter_at_start(struct SNAME##_iter *iter) \ + bool CMC_(PFX, _iter_at_start)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ - return PFX##_empty(iter->target) || iter->start; \ + return CMC_(PFX, _empty)(iter->target) || iter->start; \ } \ \ - bool PFX##_iter_at_end(struct SNAME##_iter *iter) \ + bool CMC_(PFX, _iter_at_end)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ - return PFX##_empty(iter->target) || iter->end; \ + return CMC_(PFX, _empty)(iter->target) || iter->end; \ } \ \ - bool PFX##_iter_to_start(struct SNAME##_iter *iter) \ + bool CMC_(PFX, _iter_to_start)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ - if (!PFX##_empty(iter->target)) \ + if (!CMC_(PFX, _empty)(iter->target)) \ { \ iter->cursor = 0; \ iter->start = true; \ - iter->end = PFX##_empty(iter->target); \ + iter->end = CMC_(PFX, _empty)(iter->target); \ \ return true; \ } \ @@ -817,12 +829,12 @@ static const char *cmc_string_fmt_intervalheap = "struct %s<%s> " return false; \ } \ \ - bool PFX##_iter_to_end(struct SNAME##_iter *iter) \ + bool CMC_(PFX, _iter_to_end)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ - if (!PFX##_empty(iter->target)) \ + if (!CMC_(PFX, _empty)(iter->target)) \ { \ iter->cursor = iter->target->count - 1; \ - iter->start = PFX##_empty(iter->target); \ + iter->start = CMC_(PFX, _empty)(iter->target); \ iter->end = true; \ \ return true; \ @@ -831,7 +843,7 @@ static const char *cmc_string_fmt_intervalheap = "struct %s<%s> " return false; \ } \ \ - bool PFX##_iter_next(struct SNAME##_iter *iter) \ + bool CMC_(PFX, _iter_next)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ if (iter->end) \ return false; \ @@ -842,14 +854,14 @@ static const char *cmc_string_fmt_intervalheap = "struct %s<%s> " return false; \ } \ \ - iter->start = PFX##_empty(iter->target); \ + iter->start = CMC_(PFX, _empty)(iter->target); \ \ iter->cursor++; \ \ return true; \ } \ \ - bool PFX##_iter_prev(struct SNAME##_iter *iter) \ + bool CMC_(PFX, _iter_prev)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ if (iter->start) \ return false; \ @@ -860,7 +872,7 @@ static const char *cmc_string_fmt_intervalheap = "struct %s<%s> " return false; \ } \ \ - iter->end = PFX##_empty(iter->target); \ + iter->end = CMC_(PFX, _empty)(iter->target); \ \ iter->cursor--; \ \ @@ -868,7 +880,8 @@ static const char *cmc_string_fmt_intervalheap = "struct %s<%s> " } \ \ /* Returns true only if the iterator moved */ \ - bool PFX##_iter_advance(struct SNAME##_iter *iter, size_t steps) \ + bool CMC_(PFX, _iter_advance)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t steps) \ { \ if (iter->end) \ return false; \ @@ -885,7 +898,7 @@ static const char *cmc_string_fmt_intervalheap = "struct %s<%s> " if (iter->end) \ return false; \ \ - iter->start = PFX##_empty(iter->target); \ + iter->start = CMC_(PFX, _empty)(iter->target); \ \ iter->cursor += steps; \ \ @@ -893,7 +906,8 @@ static const char *cmc_string_fmt_intervalheap = "struct %s<%s> " } \ \ /* Returns true only if the iterator moved */ \ - bool PFX##_iter_rewind(struct SNAME##_iter *iter, size_t steps) \ + bool CMC_(PFX, _iter_rewind)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t steps) \ { \ if (iter->start) \ return false; \ @@ -907,7 +921,7 @@ static const char *cmc_string_fmt_intervalheap = "struct %s<%s> " if (steps == 0 || iter->cursor < steps) \ return false; \ \ - iter->end = PFX##_empty(iter->target); \ + iter->end = CMC_(PFX, _empty)(iter->target); \ \ iter->cursor -= steps; \ \ @@ -916,33 +930,34 @@ static const char *cmc_string_fmt_intervalheap = "struct %s<%s> " \ /* Returns true only if the iterator was able to be positioned at the */ \ /* given index */ \ - bool PFX##_iter_go_to(struct SNAME##_iter *iter, size_t index) \ + bool CMC_(PFX, _iter_go_to)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t index) \ { \ if (index >= iter->target->count) \ return false; \ \ if (iter->cursor > index) \ - return PFX##_iter_rewind(iter, iter->cursor - index); \ + return CMC_(PFX, _iter_rewind)(iter, iter->cursor - index); \ else if (iter->cursor < index) \ - return PFX##_iter_advance(iter, index - iter->cursor); \ + return CMC_(PFX, _iter_advance)(iter, index - iter->cursor); \ \ return true; \ } \ \ - V PFX##_iter_value(struct SNAME##_iter *iter) \ + V CMC_(PFX, _iter_value)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ - if (PFX##_empty(iter->target)) \ + if (CMC_(PFX, _empty)(iter->target)) \ return (V){ 0 }; \ \ return iter->target->buffer[iter->cursor / 2][iter->cursor % 2]; \ } \ \ - size_t PFX##_iter_index(struct SNAME##_iter *iter) \ + size_t CMC_(PFX, _iter_index)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ return iter->cursor; \ } \ \ - static void PFX##_impl_float_up_max(struct SNAME *_heap_) \ + static void CMC_(PFX, _impl_float_up_max)(struct SNAME * _heap_) \ { \ size_t index = _heap_->size - 1; \ \ @@ -989,7 +1004,7 @@ static const char *cmc_string_fmt_intervalheap = "struct %s<%s> " } \ } \ \ - static void PFX##_impl_float_up_min(struct SNAME *_heap_) \ + static void CMC_(PFX, _impl_float_up_min)(struct SNAME * _heap_) \ { \ size_t index = _heap_->size - 1; \ \ @@ -1017,7 +1032,7 @@ static const char *cmc_string_fmt_intervalheap = "struct %s<%s> " } \ } \ \ - static void PFX##_impl_float_down_max(struct SNAME *_heap_) \ + static void CMC_(PFX, _impl_float_down_max)(struct SNAME * _heap_) \ { \ /* Floats Down from the MinHeap */ \ size_t index = 0; \ @@ -1107,7 +1122,7 @@ static const char *cmc_string_fmt_intervalheap = "struct %s<%s> " } \ } \ \ - static void PFX##_impl_float_down_min(struct SNAME *_heap_) \ + static void CMC_(PFX, _impl_float_down_min)(struct SNAME * _heap_) \ { \ /* Floats Down from the MinHeap */ \ size_t index = 0; \ @@ -1171,4 +1186,4 @@ static const char *cmc_string_fmt_intervalheap = "struct %s<%s> " } \ } -#endif /* CMC_INTERVALHEAP_H */ +#endif /* CMC_CMC_INTERVALHEAP_H */ diff --git a/src/cmc/linkedlist.h b/src/cmc/linkedlist.h index 02d93fc..a5eb3a3 100644 --- a/src/cmc/linkedlist.h +++ b/src/cmc/linkedlist.h @@ -25,8 +25,8 @@ * and tail points to the last. */ -#ifndef CMC_LINKEDLIST_H -#define CMC_LINKEDLIST_H +#ifndef CMC_CMC_LINKEDLIST_H +#define CMC_CMC_LINKEDLIST_H /* ------------------------------------------------------------------------- * Core functionalities of the C Macro Collections Library @@ -37,194 +37,212 @@ * LinkedList specific * ------------------------------------------------------------------------- */ /* to_string format */ -static const char *cmc_string_fmt_linkedlist = "struct %s<%s> " - "at %p { " - "count:%" PRIuMAX ", " - "head:%p, " - "tail:%p, " - "flag:%d, " - "f_val:%p, " - "alloc:%p, " - "callbacks:%p }"; +static const char *cmc_cmc_string_fmt_linkedlist = "struct %s<%s> " + "at %p { " + "count:%" PRIuMAX ", " + "head:%p, " + "tail:%p, " + "flag:%d, " + "f_val:%p, " + "alloc:%p, " + "callbacks:%p }"; -#define CMC_GENERATE_LINKEDLIST(PFX, SNAME, V) \ - CMC_GENERATE_LINKEDLIST_HEADER(PFX, SNAME, V) \ - CMC_GENERATE_LINKEDLIST_SOURCE(PFX, SNAME, V) +/** + * Core LinkedList implementation + */ +#define CMC_CMC_LINKEDLIST_CORE(BODY) \ + CMC_CMC_LINKEDLIST_CORE_HEADER(BODY) \ + CMC_CMC_LINKEDLIST_CORE_SOURCE(BODY) -#define CMC_WRAPGEN_LINKEDLIST_HEADER(PFX, SNAME, K, V) \ - CMC_GENERATE_LINKEDLIST_HEADER(PFX, SNAME, V) +#define CMC_CMC_LINKEDLIST_CORE_HEADER(BODY) \ + CMC_CMC_LINKEDLIST_CORE_HEADER_(CMC_PARAM_PFX(BODY), \ + CMC_PARAM_SNAME(BODY), CMC_PARAM_V(BODY)) -#define CMC_WRAPGEN_LINKEDLIST_SOURCE(PFX, SNAME, K, V) \ - CMC_GENERATE_LINKEDLIST_SOURCE(PFX, SNAME, V) +#define CMC_CMC_LINKEDLIST_CORE_SOURCE(BODY) \ + CMC_CMC_LINKEDLIST_CORE_SOURCE_(CMC_PARAM_PFX(BODY), \ + CMC_PARAM_SNAME(BODY), CMC_PARAM_V(BODY)) /* ------------------------------------------------------------------------- * Header * ------------------------------------------------------------------------- */ -#define CMC_GENERATE_LINKEDLIST_HEADER(PFX, SNAME, V) \ - \ - /* Linked List Structure */ \ - struct SNAME \ - { \ - /* First node in the list */ \ - struct SNAME##_node *head; \ - \ - /* Last node in the list */ \ - struct SNAME##_node *tail; \ - \ - /* Current amount of elements in the list */ \ - size_t count; \ - \ - /* Flags indicating errors or success */ \ - int flag; \ - \ - /* Value function table */ \ - struct SNAME##_fval *f_val; \ - \ - /* Custom allocation functions */ \ - struct cmc_alloc_node *alloc; \ - \ - /* Custom callback functions */ \ - struct cmc_callbacks *callbacks; \ - }; \ - \ - /* Doubly-linked list node */ \ - struct SNAME##_node \ - { \ - /* Node's value */ \ - V value; \ - \ - /* Pointer to the next node on the linked list */ \ - struct SNAME##_node *next; \ - \ - /* Pointer to the previous node on the linked list */ \ - struct SNAME##_node *prev; \ - }; \ - \ - /* Value struct function table */ \ - struct SNAME##_fval \ - { \ - /* Comparator function */ \ - int (*cmp)(V, V); \ - \ - /* Copy function */ \ - V (*cpy)(V); \ - \ - /* To string function */ \ - bool (*str)(FILE *, V); \ - \ - /* Free from memory function */ \ - void (*free)(V); \ - \ - /* Hash function */ \ - size_t (*hash)(V); \ - \ - /* Priority function */ \ - int (*pri)(V, V); \ - }; \ - \ - /* Linked List Iterator */ \ - struct SNAME##_iter \ - { \ - /* Target Linked List */ \ - struct SNAME *target; \ - \ - /* Cursor's current node */ \ - struct SNAME##_node *cursor; \ - \ - /* Keeps track of relative index to the iteration of elements */ \ - size_t index; \ - \ - /* If the iterator has reached the start of the iteration */ \ - bool start; \ - \ - /* If the iterator has reached the end of the iteration */ \ - bool end; \ - }; \ - \ - /* Collection Functions */ \ - /* Collection Allocation and Deallocation */ \ - struct SNAME *PFX##_new(struct SNAME##_fval *f_val); \ - struct SNAME *PFX##_new_custom(struct SNAME##_fval *f_val, \ - struct cmc_alloc_node *alloc, \ - struct cmc_callbacks *callbacks); \ - void PFX##_clear(struct SNAME *_list_); \ - void PFX##_free(struct SNAME *_list_); \ - /* Customization of Allocation and Callbacks */ \ - void PFX##_customize(struct SNAME *_list_, struct cmc_alloc_node *alloc, \ - struct cmc_callbacks *callbacks); \ - /* Collection Input and Output */ \ - bool PFX##_push_front(struct SNAME *_list_, V value); \ - bool PFX##_push_at(struct SNAME *_list_, V value, size_t index); \ - bool PFX##_push_back(struct SNAME *_list_, V value); \ - bool PFX##_pop_front(struct SNAME *_list_); \ - bool PFX##_pop_at(struct SNAME *_list_, size_t index); \ - bool PFX##_pop_back(struct SNAME *_list_); \ - /* Element Access */ \ - V PFX##_front(struct SNAME *_list_); \ - V PFX##_get(struct SNAME *_list_, size_t index); \ - V *PFX##_get_ref(struct SNAME *_list_, size_t index); \ - V PFX##_back(struct SNAME *_list_); \ - /* Collection State */ \ - bool PFX##_contains(struct SNAME *_list_, V value); \ - bool PFX##_empty(struct SNAME *_list_); \ - size_t PFX##_count(struct SNAME *_list_); \ - int PFX##_flag(struct SNAME *_list_); \ - /* Collection Utility */ \ - struct SNAME *PFX##_copy_of(struct SNAME *_list_); \ - bool PFX##_equals(struct SNAME *_list1_, struct SNAME *_list2_); \ - struct cmc_string PFX##_to_string(struct SNAME *_list_); \ - bool PFX##_print(struct SNAME *_list_, FILE *fptr); \ - \ - /* Node Related Functions */ \ - /* Node Allocation and Deallocation */ \ - struct SNAME##_node *PFX##_new_node(struct SNAME *_list_, V value); \ - void PFX##_free_node(struct SNAME *_list_, struct SNAME##_node *_node_); \ - /* Node Access Relative to a Linked List */ \ - struct SNAME##_node *PFX##_head(struct SNAME *_list_); \ - struct SNAME##_node *PFX##_get_node(struct SNAME *_list_, size_t index); \ - struct SNAME##_node *PFX##_tail(struct SNAME *_list_); \ - /* Input and Output Relative to a Node */ \ - bool PFX##_add_next(struct SNAME *_owner_, struct SNAME##_node *_node_, \ - V value); \ - bool PFX##_add_prev(struct SNAME *_owner_, struct SNAME##_node *_node_, \ - V value); \ - bool PFX##_del_next(struct SNAME *_owner_, struct SNAME##_node *_node_); \ - bool PFX##_del_curr(struct SNAME *_owner_, struct SNAME##_node *_node_); \ - bool PFX##_del_prev(struct SNAME *_owner_, struct SNAME##_node *_node_); \ - /* Node Access Relative to a Linked List Node */ \ - struct SNAME##_node *PFX##_next_node(struct SNAME##_node *_node_); \ - struct SNAME##_node *PFX##_prev_node(struct SNAME##_node *_node_); \ - \ - /* Iterator Functions */ \ - /* Iterator Initialization */ \ - struct SNAME##_iter PFX##_iter_start(struct SNAME *target); \ - struct SNAME##_iter PFX##_iter_end(struct SNAME *target); \ - /* Iterator State */ \ - bool PFX##_iter_at_start(struct SNAME##_iter *iter); \ - bool PFX##_iter_at_end(struct SNAME##_iter *iter); \ - /* Iterator Movement */ \ - bool PFX##_iter_to_start(struct SNAME##_iter *iter); \ - bool PFX##_iter_to_end(struct SNAME##_iter *iter); \ - bool PFX##_iter_next(struct SNAME##_iter *iter); \ - bool PFX##_iter_prev(struct SNAME##_iter *iter); \ - bool PFX##_iter_advance(struct SNAME##_iter *iter, size_t steps); \ - bool PFX##_iter_rewind(struct SNAME##_iter *iter, size_t steps); \ - bool PFX##_iter_go_to(struct SNAME##_iter *iter, size_t index); \ - /* Iterator Access */ \ - V PFX##_iter_value(struct SNAME##_iter *iter); \ - V *PFX##_iter_rvalue(struct SNAME##_iter *iter); \ - size_t PFX##_iter_index(struct SNAME##_iter *iter); \ - struct SNAME##_node *PFX##_iter_node(struct SNAME##_iter *iter); +#define CMC_CMC_LINKEDLIST_CORE_HEADER_(PFX, SNAME, V) \ + \ + /* Linked List Structure */ \ + struct SNAME \ + { \ + /* First node in the list */ \ + struct CMC_DEF_NODE(SNAME) * head; \ + \ + /* Last node in the list */ \ + struct CMC_DEF_NODE(SNAME) * tail; \ + \ + /* Current amount of elements in the list */ \ + size_t count; \ + \ + /* Flags indicating errors or success */ \ + int flag; \ + \ + /* Value function table */ \ + struct CMC_DEF_FVAL(SNAME) * f_val; \ + \ + /* Custom allocation functions */ \ + struct cmc_alloc_node *alloc; \ + \ + /* Custom callback functions */ \ + struct cmc_callbacks *callbacks; \ + }; \ + \ + /* Doubly-linked list node */ \ + struct CMC_DEF_NODE(SNAME) \ + { \ + /* Node's value */ \ + V value; \ + \ + /* Pointer to the next node on the linked list */ \ + struct CMC_DEF_NODE(SNAME) * next; \ + \ + /* Pointer to the previous node on the linked list */ \ + struct CMC_DEF_NODE(SNAME) * prev; \ + }; \ + \ + /* Value struct function table */ \ + struct CMC_DEF_FVAL(SNAME) \ + { \ + /* Comparator function */ \ + int (*cmp)(V, V); \ + \ + /* Copy function */ \ + V (*cpy)(V); \ + \ + /* To string function */ \ + bool (*str)(FILE *, V); \ + \ + /* Free from memory function */ \ + void (*free)(V); \ + \ + /* Hash function */ \ + size_t (*hash)(V); \ + \ + /* Priority function */ \ + int (*pri)(V, V); \ + }; \ + \ + /* Linked List Iterator */ \ + struct CMC_DEF_ITER(SNAME) \ + { \ + /* Target Linked List */ \ + struct SNAME *target; \ + \ + /* Cursor's current node */ \ + struct CMC_DEF_NODE(SNAME) * cursor; \ + \ + /* Keeps track of relative index to the iteration of elements */ \ + size_t index; \ + \ + /* If the iterator has reached the start of the iteration */ \ + bool start; \ + \ + /* If the iterator has reached the end of the iteration */ \ + bool end; \ + }; \ + \ + /* Collection Functions */ \ + /* Collection Allocation and Deallocation */ \ + struct SNAME *CMC_(PFX, _new)(struct CMC_DEF_FVAL(SNAME) * f_val); \ + struct SNAME *CMC_(PFX, _new_custom)(struct CMC_DEF_FVAL(SNAME) * f_val, \ + struct cmc_alloc_node * alloc, \ + struct cmc_callbacks * callbacks); \ + void CMC_(PFX, _clear)(struct SNAME * _list_); \ + void CMC_(PFX, _free)(struct SNAME * _list_); \ + /* Customization of Allocation and Callbacks */ \ + void CMC_(PFX, _customize)(struct SNAME * _list_, \ + struct cmc_alloc_node * alloc, \ + struct cmc_callbacks * callbacks); \ + /* Collection Input and Output */ \ + bool CMC_(PFX, _push_front)(struct SNAME * _list_, V value); \ + bool CMC_(PFX, _push_at)(struct SNAME * _list_, V value, size_t index); \ + bool CMC_(PFX, _push_back)(struct SNAME * _list_, V value); \ + bool CMC_(PFX, _pop_front)(struct SNAME * _list_); \ + bool CMC_(PFX, _pop_at)(struct SNAME * _list_, size_t index); \ + bool CMC_(PFX, _pop_back)(struct SNAME * _list_); \ + /* Element Access */ \ + V CMC_(PFX, _front)(struct SNAME * _list_); \ + V CMC_(PFX, _get)(struct SNAME * _list_, size_t index); \ + V *CMC_(PFX, _get_ref)(struct SNAME * _list_, size_t index); \ + V CMC_(PFX, _back)(struct SNAME * _list_); \ + /* Collection State */ \ + bool CMC_(PFX, _contains)(struct SNAME * _list_, V value); \ + bool CMC_(PFX, _empty)(struct SNAME * _list_); \ + size_t CMC_(PFX, _count)(struct SNAME * _list_); \ + int CMC_(PFX, _flag)(struct SNAME * _list_); \ + /* Collection Utility */ \ + struct SNAME *CMC_(PFX, _copy_of)(struct SNAME * _list_); \ + bool CMC_(PFX, _equals)(struct SNAME * _list1_, struct SNAME * _list2_); \ + struct cmc_string CMC_(PFX, _to_string)(struct SNAME * _list_); \ + bool CMC_(PFX, _print)(struct SNAME * _list_, FILE * fptr); \ + \ + /* Node Related Functions */ \ + /* Node Allocation and Deallocation */ \ + struct CMC_DEF_NODE(SNAME) * \ + CMC_(PFX, _new_node)(struct SNAME * _list_, V value); \ + void CMC_(PFX, _free_node)(struct SNAME * _list_, \ + struct CMC_DEF_NODE(SNAME) * _node_); \ + /* Node Access Relative to a Linked List */ \ + struct CMC_DEF_NODE(SNAME) * CMC_(PFX, _head)(struct SNAME * _list_); \ + struct CMC_DEF_NODE(SNAME) * \ + CMC_(PFX, _get_node)(struct SNAME * _list_, size_t index); \ + struct CMC_DEF_NODE(SNAME) * CMC_(PFX, _tail)(struct SNAME * _list_); \ + /* Input and Output Relative to a Node */ \ + bool CMC_(PFX, _add_next)(struct SNAME * _owner_, \ + struct CMC_DEF_NODE(SNAME) * _node_, V value); \ + bool CMC_(PFX, _add_prev)(struct SNAME * _owner_, \ + struct CMC_DEF_NODE(SNAME) * _node_, V value); \ + bool CMC_(PFX, _del_next)(struct SNAME * _owner_, \ + struct CMC_DEF_NODE(SNAME) * _node_); \ + bool CMC_(PFX, _del_curr)(struct SNAME * _owner_, \ + struct CMC_DEF_NODE(SNAME) * _node_); \ + bool CMC_(PFX, _del_prev)(struct SNAME * _owner_, \ + struct CMC_DEF_NODE(SNAME) * _node_); \ + /* Node Access Relative to a Linked List Node */ \ + struct CMC_DEF_NODE(SNAME) * \ + CMC_(PFX, _next_node)(struct CMC_DEF_NODE(SNAME) * _node_); \ + struct CMC_DEF_NODE(SNAME) * \ + CMC_(PFX, _prev_node)(struct CMC_DEF_NODE(SNAME) * _node_); \ + \ + /* Iterator Functions */ \ + /* Iterator Initialization */ \ + struct CMC_DEF_ITER(SNAME) CMC_(PFX, _iter_start)(struct SNAME * target); \ + struct CMC_DEF_ITER(SNAME) CMC_(PFX, _iter_end)(struct SNAME * target); \ + /* Iterator State */ \ + bool CMC_(PFX, _iter_at_start)(struct CMC_DEF_ITER(SNAME) * iter); \ + bool CMC_(PFX, _iter_at_end)(struct CMC_DEF_ITER(SNAME) * iter); \ + /* Iterator Movement */ \ + bool CMC_(PFX, _iter_to_start)(struct CMC_DEF_ITER(SNAME) * iter); \ + bool CMC_(PFX, _iter_to_end)(struct CMC_DEF_ITER(SNAME) * iter); \ + bool CMC_(PFX, _iter_next)(struct CMC_DEF_ITER(SNAME) * iter); \ + bool CMC_(PFX, _iter_prev)(struct CMC_DEF_ITER(SNAME) * iter); \ + bool CMC_(PFX, _iter_advance)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t steps); \ + bool CMC_(PFX, _iter_rewind)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t steps); \ + bool CMC_(PFX, _iter_go_to)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t index); \ + /* Iterator Access */ \ + V CMC_(PFX, _iter_value)(struct CMC_DEF_ITER(SNAME) * iter); \ + V *CMC_(PFX, _iter_rvalue)(struct CMC_DEF_ITER(SNAME) * iter); \ + size_t CMC_(PFX, _iter_index)(struct CMC_DEF_ITER(SNAME) * iter); \ + struct CMC_DEF_NODE(SNAME) * \ + CMC_(PFX, _iter_node)(struct CMC_DEF_ITER(SNAME) * iter); /* ------------------------------------------------------------------------- * Source * ------------------------------------------------------------------------- */ -#define CMC_GENERATE_LINKEDLIST_SOURCE(PFX, SNAME, V) \ +#define CMC_CMC_LINKEDLIST_CORE_SOURCE_(PFX, SNAME, V) \ \ /* Implementation Detail Functions */ \ /* None */ \ \ - struct SNAME *PFX##_new(struct SNAME##_fval *f_val) \ + struct SNAME *CMC_(PFX, _new)(struct CMC_DEF_FVAL(SNAME) * f_val) \ { \ if (!f_val) \ return NULL; \ @@ -239,7 +257,7 @@ static const char *cmc_string_fmt_linkedlist = "struct %s<%s> " _list_->count = 0; \ _list_->head = NULL; \ _list_->tail = NULL; \ - _list_->flag = cmc_flags.OK; \ + _list_->flag = CMC_FLAG_OK; \ _list_->f_val = f_val; \ _list_->alloc = alloc; \ _list_->callbacks = NULL; \ @@ -247,9 +265,9 @@ static const char *cmc_string_fmt_linkedlist = "struct %s<%s> " return _list_; \ } \ \ - struct SNAME *PFX##_new_custom(struct SNAME##_fval *f_val, \ - struct cmc_alloc_node *alloc, \ - struct cmc_callbacks *callbacks) \ + struct SNAME *CMC_(PFX, _new_custom)(struct CMC_DEF_FVAL(SNAME) * f_val, \ + struct cmc_alloc_node * alloc, \ + struct cmc_callbacks * callbacks) \ { \ if (!f_val) \ return NULL; \ @@ -265,7 +283,7 @@ static const char *cmc_string_fmt_linkedlist = "struct %s<%s> " _list_->count = 0; \ _list_->head = NULL; \ _list_->tail = NULL; \ - _list_->flag = cmc_flags.OK; \ + _list_->flag = CMC_FLAG_OK; \ _list_->f_val = f_val; \ _list_->alloc = alloc; \ _list_->callbacks = callbacks; \ @@ -273,9 +291,9 @@ static const char *cmc_string_fmt_linkedlist = "struct %s<%s> " return _list_; \ } \ \ - void PFX##_clear(struct SNAME *_list_) \ + void CMC_(PFX, _clear)(struct SNAME * _list_) \ { \ - struct SNAME##_node *scan = _list_->head; \ + struct CMC_DEF_NODE(SNAME) *scan = _list_->head; \ \ while (_list_->head != NULL) \ { \ @@ -294,18 +312,19 @@ static const char *cmc_string_fmt_linkedlist = "struct %s<%s> " _list_->count = 0; \ _list_->head = NULL; \ _list_->tail = NULL; \ - _list_->flag = cmc_flags.OK; \ + _list_->flag = CMC_FLAG_OK; \ } \ \ - void PFX##_free(struct SNAME *_list_) \ + void CMC_(PFX, _free)(struct SNAME * _list_) \ { \ - PFX##_clear(_list_); \ + CMC_(PFX, _clear)(_list_); \ \ _list_->alloc->free(_list_); \ } \ \ - void PFX##_customize(struct SNAME *_list_, struct cmc_alloc_node *alloc, \ - struct cmc_callbacks *callbacks) \ + void CMC_(PFX, _customize)(struct SNAME * _list_, \ + struct cmc_alloc_node * alloc, \ + struct cmc_callbacks * callbacks) \ { \ if (!alloc) \ _list_->alloc = &cmc_alloc_node_default; \ @@ -314,17 +333,18 @@ static const char *cmc_string_fmt_linkedlist = "struct %s<%s> " \ _list_->callbacks = callbacks; \ \ - _list_->flag = cmc_flags.OK; \ + _list_->flag = CMC_FLAG_OK; \ } \ \ - bool PFX##_push_front(struct SNAME *_list_, V value) \ + bool CMC_(PFX, _push_front)(struct SNAME * _list_, V value) \ { \ - struct SNAME##_node *_node_ = PFX##_new_node(_list_, value); \ + struct CMC_DEF_NODE(SNAME) *_node_ = \ + CMC_(PFX, _new_node)(_list_, value); \ \ if (!_node_) \ return false; \ \ - if (PFX##_empty(_list_)) \ + if (CMC_(PFX, _empty)(_list_)) \ { \ _list_->head = _node_; \ _list_->tail = _node_; \ @@ -337,7 +357,7 @@ static const char *cmc_string_fmt_linkedlist = "struct %s<%s> " } \ \ _list_->count++; \ - _list_->flag = cmc_flags.OK; \ + _list_->flag = CMC_FLAG_OK; \ \ if (_list_->callbacks && _list_->callbacks->create) \ _list_->callbacks->create(); \ @@ -345,29 +365,31 @@ static const char *cmc_string_fmt_linkedlist = "struct %s<%s> " return true; \ } \ \ - bool PFX##_push_at(struct SNAME *_list_, V value, size_t index) \ + bool CMC_(PFX, _push_at)(struct SNAME * _list_, V value, size_t index) \ { \ if (index > _list_->count) \ { \ - _list_->flag = cmc_flags.RANGE; \ + _list_->flag = CMC_FLAG_RANGE; \ return false; \ } \ \ if (index == 0) \ { \ - return PFX##_push_front(_list_, value); \ + return CMC_(PFX, _push_front)(_list_, value); \ } \ else if (index == _list_->count) \ { \ - return PFX##_push_back(_list_, value); \ + return CMC_(PFX, _push_back)(_list_, value); \ } \ \ - struct SNAME##_node *_node_ = PFX##_new_node(_list_, value); \ + struct CMC_DEF_NODE(SNAME) *_node_ = \ + CMC_(PFX, _new_node)(_list_, value); \ \ if (!_node_) \ return false; \ \ - struct SNAME##_node *scan = PFX##_get_node(_list_, index - 1); \ + struct CMC_DEF_NODE(SNAME) *scan = \ + CMC_(PFX, _get_node)(_list_, index - 1); \ \ _node_->next = scan->next; \ _node_->prev = scan; \ @@ -375,7 +397,7 @@ static const char *cmc_string_fmt_linkedlist = "struct %s<%s> " _node_->prev->next = _node_; \ \ _list_->count++; \ - _list_->flag = cmc_flags.OK; \ + _list_->flag = CMC_FLAG_OK; \ \ if (_list_->callbacks && _list_->callbacks->create) \ _list_->callbacks->create(); \ @@ -383,14 +405,15 @@ static const char *cmc_string_fmt_linkedlist = "struct %s<%s> " return true; \ } \ \ - bool PFX##_push_back(struct SNAME *_list_, V value) \ + bool CMC_(PFX, _push_back)(struct SNAME * _list_, V value) \ { \ - struct SNAME##_node *_node_ = PFX##_new_node(_list_, value); \ + struct CMC_DEF_NODE(SNAME) *_node_ = \ + CMC_(PFX, _new_node)(_list_, value); \ \ if (!_node_) \ return false; \ \ - if (PFX##_empty(_list_)) \ + if (CMC_(PFX, _empty)(_list_)) \ { \ _list_->head = _node_; \ _list_->tail = _node_; \ @@ -403,7 +426,7 @@ static const char *cmc_string_fmt_linkedlist = "struct %s<%s> " } \ \ _list_->count++; \ - _list_->flag = cmc_flags.OK; \ + _list_->flag = CMC_FLAG_OK; \ \ if (_list_->callbacks && _list_->callbacks->create) \ _list_->callbacks->create(); \ @@ -411,15 +434,15 @@ static const char *cmc_string_fmt_linkedlist = "struct %s<%s> " return true; \ } \ \ - bool PFX##_pop_front(struct SNAME *_list_) \ + bool CMC_(PFX, _pop_front)(struct SNAME * _list_) \ { \ - if (PFX##_empty(_list_)) \ + if (CMC_(PFX, _empty)(_list_)) \ { \ - _list_->flag = cmc_flags.EMPTY; \ + _list_->flag = CMC_FLAG_EMPTY; \ return false; \ } \ \ - struct SNAME##_node *_node_ = _list_->head; \ + struct CMC_DEF_NODE(SNAME) *_node_ = _list_->head; \ _list_->head = _list_->head->next; \ \ _list_->alloc->free(_node_); \ @@ -430,7 +453,7 @@ static const char *cmc_string_fmt_linkedlist = "struct %s<%s> " _list_->head->prev = NULL; \ \ _list_->count--; \ - _list_->flag = cmc_flags.OK; \ + _list_->flag = CMC_FLAG_OK; \ \ if (_list_->callbacks && _list_->callbacks->delete) \ _list_->callbacks->delete (); \ @@ -438,30 +461,31 @@ static const char *cmc_string_fmt_linkedlist = "struct %s<%s> " return true; \ } \ \ - bool PFX##_pop_at(struct SNAME *_list_, size_t index) \ + bool CMC_(PFX, _pop_at)(struct SNAME * _list_, size_t index) \ { \ - if (PFX##_empty(_list_)) \ + if (CMC_(PFX, _empty)(_list_)) \ { \ - _list_->flag = cmc_flags.EMPTY; \ + _list_->flag = CMC_FLAG_EMPTY; \ return false; \ } \ \ if (index >= _list_->count) \ { \ - _list_->flag = cmc_flags.RANGE; \ + _list_->flag = CMC_FLAG_RANGE; \ return false; \ } \ \ if (index == 0) \ { \ - return PFX##_pop_front(_list_); \ + return CMC_(PFX, _pop_front)(_list_); \ } \ else if (index == _list_->count - 1) \ { \ - return PFX##_pop_back(_list_); \ + return CMC_(PFX, _pop_back)(_list_); \ } \ \ - struct SNAME##_node *_node_ = PFX##_get_node(_list_, index); \ + struct CMC_DEF_NODE(SNAME) *_node_ = \ + CMC_(PFX, _get_node)(_list_, index); \ \ if (!_node_) \ return false; \ @@ -472,7 +496,7 @@ static const char *cmc_string_fmt_linkedlist = "struct %s<%s> " _list_->alloc->free(_node_); \ \ _list_->count--; \ - _list_->flag = cmc_flags.OK; \ + _list_->flag = CMC_FLAG_OK; \ \ if (_list_->callbacks && _list_->callbacks->delete) \ _list_->callbacks->delete (); \ @@ -480,15 +504,15 @@ static const char *cmc_string_fmt_linkedlist = "struct %s<%s> " return true; \ } \ \ - bool PFX##_pop_back(struct SNAME *_list_) \ + bool CMC_(PFX, _pop_back)(struct SNAME * _list_) \ { \ - if (PFX##_empty(_list_)) \ + if (CMC_(PFX, _empty)(_list_)) \ { \ - _list_->flag = cmc_flags.EMPTY; \ + _list_->flag = CMC_FLAG_EMPTY; \ return false; \ } \ \ - struct SNAME##_node *_node_ = _list_->tail; \ + struct CMC_DEF_NODE(SNAME) *_node_ = _list_->tail; \ _list_->tail = _list_->tail->prev; \ \ _list_->alloc->free(_node_); \ @@ -499,7 +523,7 @@ static const char *cmc_string_fmt_linkedlist = "struct %s<%s> " _list_->tail->next = NULL; \ \ _list_->count--; \ - _list_->flag = cmc_flags.OK; \ + _list_->flag = CMC_FLAG_OK; \ \ if (_list_->callbacks && _list_->callbacks->delete) \ _list_->callbacks->delete (); \ @@ -507,15 +531,15 @@ static const char *cmc_string_fmt_linkedlist = "struct %s<%s> " return true; \ } \ \ - V PFX##_front(struct SNAME *_list_) \ + V CMC_(PFX, _front)(struct SNAME * _list_) \ { \ - if (PFX##_empty(_list_)) \ + if (CMC_(PFX, _empty)(_list_)) \ { \ - _list_->flag = cmc_flags.EMPTY; \ + _list_->flag = CMC_FLAG_EMPTY; \ return (V){ 0 }; \ } \ \ - _list_->flag = cmc_flags.OK; \ + _list_->flag = CMC_FLAG_OK; \ \ if (_list_->callbacks && _list_->callbacks->read) \ _list_->callbacks->read(); \ @@ -523,21 +547,22 @@ static const char *cmc_string_fmt_linkedlist = "struct %s<%s> " return _list_->head->value; \ } \ \ - V PFX##_get(struct SNAME *_list_, size_t index) \ + V CMC_(PFX, _get)(struct SNAME * _list_, size_t index) \ { \ - if (PFX##_empty(_list_)) \ + if (CMC_(PFX, _empty)(_list_)) \ { \ - _list_->flag = cmc_flags.EMPTY; \ + _list_->flag = CMC_FLAG_EMPTY; \ return (V){ 0 }; \ } \ \ if (index >= _list_->count) \ { \ - _list_->flag = cmc_flags.RANGE; \ + _list_->flag = CMC_FLAG_RANGE; \ return (V){ 0 }; \ } \ \ - struct SNAME##_node *scan = PFX##_get_node(_list_, index); \ + struct CMC_DEF_NODE(SNAME) *scan = \ + CMC_(PFX, _get_node)(_list_, index); \ \ if (scan == NULL) \ return (V){ 0 }; \ @@ -548,21 +573,22 @@ static const char *cmc_string_fmt_linkedlist = "struct %s<%s> " return scan->value; \ } \ \ - V *PFX##_get_ref(struct SNAME *_list_, size_t index) \ + V *CMC_(PFX, _get_ref)(struct SNAME * _list_, size_t index) \ { \ - if (PFX##_empty(_list_)) \ + if (CMC_(PFX, _empty)(_list_)) \ { \ - _list_->flag = cmc_flags.EMPTY; \ + _list_->flag = CMC_FLAG_EMPTY; \ return NULL; \ } \ \ if (index >= _list_->count) \ { \ - _list_->flag = cmc_flags.RANGE; \ + _list_->flag = CMC_FLAG_RANGE; \ return NULL; \ } \ \ - struct SNAME##_node *scan = PFX##_get_node(_list_, index); \ + struct CMC_DEF_NODE(SNAME) *scan = \ + CMC_(PFX, _get_node)(_list_, index); \ \ if (scan == NULL) \ return NULL; \ @@ -573,15 +599,15 @@ static const char *cmc_string_fmt_linkedlist = "struct %s<%s> " return &(scan->value); \ } \ \ - V PFX##_back(struct SNAME *_list_) \ + V CMC_(PFX, _back)(struct SNAME * _list_) \ { \ - if (PFX##_empty(_list_)) \ + if (CMC_(PFX, _empty)(_list_)) \ { \ - _list_->flag = cmc_flags.EMPTY; \ + _list_->flag = CMC_FLAG_EMPTY; \ return (V){ 0 }; \ } \ \ - _list_->flag = cmc_flags.OK; \ + _list_->flag = CMC_FLAG_OK; \ \ if (_list_->callbacks && _list_->callbacks->read) \ _list_->callbacks->read(); \ @@ -589,13 +615,13 @@ static const char *cmc_string_fmt_linkedlist = "struct %s<%s> " return _list_->tail->value; \ } \ \ - bool PFX##_contains(struct SNAME *_list_, V value) \ + bool CMC_(PFX, _contains)(struct SNAME * _list_, V value) \ { \ - _list_->flag = cmc_flags.OK; \ + _list_->flag = CMC_FLAG_OK; \ \ bool result = false; \ \ - struct SNAME##_node *scan = _list_->head; \ + struct CMC_DEF_NODE(SNAME) *scan = _list_->head; \ \ while (scan != NULL) \ { \ @@ -614,42 +640,42 @@ static const char *cmc_string_fmt_linkedlist = "struct %s<%s> " return result; \ } \ \ - bool PFX##_empty(struct SNAME *_list_) \ + bool CMC_(PFX, _empty)(struct SNAME * _list_) \ { \ return _list_->count == 0; \ } \ \ - size_t PFX##_count(struct SNAME *_list_) \ + size_t CMC_(PFX, _count)(struct SNAME * _list_) \ { \ return _list_->count; \ } \ \ - int PFX##_flag(struct SNAME *_list_) \ + int CMC_(PFX, _flag)(struct SNAME * _list_) \ { \ return _list_->flag; \ } \ \ - struct SNAME *PFX##_copy_of(struct SNAME *_list_) \ + struct SNAME *CMC_(PFX, _copy_of)(struct SNAME * _list_) \ { \ - struct SNAME *result = \ - PFX##_new_custom(_list_->f_val, _list_->alloc, _list_->callbacks); \ + struct SNAME *result = CMC_(PFX, _new_custom)( \ + _list_->f_val, _list_->alloc, _list_->callbacks); \ \ if (!result) \ return NULL; \ \ - struct SNAME##_node *scan = _list_->head; \ + struct CMC_DEF_NODE(SNAME) *scan = _list_->head; \ \ while (scan != NULL) \ { \ /* This allocation should never fail since it might not be */ \ /* possible to recover from it. That is why it isn't checked */ \ - struct SNAME##_node *new_node; \ + struct CMC_DEF_NODE(SNAME) * new_node; \ \ if (_list_->f_val->cpy) \ - new_node = \ - PFX##_new_node(_list_, _list_->f_val->cpy(scan->value)); \ + new_node = CMC_(PFX, _new_node)( \ + _list_, _list_->f_val->cpy(scan->value)); \ else \ - new_node = PFX##_new_node(_list_, scan->value); \ + new_node = CMC_(PFX, _new_node)(_list_, scan->value); \ \ if (!result->head) \ { \ @@ -668,21 +694,21 @@ static const char *cmc_string_fmt_linkedlist = "struct %s<%s> " \ result->count = _list_->count; \ \ - _list_->flag = cmc_flags.OK; \ + _list_->flag = CMC_FLAG_OK; \ \ return result; \ } \ \ - bool PFX##_equals(struct SNAME *_list1_, struct SNAME *_list2_) \ + bool CMC_(PFX, _equals)(struct SNAME * _list1_, struct SNAME * _list2_) \ { \ - _list1_->flag = cmc_flags.OK; \ - _list2_->flag = cmc_flags.OK; \ + _list1_->flag = CMC_FLAG_OK; \ + _list2_->flag = CMC_FLAG_OK; \ \ if (_list1_->count != _list2_->count) \ return false; \ \ - struct SNAME##_node *scan1 = _list1_->head; \ - struct SNAME##_node *scan2 = _list2_->head; \ + struct CMC_DEF_NODE(SNAME) *scan1 = _list1_->head; \ + struct CMC_DEF_NODE(SNAME) *scan2 = _list2_->head; \ \ while (scan1 != NULL && scan2 != NULL) \ { \ @@ -696,21 +722,21 @@ static const char *cmc_string_fmt_linkedlist = "struct %s<%s> " return true; \ } \ \ - struct cmc_string PFX##_to_string(struct SNAME *_list_) \ + struct cmc_string CMC_(PFX, _to_string)(struct SNAME * _list_) \ { \ struct cmc_string str; \ struct SNAME *l_ = _list_; \ \ - int n = snprintf(str.s, cmc_string_len, cmc_string_fmt_linkedlist, \ + int n = snprintf(str.s, cmc_string_len, cmc_cmc_string_fmt_linkedlist, \ #SNAME, #V, l_, l_->count, l_->head, l_->tail, \ l_->flag, l_->f_val, l_->alloc, l_->callbacks); \ \ return n >= 0 ? str : (struct cmc_string){ 0 }; \ } \ \ - bool PFX##_print(struct SNAME *_list_, FILE *fptr) \ + bool CMC_(PFX, _print)(struct SNAME * _list_, FILE * fptr) \ { \ - struct SNAME##_node *scan = _list_->head; \ + struct CMC_DEF_NODE(SNAME) *scan = _list_->head; \ \ while (scan != NULL) \ { \ @@ -723,14 +749,15 @@ static const char *cmc_string_fmt_linkedlist = "struct %s<%s> " return true; \ } \ \ - struct SNAME##_node *PFX##_new_node(struct SNAME *_list_, V value) \ + struct CMC_DEF_NODE(SNAME) * \ + CMC_(PFX, _new_node)(struct SNAME * _list_, V value) \ { \ - struct SNAME##_node *_node_ = \ - _list_->alloc->malloc(sizeof(struct SNAME##_node)); \ + struct CMC_DEF_NODE(SNAME) *_node_ = \ + _list_->alloc->malloc(sizeof(struct CMC_DEF_NODE(SNAME))); \ \ if (!_node_) \ { \ - _list_->flag = cmc_flags.ALLOC; \ + _list_->flag = CMC_FLAG_ALLOC; \ return NULL; \ } \ \ @@ -741,31 +768,33 @@ static const char *cmc_string_fmt_linkedlist = "struct %s<%s> " return _node_; \ } \ \ - void PFX##_free_node(struct SNAME *_list_, struct SNAME##_node *_node_) \ + void CMC_(PFX, _free_node)(struct SNAME * _list_, \ + struct CMC_DEF_NODE(SNAME) * _node_) \ { \ _list_->alloc->free(_node_); \ } \ \ - struct SNAME##_node *PFX##_head(struct SNAME *_list_) \ + struct CMC_DEF_NODE(SNAME) * CMC_(PFX, _head)(struct SNAME * _list_) \ { \ return _list_->head; \ } \ \ - struct SNAME##_node *PFX##_get_node(struct SNAME *_list_, size_t index) \ + struct CMC_DEF_NODE(SNAME) * \ + CMC_(PFX, _get_node)(struct SNAME * _list_, size_t index) \ { \ - if (PFX##_empty(_list_)) \ + if (CMC_(PFX, _empty)(_list_)) \ { \ - _list_->flag = cmc_flags.EMPTY; \ + _list_->flag = CMC_FLAG_EMPTY; \ return NULL; \ } \ \ if (index >= _list_->count) \ { \ - _list_->flag = cmc_flags.RANGE; \ + _list_->flag = CMC_FLAG_RANGE; \ return NULL; \ } \ \ - struct SNAME##_node *_node_ = NULL; \ + struct CMC_DEF_NODE(SNAME) *_node_ = NULL; \ \ if (index <= _list_->count / 2) \ { \ @@ -784,20 +813,21 @@ static const char *cmc_string_fmt_linkedlist = "struct %s<%s> " } \ } \ \ - _list_->flag = cmc_flags.OK; \ + _list_->flag = CMC_FLAG_OK; \ \ return _node_; \ } \ \ - struct SNAME##_node *PFX##_tail(struct SNAME *_list_) \ + struct CMC_DEF_NODE(SNAME) * CMC_(PFX, _tail)(struct SNAME * _list_) \ { \ return _list_->tail; \ } \ \ - bool PFX##_add_next(struct SNAME *_owner_, struct SNAME##_node *_node_, \ - V value) \ + bool CMC_(PFX, _add_next)(struct SNAME * _owner_, \ + struct CMC_DEF_NODE(SNAME) * _node_, V value) \ { \ - struct SNAME##_node *new_node = PFX##_new_node(_owner_, value); \ + struct CMC_DEF_NODE(SNAME) *new_node = \ + CMC_(PFX, _new_node)(_owner_, value); \ \ if (!new_node) \ return false; \ @@ -813,15 +843,16 @@ static const char *cmc_string_fmt_linkedlist = "struct %s<%s> " _node_->next = new_node; \ \ _owner_->count++; \ - _owner_->flag = cmc_flags.OK; \ + _owner_->flag = CMC_FLAG_OK; \ \ return true; \ } \ \ - bool PFX##_add_prev(struct SNAME *_owner_, struct SNAME##_node *_node_, \ - V value) \ + bool CMC_(PFX, _add_prev)(struct SNAME * _owner_, \ + struct CMC_DEF_NODE(SNAME) * _node_, V value) \ { \ - struct SNAME##_node *new_node = PFX##_new_node(_owner_, value); \ + struct CMC_DEF_NODE(SNAME) *new_node = \ + CMC_(PFX, _new_node)(_owner_, value); \ \ if (!new_node) \ return false; \ @@ -837,20 +868,21 @@ static const char *cmc_string_fmt_linkedlist = "struct %s<%s> " _node_->prev = new_node; \ \ _owner_->count++; \ - _owner_->flag = cmc_flags.OK; \ + _owner_->flag = CMC_FLAG_OK; \ \ return true; \ } \ \ - bool PFX##_del_next(struct SNAME *_owner_, struct SNAME##_node *_node_) \ + bool CMC_(PFX, _del_next)(struct SNAME * _owner_, \ + struct CMC_DEF_NODE(SNAME) * _node_) \ { \ if (_node_->next == NULL) \ { \ - _owner_->flag = cmc_flags.INVALID; \ + _owner_->flag = CMC_FLAG_INVALID; \ return false; \ } \ \ - struct SNAME##_node *tmp = _node_->next; \ + struct CMC_DEF_NODE(SNAME) *tmp = _node_->next; \ \ _node_->next = _node_->next->next; \ \ @@ -862,12 +894,13 @@ static const char *cmc_string_fmt_linkedlist = "struct %s<%s> " _owner_->alloc->free(tmp); \ \ _owner_->count--; \ - _owner_->flag = cmc_flags.OK; \ + _owner_->flag = CMC_FLAG_OK; \ \ return true; \ } \ \ - bool PFX##_del_curr(struct SNAME *_owner_, struct SNAME##_node *_node_) \ + bool CMC_(PFX, _del_curr)(struct SNAME * _owner_, \ + struct CMC_DEF_NODE(SNAME) * _node_) \ { \ if (_node_->prev != NULL) \ _node_->prev->next = _node_->next; \ @@ -882,20 +915,21 @@ static const char *cmc_string_fmt_linkedlist = "struct %s<%s> " _owner_->alloc->free(_node_); \ \ _owner_->count--; \ - _owner_->flag = cmc_flags.OK; \ + _owner_->flag = CMC_FLAG_OK; \ \ return true; \ } \ \ - bool PFX##_del_prev(struct SNAME *_owner_, struct SNAME##_node *_node_) \ + bool CMC_(PFX, _del_prev)(struct SNAME * _owner_, \ + struct CMC_DEF_NODE(SNAME) * _node_) \ { \ if (_node_->prev == NULL) \ { \ - _owner_->flag = cmc_flags.INVALID; \ + _owner_->flag = CMC_FLAG_INVALID; \ return false; \ } \ \ - struct SNAME##_node *tmp = _node_->prev; \ + struct CMC_DEF_NODE(SNAME) *tmp = _node_->prev; \ \ _node_->prev = _node_->prev->prev; \ \ @@ -907,68 +941,70 @@ static const char *cmc_string_fmt_linkedlist = "struct %s<%s> " _owner_->alloc->free(tmp); \ \ _owner_->count--; \ - _owner_->flag = cmc_flags.OK; \ + _owner_->flag = CMC_FLAG_OK; \ \ return true; \ } \ \ - struct SNAME##_node *PFX##_next_node(struct SNAME##_node *_node_) \ + struct CMC_DEF_NODE(SNAME) * \ + CMC_(PFX, _next_node)(struct CMC_DEF_NODE(SNAME) * _node_) \ { \ return _node_->next; \ } \ \ - struct SNAME##_node *PFX##_prev_node(struct SNAME##_node *_node_) \ + struct CMC_DEF_NODE(SNAME) * \ + CMC_(PFX, _prev_node)(struct CMC_DEF_NODE(SNAME) * _node_) \ { \ return _node_->prev; \ } \ \ - struct SNAME##_iter PFX##_iter_start(struct SNAME *target) \ + struct CMC_DEF_ITER(SNAME) CMC_(PFX, _iter_start)(struct SNAME * target) \ { \ - struct SNAME##_iter iter; \ + struct CMC_DEF_ITER(SNAME) iter; \ \ iter.target = target; \ iter.cursor = target->head; \ iter.index = 0; \ iter.start = true; \ - iter.end = PFX##_empty(target); \ + iter.end = CMC_(PFX, _empty)(target); \ \ return iter; \ } \ \ - struct SNAME##_iter PFX##_iter_end(struct SNAME *target) \ + struct CMC_DEF_ITER(SNAME) CMC_(PFX, _iter_end)(struct SNAME * target) \ { \ - struct SNAME##_iter iter; \ + struct CMC_DEF_ITER(SNAME) iter; \ \ iter.target = target; \ iter.cursor = target->tail; \ iter.index = 0; \ - iter.start = PFX##_empty(target); \ + iter.start = CMC_(PFX, _empty)(target); \ iter.end = true; \ \ - if (!PFX##_empty(target)) \ + if (!CMC_(PFX, _empty)(target)) \ iter.index = target->count - 1; \ \ return iter; \ } \ \ - bool PFX##_iter_at_start(struct SNAME##_iter *iter) \ + bool CMC_(PFX, _iter_at_start)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ - return PFX##_empty(iter->target) || iter->start; \ + return CMC_(PFX, _empty)(iter->target) || iter->start; \ } \ \ - bool PFX##_iter_at_end(struct SNAME##_iter *iter) \ + bool CMC_(PFX, _iter_at_end)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ - return PFX##_empty(iter->target) || iter->end; \ + return CMC_(PFX, _empty)(iter->target) || iter->end; \ } \ \ - bool PFX##_iter_to_start(struct SNAME##_iter *iter) \ + bool CMC_(PFX, _iter_to_start)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ - if (!PFX##_empty(iter->target)) \ + if (!CMC_(PFX, _empty)(iter->target)) \ { \ iter->cursor = iter->target->head; \ iter->index = 0; \ iter->start = true; \ - iter->end = PFX##_empty(iter->target); \ + iter->end = CMC_(PFX, _empty)(iter->target); \ \ return true; \ } \ @@ -976,13 +1012,13 @@ static const char *cmc_string_fmt_linkedlist = "struct %s<%s> " return false; \ } \ \ - bool PFX##_iter_to_end(struct SNAME##_iter *iter) \ + bool CMC_(PFX, _iter_to_end)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ - if (!PFX##_empty(iter->target)) \ + if (!CMC_(PFX, _empty)(iter->target)) \ { \ iter->cursor = iter->target->tail; \ iter->index = iter->target->count - 1; \ - iter->start = PFX##_empty(iter->target); \ + iter->start = CMC_(PFX, _empty)(iter->target); \ iter->end = true; \ \ return true; \ @@ -991,7 +1027,7 @@ static const char *cmc_string_fmt_linkedlist = "struct %s<%s> " return false; \ } \ \ - bool PFX##_iter_next(struct SNAME##_iter *iter) \ + bool CMC_(PFX, _iter_next)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ if (iter->end) \ return false; \ @@ -1002,7 +1038,7 @@ static const char *cmc_string_fmt_linkedlist = "struct %s<%s> " return false; \ } \ \ - iter->start = PFX##_empty(iter->target); \ + iter->start = CMC_(PFX, _empty)(iter->target); \ \ iter->cursor = iter->cursor->next; \ iter->index++; \ @@ -1010,7 +1046,7 @@ static const char *cmc_string_fmt_linkedlist = "struct %s<%s> " return true; \ } \ \ - bool PFX##_iter_prev(struct SNAME##_iter *iter) \ + bool CMC_(PFX, _iter_prev)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ if (iter->start) \ return false; \ @@ -1021,7 +1057,7 @@ static const char *cmc_string_fmt_linkedlist = "struct %s<%s> " return false; \ } \ \ - iter->end = PFX##_empty(iter->target); \ + iter->end = CMC_(PFX, _empty)(iter->target); \ \ iter->cursor = iter->cursor->prev; \ iter->index--; \ @@ -1030,7 +1066,8 @@ static const char *cmc_string_fmt_linkedlist = "struct %s<%s> " } \ \ /* Returns true only if the iterator moved */ \ - bool PFX##_iter_advance(struct SNAME##_iter *iter, size_t steps) \ + bool CMC_(PFX, _iter_advance)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t steps) \ { \ if (iter->end) \ return false; \ @@ -1044,7 +1081,7 @@ static const char *cmc_string_fmt_linkedlist = "struct %s<%s> " if (steps == 0 || iter->index + steps >= iter->target->count) \ return false; \ \ - iter->start = PFX##_empty(iter->target); \ + iter->start = CMC_(PFX, _empty)(iter->target); \ \ iter->index += steps; \ \ @@ -1055,7 +1092,8 @@ static const char *cmc_string_fmt_linkedlist = "struct %s<%s> " } \ \ /* Returns true only if the iterator moved */ \ - bool PFX##_iter_rewind(struct SNAME##_iter *iter, size_t steps) \ + bool CMC_(PFX, _iter_rewind)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t steps) \ { \ if (iter->start) \ return false; \ @@ -1069,7 +1107,7 @@ static const char *cmc_string_fmt_linkedlist = "struct %s<%s> " if (steps == 0 || iter->index < steps) \ return false; \ \ - iter->end = PFX##_empty(iter->target); \ + iter->end = CMC_(PFX, _empty)(iter->target); \ \ iter->index -= steps; \ \ @@ -1081,43 +1119,45 @@ static const char *cmc_string_fmt_linkedlist = "struct %s<%s> " \ /* Returns true only if the iterator was able to be positioned at the */ \ /* given index */ \ - bool PFX##_iter_go_to(struct SNAME##_iter *iter, size_t index) \ + bool CMC_(PFX, _iter_go_to)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t index) \ { \ if (index >= iter->target->count) \ return false; \ \ if (iter->index > index) \ - return PFX##_iter_rewind(iter, iter->index - index); \ + return CMC_(PFX, _iter_rewind)(iter, iter->index - index); \ else if (iter->index < index) \ - return PFX##_iter_advance(iter, index - iter->index); \ + return CMC_(PFX, _iter_advance)(iter, index - iter->index); \ \ return true; \ } \ \ - V PFX##_iter_value(struct SNAME##_iter *iter) \ + V CMC_(PFX, _iter_value)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ - if (PFX##_empty(iter->target)) \ + if (CMC_(PFX, _empty)(iter->target)) \ return (V){ 0 }; \ \ return iter->cursor->value; \ } \ \ - V *PFX##_iter_rvalue(struct SNAME##_iter *iter) \ + V *CMC_(PFX, _iter_rvalue)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ - if (PFX##_empty(iter->target)) \ + if (CMC_(PFX, _empty)(iter->target)) \ return NULL; \ \ return &(iter->cursor->value); \ } \ \ - size_t PFX##_iter_index(struct SNAME##_iter *iter) \ + size_t CMC_(PFX, _iter_index)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ return iter->index; \ } \ \ - struct SNAME##_node *PFX##_iter_node(struct SNAME##_iter *iter) \ + struct CMC_DEF_NODE(SNAME) * \ + CMC_(PFX, _iter_node)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ return iter->cursor; \ } -#endif /* CMC_LINKEDLIST_H */ +#endif /* CMC_CMC_LINKEDLIST_H */ diff --git a/src/cmc/list.h b/src/cmc/list.h index aa7ff78..a8fc1c9 100644 --- a/src/cmc/list.h +++ b/src/cmc/list.h @@ -40,8 +40,8 @@ * list. */ -#ifndef CMC_LIST_H -#define CMC_LIST_H +#ifndef CMC_CMC_LIST_H +#define CMC_CMC_LIST_H /* ------------------------------------------------------------------------- * Core functionalities of the C Macro Collections Library @@ -52,170 +52,185 @@ * List specific * ------------------------------------------------------------------------- */ /* to_string format */ -static const char *cmc_string_fmt_list = "struct %s<%s> " - "at %p { " - "buffer:%p, " - "capacity:%" PRIuMAX ", " - "count:%" PRIuMAX ", " - "flag:%d, " - "f_val:%p, " - "alloc:%p, " - "callbacks:%p }"; +static const char *cmc_cmc_string_fmt_list = "struct %s<%s> " + "at %p { " + "buffer:%p, " + "capacity:%" PRIuMAX ", " + "count:%" PRIuMAX ", " + "flag:%d, " + "f_val:%p, " + "alloc:%p, " + "callbacks:%p }"; -#define CMC_GENERATE_LIST(PFX, SNAME, V) \ - CMC_GENERATE_LIST_HEADER(PFX, SNAME, V) \ - CMC_GENERATE_LIST_SOURCE(PFX, SNAME, V) +/** + * Core List implementation + */ +#define CMC_CMC_LIST_CORE(BODY) \ + CMC_CMC_LIST_CORE_HEADER(BODY) \ + CMC_CMC_LIST_CORE_SOURCE(BODY) -#define CMC_WRAPGEN_LIST_HEADER(PFX, SNAME, K, V) \ - CMC_GENERATE_LIST_HEADER(PFX, SNAME, V) +#define CMC_CMC_LIST_CORE_HEADER(BODY) \ + CMC_CMC_LIST_CORE_HEADER_(CMC_PARAM_PFX(BODY), CMC_PARAM_SNAME(BODY), \ + CMC_PARAM_V(BODY)) -#define CMC_WRAPGEN_LIST_SOURCE(PFX, SNAME, K, V) \ - CMC_GENERATE_LIST_SOURCE(PFX, SNAME, V) +#define CMC_CMC_LIST_CORE_SOURCE(BODY) \ + CMC_CMC_LIST_CORE_SOURCE_(CMC_PARAM_PFX(BODY), CMC_PARAM_SNAME(BODY), \ + CMC_PARAM_V(BODY)) /* ------------------------------------------------------------------------- * Header * ------------------------------------------------------------------------- */ -#define CMC_GENERATE_LIST_HEADER(PFX, SNAME, V) \ - \ - /* List Structure */ \ - struct SNAME \ - { \ - /* Dynamic array of elements */ \ - V *buffer; \ - \ - /* Current array capacity */ \ - size_t capacity; \ - \ - /* Current amount of elements */ \ - size_t count; \ - \ - /* Flags indicating errors or success */ \ - int flag; \ - \ - /* Value function table */ \ - struct SNAME##_fval *f_val; \ - \ - /* Custom allocation functions */ \ - struct cmc_alloc_node *alloc; \ - \ - /* Custom callback functions */ \ - struct cmc_callbacks *callbacks; \ - }; \ - \ - /* Value struct function table */ \ - struct SNAME##_fval \ - { \ - /* Comparator function */ \ - int (*cmp)(V, V); \ - \ - /* Copy function */ \ - V (*cpy)(V); \ - \ - /* To string function */ \ - bool (*str)(FILE *, V); \ - \ - /* Free from memory function */ \ - void (*free)(V); \ - \ - /* Hash function */ \ - size_t (*hash)(V); \ - \ - /* Priority function */ \ - int (*pri)(V, V); \ - }; \ - \ - /* List Iterator */ \ - struct SNAME##_iter \ - { \ - /* Target list */ \ - struct SNAME *target; \ - \ - /* Cursor's position (index) */ \ - size_t cursor; \ - \ - /* If the iterator has reached the start of the iteration */ \ - bool start; \ - \ - /* If the iterator has reached the end of the iteration */ \ - bool end; \ - }; \ - \ - /* Collection Functions */ \ - /* Collection Allocation and Deallocation */ \ - struct SNAME *PFX##_new(size_t capacity, struct SNAME##_fval *f_val); \ - struct SNAME *PFX##_new_custom( \ - size_t capacity, struct SNAME##_fval *f_val, \ - struct cmc_alloc_node *alloc, struct cmc_callbacks *callbacks); \ - void PFX##_clear(struct SNAME *_list_); \ - void PFX##_free(struct SNAME *_list_); \ - /* Customization of Allocation and Callbacks */ \ - void PFX##_customize(struct SNAME *_list_, struct cmc_alloc_node *alloc, \ - struct cmc_callbacks *callbacks); \ - /* Collection Input and Output */ \ - bool PFX##_push_front(struct SNAME *_list_, V value); \ - bool PFX##_push_at(struct SNAME *_list_, V value, size_t index); \ - bool PFX##_push_back(struct SNAME *_list_, V value); \ - bool PFX##_pop_front(struct SNAME *_list_); \ - bool PFX##_pop_at(struct SNAME *_list_, size_t index); \ - bool PFX##_pop_back(struct SNAME *_list_); \ - /* Collection Sequence Input and Output */ \ - bool PFX##_seq_push_front(struct SNAME *_list_, V *values, size_t size); \ - bool PFX##_seq_push_at(struct SNAME *_list_, V *values, size_t size, \ - size_t index); \ - bool PFX##_seq_push_back(struct SNAME *_list_, V *values, size_t size); \ - bool PFX##_seq_pop_at(struct SNAME *_list_, size_t from, size_t to); \ - struct SNAME *PFX##_seq_sublist(struct SNAME *_list_, size_t from, \ - size_t to); \ - /* Element Access */ \ - V PFX##_front(struct SNAME *_list_); \ - V PFX##_get(struct SNAME *_list_, size_t index); \ - V *PFX##_get_ref(struct SNAME *_list_, size_t index); \ - V PFX##_back(struct SNAME *_list_); \ - size_t PFX##_index_of(struct SNAME *_list_, V value, bool from_start); \ - /* Collection State */ \ - bool PFX##_contains(struct SNAME *_list_, V value); \ - bool PFX##_empty(struct SNAME *_list_); \ - bool PFX##_full(struct SNAME *_list_); \ - size_t PFX##_count(struct SNAME *_list_); \ - bool PFX##_fits(struct SNAME *_list_, size_t size); \ - size_t PFX##_capacity(struct SNAME *_list_); \ - int PFX##_flag(struct SNAME *_list_); \ - /* Collection Utility */ \ - bool PFX##_resize(struct SNAME *_list_, size_t capacity); \ - struct SNAME *PFX##_copy_of(struct SNAME *_list_); \ - bool PFX##_equals(struct SNAME *_list1_, struct SNAME *_list2_); \ - struct cmc_string PFX##_to_string(struct SNAME *_list_); \ - bool PFX##_print(struct SNAME *_list_, FILE *fptr); \ - \ - /* Iterator Functions */ \ - /* Iterator Initialization */ \ - struct SNAME##_iter PFX##_iter_start(struct SNAME *target); \ - struct SNAME##_iter PFX##_iter_end(struct SNAME *target); \ - /* Iterator State */ \ - bool PFX##_iter_at_start(struct SNAME##_iter *iter); \ - bool PFX##_iter_at_end(struct SNAME##_iter *iter); \ - /* Iterator Movement */ \ - bool PFX##_iter_to_start(struct SNAME##_iter *iter); \ - bool PFX##_iter_to_end(struct SNAME##_iter *iter); \ - bool PFX##_iter_next(struct SNAME##_iter *iter); \ - bool PFX##_iter_prev(struct SNAME##_iter *iter); \ - bool PFX##_iter_advance(struct SNAME##_iter *iter, size_t steps); \ - bool PFX##_iter_rewind(struct SNAME##_iter *iter, size_t steps); \ - bool PFX##_iter_go_to(struct SNAME##_iter *iter, size_t index); \ - /* Iterator Access */ \ - V PFX##_iter_value(struct SNAME##_iter *iter); \ - V *PFX##_iter_rvalue(struct SNAME##_iter *iter); \ - size_t PFX##_iter_index(struct SNAME##_iter *iter); +#define CMC_CMC_LIST_CORE_HEADER_(PFX, SNAME, V) \ + \ + /* List Structure */ \ + struct SNAME \ + { \ + /* Dynamic array of elements */ \ + V *buffer; \ + \ + /* Current array capacity */ \ + size_t capacity; \ + \ + /* Current amount of elements */ \ + size_t count; \ + \ + /* Flags indicating errors or success */ \ + int flag; \ + \ + /* Value function table */ \ + struct CMC_DEF_FVAL(SNAME) * f_val; \ + \ + /* Custom allocation functions */ \ + struct cmc_alloc_node *alloc; \ + \ + /* Custom callback functions */ \ + struct cmc_callbacks *callbacks; \ + }; \ + \ + /* Value struct function table */ \ + struct CMC_DEF_FVAL(SNAME) \ + { \ + /* Comparator function */ \ + int (*cmp)(V, V); \ + \ + /* Copy function */ \ + V (*cpy)(V); \ + \ + /* To string function */ \ + bool (*str)(FILE *, V); \ + \ + /* Free from memory function */ \ + void (*free)(V); \ + \ + /* Hash function */ \ + size_t (*hash)(V); \ + \ + /* Priority function */ \ + int (*pri)(V, V); \ + }; \ + \ + /* List Iterator */ \ + struct CMC_DEF_ITER(SNAME) \ + { \ + /* Target list */ \ + struct SNAME *target; \ + \ + /* Cursor's position (index) */ \ + size_t cursor; \ + \ + /* If the iterator has reached the start of the iteration */ \ + bool start; \ + \ + /* If the iterator has reached the end of the iteration */ \ + bool end; \ + }; \ + \ + /* Collection Functions */ \ + /* Collection Allocation and Deallocation */ \ + struct SNAME *CMC_(PFX, _new)(size_t capacity, \ + struct CMC_DEF_FVAL(SNAME) * f_val); \ + struct SNAME *CMC_(PFX, _new_custom)( \ + size_t capacity, struct CMC_DEF_FVAL(SNAME) * f_val, \ + struct cmc_alloc_node * alloc, struct cmc_callbacks * callbacks); \ + void CMC_(PFX, _clear)(struct SNAME * _list_); \ + void CMC_(PFX, _free)(struct SNAME * _list_); \ + /* Customization of Allocation and Callbacks */ \ + void CMC_(PFX, _customize)(struct SNAME * _list_, \ + struct cmc_alloc_node * alloc, \ + struct cmc_callbacks * callbacks); \ + /* Collection Input and Output */ \ + bool CMC_(PFX, _push_front)(struct SNAME * _list_, V value); \ + bool CMC_(PFX, _push_at)(struct SNAME * _list_, V value, size_t index); \ + bool CMC_(PFX, _push_back)(struct SNAME * _list_, V value); \ + bool CMC_(PFX, _pop_front)(struct SNAME * _list_); \ + bool CMC_(PFX, _pop_at)(struct SNAME * _list_, size_t index); \ + bool CMC_(PFX, _pop_back)(struct SNAME * _list_); \ + /* Collection Sequence Input and Output */ \ + bool CMC_(PFX, _seq_push_front)(struct SNAME * _list_, V * values, \ + size_t size); \ + bool CMC_(PFX, _seq_push_at)(struct SNAME * _list_, V * values, \ + size_t size, size_t index); \ + bool CMC_(PFX, _seq_push_back)(struct SNAME * _list_, V * values, \ + size_t size); \ + bool CMC_(PFX, _seq_pop_at)(struct SNAME * _list_, size_t from, \ + size_t to); \ + struct SNAME *CMC_(PFX, _seq_sublist)(struct SNAME * _list_, size_t from, \ + size_t to); \ + /* Element Access */ \ + V CMC_(PFX, _front)(struct SNAME * _list_); \ + V CMC_(PFX, _get)(struct SNAME * _list_, size_t index); \ + V *CMC_(PFX, _get_ref)(struct SNAME * _list_, size_t index); \ + V CMC_(PFX, _back)(struct SNAME * _list_); \ + size_t CMC_(PFX, _index_of)(struct SNAME * _list_, V value, \ + bool from_start); \ + /* Collection State */ \ + bool CMC_(PFX, _contains)(struct SNAME * _list_, V value); \ + bool CMC_(PFX, _empty)(struct SNAME * _list_); \ + bool CMC_(PFX, _full)(struct SNAME * _list_); \ + size_t CMC_(PFX, _count)(struct SNAME * _list_); \ + bool CMC_(PFX, _fits)(struct SNAME * _list_, size_t size); \ + size_t CMC_(PFX, _capacity)(struct SNAME * _list_); \ + int CMC_(PFX, _flag)(struct SNAME * _list_); \ + /* Collection Utility */ \ + bool CMC_(PFX, _resize)(struct SNAME * _list_, size_t capacity); \ + struct SNAME *CMC_(PFX, _copy_of)(struct SNAME * _list_); \ + bool CMC_(PFX, _equals)(struct SNAME * _list1_, struct SNAME * _list2_); \ + struct cmc_string CMC_(PFX, _to_string)(struct SNAME * _list_); \ + bool CMC_(PFX, _print)(struct SNAME * _list_, FILE * fptr); \ + \ + /* Iterator Functions */ \ + /* Iterator Initialization */ \ + struct CMC_DEF_ITER(SNAME) CMC_(PFX, _iter_start)(struct SNAME * target); \ + struct CMC_DEF_ITER(SNAME) CMC_(PFX, _iter_end)(struct SNAME * target); \ + /* Iterator State */ \ + bool CMC_(PFX, _iter_at_start)(struct CMC_DEF_ITER(SNAME) * iter); \ + bool CMC_(PFX, _iter_at_end)(struct CMC_DEF_ITER(SNAME) * iter); \ + /* Iterator Movement */ \ + bool CMC_(PFX, _iter_to_start)(struct CMC_DEF_ITER(SNAME) * iter); \ + bool CMC_(PFX, _iter_to_end)(struct CMC_DEF_ITER(SNAME) * iter); \ + bool CMC_(PFX, _iter_next)(struct CMC_DEF_ITER(SNAME) * iter); \ + bool CMC_(PFX, _iter_prev)(struct CMC_DEF_ITER(SNAME) * iter); \ + bool CMC_(PFX, _iter_advance)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t steps); \ + bool CMC_(PFX, _iter_rewind)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t steps); \ + bool CMC_(PFX, _iter_go_to)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t index); \ + /* Iterator Access */ \ + V CMC_(PFX, _iter_value)(struct CMC_DEF_ITER(SNAME) * iter); \ + V *CMC_(PFX, _iter_rvalue)(struct CMC_DEF_ITER(SNAME) * iter); \ + size_t CMC_(PFX, _iter_index)(struct CMC_DEF_ITER(SNAME) * iter); /* ------------------------------------------------------------------------- * Source * ------------------------------------------------------------------------- */ -#define CMC_GENERATE_LIST_SOURCE(PFX, SNAME, V) \ +#define CMC_CMC_LIST_CORE_SOURCE_(PFX, SNAME, V) \ \ /* Implementation Detail Functions */ \ /* None */ \ \ - struct SNAME *PFX##_new(size_t capacity, struct SNAME##_fval *f_val) \ + struct SNAME *CMC_(PFX, _new)(size_t capacity, \ + struct CMC_DEF_FVAL(SNAME) * f_val) \ { \ struct cmc_alloc_node *alloc = &cmc_alloc_node_default; \ \ @@ -237,7 +252,7 @@ static const char *cmc_string_fmt_list = "struct %s<%s> " \ _list_->capacity = capacity; \ _list_->count = 0; \ - _list_->flag = cmc_flags.OK; \ + _list_->flag = CMC_FLAG_OK; \ _list_->f_val = f_val; \ _list_->alloc = alloc; \ _list_->callbacks = NULL; \ @@ -245,9 +260,9 @@ static const char *cmc_string_fmt_list = "struct %s<%s> " return _list_; \ } \ \ - struct SNAME *PFX##_new_custom( \ - size_t capacity, struct SNAME##_fval *f_val, \ - struct cmc_alloc_node *alloc, struct cmc_callbacks *callbacks) \ + struct SNAME *CMC_(PFX, _new_custom)( \ + size_t capacity, struct CMC_DEF_FVAL(SNAME) * f_val, \ + struct cmc_alloc_node * alloc, struct cmc_callbacks * callbacks) \ { \ if (capacity < 1) \ return NULL; \ @@ -273,7 +288,7 @@ static const char *cmc_string_fmt_list = "struct %s<%s> " \ _list_->capacity = capacity; \ _list_->count = 0; \ - _list_->flag = cmc_flags.OK; \ + _list_->flag = CMC_FLAG_OK; \ _list_->f_val = f_val; \ _list_->alloc = alloc; \ _list_->callbacks = callbacks; \ @@ -281,7 +296,7 @@ static const char *cmc_string_fmt_list = "struct %s<%s> " return _list_; \ } \ \ - void PFX##_clear(struct SNAME *_list_) \ + void CMC_(PFX, _clear)(struct SNAME * _list_) \ { \ if (_list_->f_val->free) \ { \ @@ -292,10 +307,10 @@ static const char *cmc_string_fmt_list = "struct %s<%s> " memset(_list_->buffer, 0, sizeof(V) * _list_->capacity); \ \ _list_->count = 0; \ - _list_->flag = cmc_flags.OK; \ + _list_->flag = CMC_FLAG_OK; \ } \ \ - void PFX##_free(struct SNAME *_list_) \ + void CMC_(PFX, _free)(struct SNAME * _list_) \ { \ if (_list_->f_val->free) \ { \ @@ -307,8 +322,9 @@ static const char *cmc_string_fmt_list = "struct %s<%s> " _list_->alloc->free(_list_); \ } \ \ - void PFX##_customize(struct SNAME *_list_, struct cmc_alloc_node *alloc, \ - struct cmc_callbacks *callbacks) \ + void CMC_(PFX, _customize)(struct SNAME * _list_, \ + struct cmc_alloc_node * alloc, \ + struct cmc_callbacks * callbacks) \ { \ if (!alloc) \ _list_->alloc = &cmc_alloc_node_default; \ @@ -317,18 +333,18 @@ static const char *cmc_string_fmt_list = "struct %s<%s> " \ _list_->callbacks = callbacks; \ \ - _list_->flag = cmc_flags.OK; \ + _list_->flag = CMC_FLAG_OK; \ } \ \ - bool PFX##_push_front(struct SNAME *_list_, V value) \ + bool CMC_(PFX, _push_front)(struct SNAME * _list_, V value) \ { \ - if (PFX##_full(_list_)) \ + if (CMC_(PFX, _full)(_list_)) \ { \ - if (!PFX##_resize(_list_, _list_->count * 2)) \ + if (!CMC_(PFX, _resize)(_list_, _list_->count * 2)) \ return false; \ } \ \ - if (!PFX##_empty(_list_)) \ + if (!CMC_(PFX, _empty)(_list_)) \ { \ memmove(_list_->buffer + 1, _list_->buffer, \ _list_->count * sizeof(V)); \ @@ -337,7 +353,7 @@ static const char *cmc_string_fmt_list = "struct %s<%s> " _list_->buffer[0] = value; \ \ _list_->count++; \ - _list_->flag = cmc_flags.OK; \ + _list_->flag = CMC_FLAG_OK; \ \ if (_list_->callbacks && _list_->callbacks->create) \ _list_->callbacks->create(); \ @@ -345,17 +361,17 @@ static const char *cmc_string_fmt_list = "struct %s<%s> " return true; \ } \ \ - bool PFX##_push_at(struct SNAME *_list_, V value, size_t index) \ + bool CMC_(PFX, _push_at)(struct SNAME * _list_, V value, size_t index) \ { \ if (index > _list_->count) \ { \ - _list_->flag = cmc_flags.RANGE; \ + _list_->flag = CMC_FLAG_RANGE; \ return false; \ } \ \ - if (PFX##_full(_list_)) \ + if (CMC_(PFX, _full)(_list_)) \ { \ - if (!PFX##_resize(_list_, _list_->count * 2)) \ + if (!CMC_(PFX, _resize)(_list_, _list_->count * 2)) \ return false; \ } \ \ @@ -364,7 +380,7 @@ static const char *cmc_string_fmt_list = "struct %s<%s> " \ _list_->buffer[index] = value; \ _list_->count++; \ - _list_->flag = cmc_flags.OK; \ + _list_->flag = CMC_FLAG_OK; \ \ if (_list_->callbacks && _list_->callbacks->create) \ _list_->callbacks->create(); \ @@ -372,16 +388,16 @@ static const char *cmc_string_fmt_list = "struct %s<%s> " return true; \ } \ \ - bool PFX##_push_back(struct SNAME *_list_, V value) \ + bool CMC_(PFX, _push_back)(struct SNAME * _list_, V value) \ { \ - if (PFX##_full(_list_)) \ + if (CMC_(PFX, _full)(_list_)) \ { \ - if (!PFX##_resize(_list_, _list_->count * 2)) \ + if (!CMC_(PFX, _resize)(_list_, _list_->count * 2)) \ return false; \ } \ \ _list_->buffer[_list_->count++] = value; \ - _list_->flag = cmc_flags.OK; \ + _list_->flag = CMC_FLAG_OK; \ \ if (_list_->callbacks && _list_->callbacks->create) \ _list_->callbacks->create(); \ @@ -389,11 +405,11 @@ static const char *cmc_string_fmt_list = "struct %s<%s> " return true; \ } \ \ - bool PFX##_pop_front(struct SNAME *_list_) \ + bool CMC_(PFX, _pop_front)(struct SNAME * _list_) \ { \ - if (PFX##_empty(_list_)) \ + if (CMC_(PFX, _empty)(_list_)) \ { \ - _list_->flag = cmc_flags.EMPTY; \ + _list_->flag = CMC_FLAG_EMPTY; \ return false; \ } \ \ @@ -401,7 +417,7 @@ static const char *cmc_string_fmt_list = "struct %s<%s> " (_list_->count - 1) * sizeof(V)); \ \ _list_->buffer[--_list_->count] = (V){ 0 }; \ - _list_->flag = cmc_flags.OK; \ + _list_->flag = CMC_FLAG_OK; \ \ if (_list_->callbacks && _list_->callbacks->delete) \ _list_->callbacks->delete (); \ @@ -409,17 +425,17 @@ static const char *cmc_string_fmt_list = "struct %s<%s> " return true; \ } \ \ - bool PFX##_pop_at(struct SNAME *_list_, size_t index) \ + bool CMC_(PFX, _pop_at)(struct SNAME * _list_, size_t index) \ { \ - if (PFX##_empty(_list_)) \ + if (CMC_(PFX, _empty)(_list_)) \ { \ - _list_->flag = cmc_flags.EMPTY; \ + _list_->flag = CMC_FLAG_EMPTY; \ return false; \ } \ \ if (index >= _list_->count) \ { \ - _list_->flag = cmc_flags.RANGE; \ + _list_->flag = CMC_FLAG_RANGE; \ return false; \ } \ \ @@ -427,7 +443,7 @@ static const char *cmc_string_fmt_list = "struct %s<%s> " (_list_->count - index - 1) * sizeof(V)); \ \ _list_->buffer[--_list_->count] = (V){ 0 }; \ - _list_->flag = cmc_flags.OK; \ + _list_->flag = CMC_FLAG_OK; \ \ if (_list_->callbacks && _list_->callbacks->delete) \ _list_->callbacks->delete (); \ @@ -435,13 +451,13 @@ static const char *cmc_string_fmt_list = "struct %s<%s> " return true; \ } \ \ - bool PFX##_pop_back(struct SNAME *_list_) \ + bool CMC_(PFX, _pop_back)(struct SNAME * _list_) \ { \ - if (PFX##_empty(_list_)) \ + if (CMC_(PFX, _empty)(_list_)) \ return false; \ \ _list_->buffer[--_list_->count] = (V){ 0 }; \ - _list_->flag = cmc_flags.OK; \ + _list_->flag = CMC_FLAG_OK; \ \ if (_list_->callbacks && _list_->callbacks->delete) \ _list_->callbacks->delete (); \ @@ -449,17 +465,18 @@ static const char *cmc_string_fmt_list = "struct %s<%s> " return true; \ } \ \ - bool PFX##_seq_push_front(struct SNAME *_list_, V *values, size_t size) \ + bool CMC_(PFX, _seq_push_front)(struct SNAME * _list_, V * values, \ + size_t size) \ { \ if (size == 0) \ { \ - _list_->flag = cmc_flags.INVALID; \ + _list_->flag = CMC_FLAG_INVALID; \ return false; \ } \ \ - if (!PFX##_fits(_list_, size)) \ + if (!CMC_(PFX, _fits)(_list_, size)) \ { \ - if (!PFX##_resize(_list_, _list_->count + size)) \ + if (!CMC_(PFX, _resize)(_list_, _list_->count + size)) \ return false; \ } \ \ @@ -469,7 +486,7 @@ static const char *cmc_string_fmt_list = "struct %s<%s> " memcpy(_list_->buffer, values, size * sizeof(V)); \ \ _list_->count += size; \ - _list_->flag = cmc_flags.OK; \ + _list_->flag = CMC_FLAG_OK; \ \ if (_list_->callbacks && _list_->callbacks->create) \ _list_->callbacks->create(); \ @@ -477,29 +494,29 @@ static const char *cmc_string_fmt_list = "struct %s<%s> " return true; \ } \ \ - bool PFX##_seq_push_at(struct SNAME *_list_, V *values, size_t size, \ - size_t index) \ + bool CMC_(PFX, _seq_push_at)(struct SNAME * _list_, V * values, \ + size_t size, size_t index) \ { \ if (size == 0) \ { \ - _list_->flag = cmc_flags.INVALID; \ + _list_->flag = CMC_FLAG_INVALID; \ return false; \ } \ \ if (index > _list_->count) \ { \ - _list_->flag = cmc_flags.RANGE; \ + _list_->flag = CMC_FLAG_RANGE; \ return false; \ } \ \ if (index == 0) \ - return PFX##_seq_push_front(_list_, values, size); \ + return CMC_(PFX, _seq_push_front)(_list_, values, size); \ else if (index == _list_->count) \ - return PFX##_seq_push_back(_list_, values, size); \ + return CMC_(PFX, _seq_push_back)(_list_, values, size); \ \ - if (!PFX##_fits(_list_, size)) \ + if (!CMC_(PFX, _fits)(_list_, size)) \ { \ - if (!PFX##_resize(_list_, _list_->count + size)) \ + if (!CMC_(PFX, _resize)(_list_, _list_->count + size)) \ return false; \ } \ \ @@ -509,7 +526,7 @@ static const char *cmc_string_fmt_list = "struct %s<%s> " memcpy(_list_->buffer + index, values, size * sizeof(V)); \ \ _list_->count += size; \ - _list_->flag = cmc_flags.OK; \ + _list_->flag = CMC_FLAG_OK; \ \ if (_list_->callbacks && _list_->callbacks->create) \ _list_->callbacks->create(); \ @@ -517,24 +534,25 @@ static const char *cmc_string_fmt_list = "struct %s<%s> " return true; \ } \ \ - bool PFX##_seq_push_back(struct SNAME *_list_, V *values, size_t size) \ + bool CMC_(PFX, _seq_push_back)(struct SNAME * _list_, V * values, \ + size_t size) \ { \ if (size == 0) \ { \ - _list_->flag = cmc_flags.INVALID; \ + _list_->flag = CMC_FLAG_INVALID; \ return false; \ } \ \ - if (!PFX##_fits(_list_, size)) \ + if (!CMC_(PFX, _fits)(_list_, size)) \ { \ - if (!PFX##_resize(_list_, _list_->count + size)) \ + if (!CMC_(PFX, _resize)(_list_, _list_->count + size)) \ return false; \ } \ \ memcpy(_list_->buffer + _list_->count, values, size * sizeof(V)); \ \ _list_->count += size; \ - _list_->flag = cmc_flags.OK; \ + _list_->flag = CMC_FLAG_OK; \ \ if (_list_->callbacks && _list_->callbacks->create) \ _list_->callbacks->create(); \ @@ -542,17 +560,17 @@ static const char *cmc_string_fmt_list = "struct %s<%s> " return true; \ } \ \ - bool PFX##_seq_pop_at(struct SNAME *_list_, size_t from, size_t to) \ + bool CMC_(PFX, _seq_pop_at)(struct SNAME * _list_, size_t from, size_t to) \ { \ if (from > to) \ { \ - _list_->flag = cmc_flags.INVALID; \ + _list_->flag = CMC_FLAG_INVALID; \ return false; \ } \ \ if (to >= _list_->count) \ { \ - _list_->flag = cmc_flags.RANGE; \ + _list_->flag = CMC_FLAG_RANGE; \ return false; \ } \ \ @@ -565,7 +583,7 @@ static const char *cmc_string_fmt_list = "struct %s<%s> " length * sizeof(V)); \ \ _list_->count -= to - from + 1; \ - _list_->flag = cmc_flags.OK; \ + _list_->flag = CMC_FLAG_OK; \ \ if (_list_->callbacks && _list_->callbacks->delete) \ _list_->callbacks->delete (); \ @@ -573,29 +591,29 @@ static const char *cmc_string_fmt_list = "struct %s<%s> " return true; \ } \ \ - struct SNAME *PFX##_seq_sublist(struct SNAME *_list_, size_t from, \ - size_t to) \ + struct SNAME *CMC_(PFX, _seq_sublist)(struct SNAME * _list_, size_t from, \ + size_t to) \ { \ if (from > to) \ { \ - _list_->flag = cmc_flags.INVALID; \ + _list_->flag = CMC_FLAG_INVALID; \ return NULL; \ } \ \ if (to >= _list_->count) \ { \ - _list_->flag = cmc_flags.RANGE; \ + _list_->flag = CMC_FLAG_RANGE; \ return NULL; \ } \ \ size_t length = to - from + 1; \ \ - struct SNAME *result = PFX##_new_custom( \ + struct SNAME *result = CMC_(PFX, _new_custom)( \ length, _list_->f_val, _list_->alloc, _list_->callbacks); \ \ if (!result) \ { \ - _list_->flag = cmc_flags.ALLOC; \ + _list_->flag = CMC_FLAG_ALLOC; \ return NULL; \ } \ \ @@ -610,7 +628,7 @@ static const char *cmc_string_fmt_list = "struct %s<%s> " _list_->count -= length; \ result->count = length; \ \ - _list_->flag = cmc_flags.OK; \ + _list_->flag = CMC_FLAG_OK; \ \ if (_list_->callbacks && _list_->callbacks->delete) \ _list_->callbacks->delete (); \ @@ -618,15 +636,15 @@ static const char *cmc_string_fmt_list = "struct %s<%s> " return result; \ } \ \ - V PFX##_front(struct SNAME *_list_) \ + V CMC_(PFX, _front)(struct SNAME * _list_) \ { \ - if (PFX##_empty(_list_)) \ + if (CMC_(PFX, _empty)(_list_)) \ { \ - _list_->flag = cmc_flags.EMPTY; \ + _list_->flag = CMC_FLAG_EMPTY; \ return (V){ 0 }; \ } \ \ - _list_->flag = cmc_flags.OK; \ + _list_->flag = CMC_FLAG_OK; \ \ if (_list_->callbacks && _list_->callbacks->read) \ _list_->callbacks->read(); \ @@ -634,21 +652,21 @@ static const char *cmc_string_fmt_list = "struct %s<%s> " return _list_->buffer[0]; \ } \ \ - V PFX##_get(struct SNAME *_list_, size_t index) \ + V CMC_(PFX, _get)(struct SNAME * _list_, size_t index) \ { \ - if (PFX##_empty(_list_)) \ + if (CMC_(PFX, _empty)(_list_)) \ { \ - _list_->flag = cmc_flags.EMPTY; \ + _list_->flag = CMC_FLAG_EMPTY; \ return (V){ 0 }; \ } \ \ if (index >= _list_->count) \ { \ - _list_->flag = cmc_flags.RANGE; \ + _list_->flag = CMC_FLAG_RANGE; \ return (V){ 0 }; \ } \ \ - _list_->flag = cmc_flags.OK; \ + _list_->flag = CMC_FLAG_OK; \ \ if (_list_->callbacks && _list_->callbacks->read) \ _list_->callbacks->read(); \ @@ -656,21 +674,21 @@ static const char *cmc_string_fmt_list = "struct %s<%s> " return _list_->buffer[index]; \ } \ \ - V *PFX##_get_ref(struct SNAME *_list_, size_t index) \ + V *CMC_(PFX, _get_ref)(struct SNAME * _list_, size_t index) \ { \ - if (PFX##_empty(_list_)) \ + if (CMC_(PFX, _empty)(_list_)) \ { \ - _list_->flag = cmc_flags.EMPTY; \ + _list_->flag = CMC_FLAG_EMPTY; \ return NULL; \ } \ \ if (index >= _list_->count) \ { \ - _list_->flag = cmc_flags.RANGE; \ + _list_->flag = CMC_FLAG_RANGE; \ return NULL; \ } \ \ - _list_->flag = cmc_flags.OK; \ + _list_->flag = CMC_FLAG_OK; \ \ if (_list_->callbacks && _list_->callbacks->read) \ _list_->callbacks->read(); \ @@ -678,15 +696,15 @@ static const char *cmc_string_fmt_list = "struct %s<%s> " return &(_list_->buffer[index]); \ } \ \ - V PFX##_back(struct SNAME *_list_) \ + V CMC_(PFX, _back)(struct SNAME * _list_) \ { \ - if (PFX##_empty(_list_)) \ + if (CMC_(PFX, _empty)(_list_)) \ { \ - _list_->flag = cmc_flags.EMPTY; \ + _list_->flag = CMC_FLAG_EMPTY; \ return (V){ 0 }; \ } \ \ - _list_->flag = cmc_flags.OK; \ + _list_->flag = CMC_FLAG_OK; \ \ if (_list_->callbacks && _list_->callbacks->read) \ _list_->callbacks->read(); \ @@ -694,9 +712,10 @@ static const char *cmc_string_fmt_list = "struct %s<%s> " return _list_->buffer[_list_->count - 1]; \ } \ \ - size_t PFX##_index_of(struct SNAME *_list_, V value, bool from_start) \ + size_t CMC_(PFX, _index_of)(struct SNAME * _list_, V value, \ + bool from_start) \ { \ - _list_->flag = cmc_flags.OK; \ + _list_->flag = CMC_FLAG_OK; \ \ size_t result = _list_->count; \ \ @@ -729,9 +748,9 @@ static const char *cmc_string_fmt_list = "struct %s<%s> " return result; \ } \ \ - bool PFX##_contains(struct SNAME *_list_, V value) \ + bool CMC_(PFX, _contains)(struct SNAME * _list_, V value) \ { \ - _list_->flag = cmc_flags.OK; \ + _list_->flag = CMC_FLAG_OK; \ \ bool result = false; \ \ @@ -750,46 +769,46 @@ static const char *cmc_string_fmt_list = "struct %s<%s> " return result; \ } \ \ - bool PFX##_empty(struct SNAME *_list_) \ + bool CMC_(PFX, _empty)(struct SNAME * _list_) \ { \ return _list_->count == 0; \ } \ \ - bool PFX##_full(struct SNAME *_list_) \ + bool CMC_(PFX, _full)(struct SNAME * _list_) \ { \ return _list_->count >= _list_->capacity; \ } \ \ - size_t PFX##_count(struct SNAME *_list_) \ + size_t CMC_(PFX, _count)(struct SNAME * _list_) \ { \ return _list_->count; \ } \ \ - bool PFX##_fits(struct SNAME *_list_, size_t size) \ + bool CMC_(PFX, _fits)(struct SNAME * _list_, size_t size) \ { \ return _list_->count + size <= _list_->capacity; \ } \ \ - size_t PFX##_capacity(struct SNAME *_list_) \ + size_t CMC_(PFX, _capacity)(struct SNAME * _list_) \ { \ return _list_->capacity; \ } \ \ - int PFX##_flag(struct SNAME *_list_) \ + int CMC_(PFX, _flag)(struct SNAME * _list_) \ { \ return _list_->flag; \ } \ \ - bool PFX##_resize(struct SNAME *_list_, size_t capacity) \ + bool CMC_(PFX, _resize)(struct SNAME * _list_, size_t capacity) \ { \ - _list_->flag = cmc_flags.OK; \ + _list_->flag = CMC_FLAG_OK; \ \ if (_list_->capacity == capacity) \ return true; \ \ if (capacity < _list_->count) \ { \ - _list_->flag = cmc_flags.INVALID; \ + _list_->flag = CMC_FLAG_INVALID; \ return false; \ } \ \ @@ -798,7 +817,7 @@ static const char *cmc_string_fmt_list = "struct %s<%s> " \ if (!new_buffer) \ { \ - _list_->flag = cmc_flags.ALLOC; \ + _list_->flag = CMC_FLAG_ALLOC; \ return false; \ } \ \ @@ -813,15 +832,15 @@ static const char *cmc_string_fmt_list = "struct %s<%s> " return true; \ } \ \ - struct SNAME *PFX##_copy_of(struct SNAME *_list_) \ + struct SNAME *CMC_(PFX, _copy_of)(struct SNAME * _list_) \ { \ struct SNAME *result = \ - PFX##_new_custom(_list_->capacity, _list_->f_val, _list_->alloc, \ - _list_->callbacks); \ + CMC_(PFX, _new_custom)(_list_->capacity, _list_->f_val, \ + _list_->alloc, _list_->callbacks); \ \ if (!result) \ { \ - _list_->flag = cmc_flags.ALLOC; \ + _list_->flag = CMC_FLAG_ALLOC; \ return NULL; \ } \ \ @@ -835,15 +854,15 @@ static const char *cmc_string_fmt_list = "struct %s<%s> " \ result->count = _list_->count; \ \ - _list_->flag = cmc_flags.OK; \ + _list_->flag = CMC_FLAG_OK; \ \ return result; \ } \ \ - bool PFX##_equals(struct SNAME *_list1_, struct SNAME *_list2_) \ + bool CMC_(PFX, _equals)(struct SNAME * _list1_, struct SNAME * _list2_) \ { \ - _list1_->flag = cmc_flags.OK; \ - _list2_->flag = cmc_flags.OK; \ + _list1_->flag = CMC_FLAG_OK; \ + _list2_->flag = CMC_FLAG_OK; \ \ if (_list1_->count != _list2_->count) \ return false; \ @@ -858,19 +877,19 @@ static const char *cmc_string_fmt_list = "struct %s<%s> " return true; \ } \ \ - struct cmc_string PFX##_to_string(struct SNAME *_list_) \ + struct cmc_string CMC_(PFX, _to_string)(struct SNAME * _list_) \ { \ struct cmc_string str; \ struct SNAME *l_ = _list_; \ \ - int n = snprintf(str.s, cmc_string_len, cmc_string_fmt_list, #SNAME, \ - #V, l_, l_->buffer, l_->capacity, l_->count, \ + int n = snprintf(str.s, cmc_string_len, cmc_cmc_string_fmt_list, \ + #SNAME, #V, l_, l_->buffer, l_->capacity, l_->count, \ l_->flag, l_->f_val, l_->alloc, l_->callbacks); \ \ return n >= 0 ? str : (struct cmc_string){ 0 }; \ } \ \ - bool PFX##_print(struct SNAME *_list_, FILE *fptr) \ + bool CMC_(PFX, _print)(struct SNAME * _list_, FILE * fptr) \ { \ for (size_t i = 0; i < _list_->count; i++) \ { \ @@ -881,50 +900,50 @@ static const char *cmc_string_fmt_list = "struct %s<%s> " return true; \ } \ \ - struct SNAME##_iter PFX##_iter_start(struct SNAME *target) \ + struct CMC_DEF_ITER(SNAME) CMC_(PFX, _iter_start)(struct SNAME * target) \ { \ - struct SNAME##_iter iter; \ + struct CMC_DEF_ITER(SNAME) iter; \ \ iter.target = target; \ iter.cursor = 0; \ iter.start = true; \ - iter.end = PFX##_empty(target); \ + iter.end = CMC_(PFX, _empty)(target); \ \ return iter; \ } \ \ - struct SNAME##_iter PFX##_iter_end(struct SNAME *target) \ + struct CMC_DEF_ITER(SNAME) CMC_(PFX, _iter_end)(struct SNAME * target) \ { \ - struct SNAME##_iter iter; \ + struct CMC_DEF_ITER(SNAME) iter; \ \ iter.target = target; \ iter.cursor = 0; \ - iter.start = PFX##_empty(target); \ + iter.start = CMC_(PFX, _empty)(target); \ iter.end = true; \ \ - if (!PFX##_empty(target)) \ + if (!CMC_(PFX, _empty)(target)) \ iter.cursor = target->count - 1; \ \ return iter; \ } \ \ - bool PFX##_iter_at_start(struct SNAME##_iter *iter) \ + bool CMC_(PFX, _iter_at_start)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ - return PFX##_empty(iter->target) || iter->start; \ + return CMC_(PFX, _empty)(iter->target) || iter->start; \ } \ \ - bool PFX##_iter_at_end(struct SNAME##_iter *iter) \ + bool CMC_(PFX, _iter_at_end)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ - return PFX##_empty(iter->target) || iter->end; \ + return CMC_(PFX, _empty)(iter->target) || iter->end; \ } \ \ - bool PFX##_iter_to_start(struct SNAME##_iter *iter) \ + bool CMC_(PFX, _iter_to_start)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ - if (!PFX##_empty(iter->target)) \ + if (!CMC_(PFX, _empty)(iter->target)) \ { \ iter->cursor = 0; \ iter->start = true; \ - iter->end = PFX##_empty(iter->target); \ + iter->end = CMC_(PFX, _empty)(iter->target); \ \ return true; \ } \ @@ -932,11 +951,11 @@ static const char *cmc_string_fmt_list = "struct %s<%s> " return false; \ } \ \ - bool PFX##_iter_to_end(struct SNAME##_iter *iter) \ + bool CMC_(PFX, _iter_to_end)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ - if (!PFX##_empty(iter->target)) \ + if (!CMC_(PFX, _empty)(iter->target)) \ { \ - iter->start = PFX##_empty(iter->target); \ + iter->start = CMC_(PFX, _empty)(iter->target); \ iter->cursor = iter->target->count - 1; \ iter->end = true; \ \ @@ -946,7 +965,7 @@ static const char *cmc_string_fmt_list = "struct %s<%s> " return false; \ } \ \ - bool PFX##_iter_next(struct SNAME##_iter *iter) \ + bool CMC_(PFX, _iter_next)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ if (iter->end) \ return false; \ @@ -957,14 +976,14 @@ static const char *cmc_string_fmt_list = "struct %s<%s> " return false; \ } \ \ - iter->start = PFX##_empty(iter->target); \ + iter->start = CMC_(PFX, _empty)(iter->target); \ \ iter->cursor++; \ \ return true; \ } \ \ - bool PFX##_iter_prev(struct SNAME##_iter *iter) \ + bool CMC_(PFX, _iter_prev)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ if (iter->start) \ return false; \ @@ -975,7 +994,7 @@ static const char *cmc_string_fmt_list = "struct %s<%s> " return false; \ } \ \ - iter->end = PFX##_empty(iter->target); \ + iter->end = CMC_(PFX, _empty)(iter->target); \ \ iter->cursor--; \ \ @@ -983,7 +1002,8 @@ static const char *cmc_string_fmt_list = "struct %s<%s> " } \ \ /* Returns true only if the iterator moved */ \ - bool PFX##_iter_advance(struct SNAME##_iter *iter, size_t steps) \ + bool CMC_(PFX, _iter_advance)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t steps) \ { \ if (iter->end) \ return false; \ @@ -997,7 +1017,7 @@ static const char *cmc_string_fmt_list = "struct %s<%s> " if (steps == 0 || iter->cursor + steps >= iter->target->count) \ return false; \ \ - iter->start = PFX##_empty(iter->target); \ + iter->start = CMC_(PFX, _empty)(iter->target); \ \ iter->cursor += steps; \ \ @@ -1005,7 +1025,8 @@ static const char *cmc_string_fmt_list = "struct %s<%s> " } \ \ /* Returns true only if the iterator moved */ \ - bool PFX##_iter_rewind(struct SNAME##_iter *iter, size_t steps) \ + bool CMC_(PFX, _iter_rewind)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t steps) \ { \ if (iter->start) \ return false; \ @@ -1019,7 +1040,7 @@ static const char *cmc_string_fmt_list = "struct %s<%s> " if (steps == 0 || iter->cursor < steps) \ return false; \ \ - iter->end = PFX##_empty(iter->target); \ + iter->end = CMC_(PFX, _empty)(iter->target); \ \ iter->cursor -= steps; \ \ @@ -1028,38 +1049,39 @@ static const char *cmc_string_fmt_list = "struct %s<%s> " \ /* Returns true only if the iterator was able to be positioned at the */ \ /* given index */ \ - bool PFX##_iter_go_to(struct SNAME##_iter *iter, size_t index) \ + bool CMC_(PFX, _iter_go_to)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t index) \ { \ if (index >= iter->target->count) \ return false; \ \ if (iter->cursor > index) \ - return PFX##_iter_rewind(iter, iter->cursor - index); \ + return CMC_(PFX, _iter_rewind)(iter, iter->cursor - index); \ else if (iter->cursor < index) \ - return PFX##_iter_advance(iter, index - iter->cursor); \ + return CMC_(PFX, _iter_advance)(iter, index - iter->cursor); \ \ return true; \ } \ \ - V PFX##_iter_value(struct SNAME##_iter *iter) \ + V CMC_(PFX, _iter_value)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ - if (PFX##_empty(iter->target)) \ + if (CMC_(PFX, _empty)(iter->target)) \ return (V){ 0 }; \ \ return iter->target->buffer[iter->cursor]; \ } \ \ - V *PFX##_iter_rvalue(struct SNAME##_iter *iter) \ + V *CMC_(PFX, _iter_rvalue)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ - if (PFX##_empty(iter->target)) \ + if (CMC_(PFX, _empty)(iter->target)) \ return NULL; \ \ return &(iter->target->buffer[iter->cursor]); \ } \ \ - size_t PFX##_iter_index(struct SNAME##_iter *iter) \ + size_t CMC_(PFX, _iter_index)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ return iter->cursor; \ } -#endif /* CMC_LIST_H */ +#endif /* CMC_CMC_LIST_H */ diff --git a/src/cmc/queue.h b/src/cmc/queue.h index 10f3fb0..4f2148f 100644 --- a/src/cmc/queue.h +++ b/src/cmc/queue.h @@ -40,8 +40,8 @@ * the resource. */ -#ifndef CMC_QUEUE_H -#define CMC_QUEUE_H +#ifndef CMC_CMC_QUEUE_H +#define CMC_CMC_QUEUE_H /* ------------------------------------------------------------------------- * Core functionalities of the C Macro Collections Library @@ -52,164 +52,175 @@ * Queue specific * ------------------------------------------------------------------------- */ /* to_string format */ -static const char *cmc_string_fmt_queue = "struct %s<%s> " - "at %p { " - "buffer:%p, " - "capacity:%" PRIuMAX ", " - "count:%" PRIuMAX ", " - "front:%" PRIuMAX ", " - "back:%" PRIuMAX ", " - "flag:%d, " - "f_val:%p, " - "alloc:%p, " - "callbacks:%p }"; +static const char *cmc_cmc_string_fmt_queue = "struct %s<%s> " + "at %p { " + "buffer:%p, " + "capacity:%" PRIuMAX ", " + "count:%" PRIuMAX ", " + "front:%" PRIuMAX ", " + "back:%" PRIuMAX ", " + "flag:%d, " + "f_val:%p, " + "alloc:%p, " + "callbacks:%p }"; -#define CMC_GENERATE_QUEUE(PFX, SNAME, V) \ - CMC_GENERATE_QUEUE_HEADER(PFX, SNAME, V) \ - CMC_GENERATE_QUEUE_SOURCE(PFX, SNAME, V) +/** + * Core Queue implementation + */ +#define CMC_CMC_QUEUE_CORE(BODY) \ + CMC_CMC_QUEUE_CORE_HEADER(BODY) \ + CMC_CMC_QUEUE_CORE_SOURCE(BODY) -#define CMC_WRAPGEN_QUEUE_HEADER(PFX, SNAME, K, V) \ - CMC_GENERATE_QUEUE_HEADER(PFX, SNAME, V) +#define CMC_CMC_QUEUE_CORE_HEADER(BODY) \ + CMC_CMC_QUEUE_CORE_HEADER_(CMC_PARAM_PFX(BODY), CMC_PARAM_SNAME(BODY), \ + CMC_PARAM_V(BODY)) -#define CMC_WRAPGEN_QUEUE_SOURCE(PFX, SNAME, K, V) \ - CMC_GENERATE_QUEUE_SOURCE(PFX, SNAME, V) +#define CMC_CMC_QUEUE_CORE_SOURCE(BODY) \ + CMC_CMC_QUEUE_CORE_SOURCE_(CMC_PARAM_PFX(BODY), CMC_PARAM_SNAME(BODY), \ + CMC_PARAM_V(BODY)) /* ------------------------------------------------------------------------- * Header * ------------------------------------------------------------------------- */ -#define CMC_GENERATE_QUEUE_HEADER(PFX, SNAME, V) \ - \ - /* Queue Structure */ \ - struct SNAME \ - { \ - /* Dynamic circular array of elements */ \ - V *buffer; \ - \ - /* Current circular array capacity */ \ - size_t capacity; \ - \ - /* Current amount of elements */ \ - size_t count; \ - \ - /* Index representing the front of the queue */ \ - size_t front; \ - \ - /* Index representing the back of the queue */ \ - size_t back; \ - \ - /* Flags indicating errors or success */ \ - int flag; \ - \ - /* Value function table */ \ - struct SNAME##_fval *f_val; \ - \ - /* Custom allocation functions */ \ - struct cmc_alloc_node *alloc; \ - \ - /* Custom callback functions */ \ - struct cmc_callbacks *callbacks; \ - }; \ - \ - /* Value struct function table */ \ - struct SNAME##_fval \ - { \ - /* Comparator function */ \ - int (*cmp)(V, V); \ - \ - /* Copy function */ \ - V (*cpy)(V); \ - \ - /* To string function */ \ - bool (*str)(FILE *, V); \ - \ - /* Free from memory function */ \ - void (*free)(V); \ - \ - /* Hash function */ \ - size_t (*hash)(V); \ - \ - /* Priority function */ \ - int (*pri)(V, V); \ - }; \ - \ - /* Queue Iterator */ \ - struct SNAME##_iter \ - { \ - /* Target queue */ \ - struct SNAME *target; \ - \ - /* Cursor's position (index) */ \ - size_t cursor; \ - \ - /* Keeps track of relative index to the iteration of elements */ \ - size_t index; \ - \ - /* If the iterator has reached the start of the iteration */ \ - bool start; \ - \ - /* If the iterator has reached the end of the iteration */ \ - bool end; \ - }; \ - \ - /* Collection Functions */ \ - /* Collection Allocation and Deallocation */ \ - struct SNAME *PFX##_new(size_t capacity, struct SNAME##_fval *f_val); \ - struct SNAME *PFX##_new_custom( \ - size_t capacity, struct SNAME##_fval *f_val, \ - struct cmc_alloc_node *alloc, struct cmc_callbacks *callbacks); \ - void PFX##_clear(struct SNAME *_queue_); \ - void PFX##_free(struct SNAME *_queue_); \ - /* Customization of Allocation and Callbacks */ \ - void PFX##_customize(struct SNAME *_queue_, struct cmc_alloc_node *alloc, \ - struct cmc_callbacks *callbacks); \ - /* Collection Input and Output */ \ - bool PFX##_enqueue(struct SNAME *_queue_, V value); \ - bool PFX##_dequeue(struct SNAME *_queue_); \ - /* Element Access */ \ - V PFX##_peek(struct SNAME *_queue_); \ - /* Collection State */ \ - bool PFX##_contains(struct SNAME *_queue_, V value); \ - bool PFX##_empty(struct SNAME *_queue_); \ - bool PFX##_full(struct SNAME *_queue_); \ - size_t PFX##_count(struct SNAME *_queue_); \ - size_t PFX##_capacity(struct SNAME *_queue_); \ - int PFX##_flag(struct SNAME *_queue_); \ - /* Collection Utility */ \ - bool PFX##_resize(struct SNAME *_queue_, size_t capacity); \ - struct SNAME *PFX##_copy_of(struct SNAME *_queue_); \ - bool PFX##_equals(struct SNAME *_queue1_, struct SNAME *_queue2_); \ - struct cmc_string PFX##_to_string(struct SNAME *_queue_); \ - bool PFX##_print(struct SNAME *_queue_, FILE *fptr); \ - \ - /* Iterator Functions */ \ - /* Iterator Initialization */ \ - struct SNAME##_iter PFX##_iter_start(struct SNAME *target); \ - struct SNAME##_iter PFX##_iter_end(struct SNAME *target); \ - /* Iterator State */ \ - bool PFX##_iter_at_start(struct SNAME##_iter *iter); \ - bool PFX##_iter_at_end(struct SNAME##_iter *iter); \ - /* Iterator Movement */ \ - bool PFX##_iter_to_start(struct SNAME##_iter *iter); \ - bool PFX##_iter_to_end(struct SNAME##_iter *iter); \ - bool PFX##_iter_next(struct SNAME##_iter *iter); \ - bool PFX##_iter_prev(struct SNAME##_iter *iter); \ - bool PFX##_iter_advance(struct SNAME##_iter *iter, size_t steps); \ - bool PFX##_iter_rewind(struct SNAME##_iter *iter, size_t steps); \ - bool PFX##_iter_go_to(struct SNAME##_iter *iter, size_t index); \ - /* Iterator Access */ \ - V PFX##_iter_value(struct SNAME##_iter *iter); \ - V *PFX##_iter_rvalue(struct SNAME##_iter *iter); \ - size_t PFX##_iter_index(struct SNAME##_iter *iter); +#define CMC_CMC_QUEUE_CORE_HEADER_(PFX, SNAME, V) \ + \ + /* Queue Structure */ \ + struct SNAME \ + { \ + /* Dynamic circular array of elements */ \ + V *buffer; \ + \ + /* Current circular array capacity */ \ + size_t capacity; \ + \ + /* Current amount of elements */ \ + size_t count; \ + \ + /* Index representing the front of the queue */ \ + size_t front; \ + \ + /* Index representing the back of the queue */ \ + size_t back; \ + \ + /* Flags indicating errors or success */ \ + int flag; \ + \ + /* Value function table */ \ + struct CMC_DEF_FVAL(SNAME) * f_val; \ + \ + /* Custom allocation functions */ \ + struct cmc_alloc_node *alloc; \ + \ + /* Custom callback functions */ \ + struct cmc_callbacks *callbacks; \ + }; \ + \ + /* Value struct function table */ \ + struct CMC_DEF_FVAL(SNAME) \ + { \ + /* Comparator function */ \ + int (*cmp)(V, V); \ + \ + /* Copy function */ \ + V (*cpy)(V); \ + \ + /* To string function */ \ + bool (*str)(FILE *, V); \ + \ + /* Free from memory function */ \ + void (*free)(V); \ + \ + /* Hash function */ \ + size_t (*hash)(V); \ + \ + /* Priority function */ \ + int (*pri)(V, V); \ + }; \ + \ + /* Queue Iterator */ \ + struct CMC_DEF_ITER(SNAME) \ + { \ + /* Target queue */ \ + struct SNAME *target; \ + \ + /* Cursor's position (index) */ \ + size_t cursor; \ + \ + /* Keeps track of relative index to the iteration of elements */ \ + size_t index; \ + \ + /* If the iterator has reached the start of the iteration */ \ + bool start; \ + \ + /* If the iterator has reached the end of the iteration */ \ + bool end; \ + }; \ + \ + /* Collection Functions */ \ + /* Collection Allocation and Deallocation */ \ + struct SNAME *CMC_(PFX, _new)(size_t capacity, \ + struct CMC_DEF_FVAL(SNAME) * f_val); \ + struct SNAME *CMC_(PFX, _new_custom)( \ + size_t capacity, struct CMC_DEF_FVAL(SNAME) * f_val, \ + struct cmc_alloc_node * alloc, struct cmc_callbacks * callbacks); \ + void CMC_(PFX, _clear)(struct SNAME * _queue_); \ + void CMC_(PFX, _free)(struct SNAME * _queue_); \ + /* Customization of Allocation and Callbacks */ \ + void CMC_(PFX, _customize)(struct SNAME * _queue_, \ + struct cmc_alloc_node * alloc, \ + struct cmc_callbacks * callbacks); \ + /* Collection Input and Output */ \ + bool CMC_(PFX, _enqueue)(struct SNAME * _queue_, V value); \ + bool CMC_(PFX, _dequeue)(struct SNAME * _queue_); \ + /* Element Access */ \ + V CMC_(PFX, _peek)(struct SNAME * _queue_); \ + /* Collection State */ \ + bool CMC_(PFX, _contains)(struct SNAME * _queue_, V value); \ + bool CMC_(PFX, _empty)(struct SNAME * _queue_); \ + bool CMC_(PFX, _full)(struct SNAME * _queue_); \ + size_t CMC_(PFX, _count)(struct SNAME * _queue_); \ + size_t CMC_(PFX, _capacity)(struct SNAME * _queue_); \ + int CMC_(PFX, _flag)(struct SNAME * _queue_); \ + /* Collection Utility */ \ + bool CMC_(PFX, _resize)(struct SNAME * _queue_, size_t capacity); \ + struct SNAME *CMC_(PFX, _copy_of)(struct SNAME * _queue_); \ + bool CMC_(PFX, _equals)(struct SNAME * _queue1_, struct SNAME * _queue2_); \ + struct cmc_string CMC_(PFX, _to_string)(struct SNAME * _queue_); \ + bool CMC_(PFX, _print)(struct SNAME * _queue_, FILE * fptr); \ + \ + /* Iterator Functions */ \ + /* Iterator Initialization */ \ + struct CMC_DEF_ITER(SNAME) CMC_(PFX, _iter_start)(struct SNAME * target); \ + struct CMC_DEF_ITER(SNAME) CMC_(PFX, _iter_end)(struct SNAME * target); \ + /* Iterator State */ \ + bool CMC_(PFX, _iter_at_start)(struct CMC_DEF_ITER(SNAME) * iter); \ + bool CMC_(PFX, _iter_at_end)(struct CMC_DEF_ITER(SNAME) * iter); \ + /* Iterator Movement */ \ + bool CMC_(PFX, _iter_to_start)(struct CMC_DEF_ITER(SNAME) * iter); \ + bool CMC_(PFX, _iter_to_end)(struct CMC_DEF_ITER(SNAME) * iter); \ + bool CMC_(PFX, _iter_next)(struct CMC_DEF_ITER(SNAME) * iter); \ + bool CMC_(PFX, _iter_prev)(struct CMC_DEF_ITER(SNAME) * iter); \ + bool CMC_(PFX, _iter_advance)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t steps); \ + bool CMC_(PFX, _iter_rewind)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t steps); \ + bool CMC_(PFX, _iter_go_to)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t index); \ + /* Iterator Access */ \ + V CMC_(PFX, _iter_value)(struct CMC_DEF_ITER(SNAME) * iter); \ + V *CMC_(PFX, _iter_rvalue)(struct CMC_DEF_ITER(SNAME) * iter); \ + size_t CMC_(PFX, _iter_index)(struct CMC_DEF_ITER(SNAME) * iter); /* ------------------------------------------------------------------------- * Source * ------------------------------------------------------------------------- */ -#define CMC_GENERATE_QUEUE_SOURCE(PFX, SNAME, V) \ +#define CMC_CMC_QUEUE_CORE_SOURCE_(PFX, SNAME, V) \ \ /* Implementation Detail Functions */ \ /* None */ \ \ - struct SNAME *PFX##_new(size_t capacity, struct SNAME##_fval *f_val) \ + struct SNAME *CMC_(PFX, _new)(size_t capacity, \ + struct CMC_DEF_FVAL(SNAME) * f_val) \ { \ struct cmc_alloc_node *alloc = &cmc_alloc_node_default; \ \ @@ -236,7 +247,7 @@ static const char *cmc_string_fmt_queue = "struct %s<%s> " _queue_->count = 0; \ _queue_->front = 0; \ _queue_->back = 0; \ - _queue_->flag = cmc_flags.OK; \ + _queue_->flag = CMC_FLAG_OK; \ _queue_->f_val = f_val; \ _queue_->alloc = alloc; \ _queue_->callbacks = NULL; \ @@ -244,9 +255,9 @@ static const char *cmc_string_fmt_queue = "struct %s<%s> " return _queue_; \ } \ \ - struct SNAME *PFX##_new_custom( \ - size_t capacity, struct SNAME##_fval *f_val, \ - struct cmc_alloc_node *alloc, struct cmc_callbacks *callbacks) \ + struct SNAME *CMC_(PFX, _new_custom)( \ + size_t capacity, struct CMC_DEF_FVAL(SNAME) * f_val, \ + struct cmc_alloc_node * alloc, struct cmc_callbacks * callbacks) \ { \ if (capacity < 1) \ return NULL; \ @@ -274,7 +285,7 @@ static const char *cmc_string_fmt_queue = "struct %s<%s> " _queue_->count = 0; \ _queue_->front = 0; \ _queue_->back = 0; \ - _queue_->flag = cmc_flags.OK; \ + _queue_->flag = CMC_FLAG_OK; \ _queue_->f_val = f_val; \ _queue_->alloc = alloc; \ _queue_->callbacks = callbacks; \ @@ -282,7 +293,7 @@ static const char *cmc_string_fmt_queue = "struct %s<%s> " return _queue_; \ } \ \ - void PFX##_clear(struct SNAME *_queue_) \ + void CMC_(PFX, _clear)(struct SNAME * _queue_) \ { \ if (_queue_->f_val->free) \ { \ @@ -299,10 +310,10 @@ static const char *cmc_string_fmt_queue = "struct %s<%s> " _queue_->count = 0; \ _queue_->front = 0; \ _queue_->back = 0; \ - _queue_->flag = cmc_flags.OK; \ + _queue_->flag = CMC_FLAG_OK; \ } \ \ - void PFX##_free(struct SNAME *_queue_) \ + void CMC_(PFX, _free)(struct SNAME * _queue_) \ { \ if (_queue_->f_val->free) \ { \ @@ -318,8 +329,9 @@ static const char *cmc_string_fmt_queue = "struct %s<%s> " _queue_->alloc->free(_queue_); \ } \ \ - void PFX##_customize(struct SNAME *_queue_, struct cmc_alloc_node *alloc, \ - struct cmc_callbacks *callbacks) \ + void CMC_(PFX, _customize)(struct SNAME * _queue_, \ + struct cmc_alloc_node * alloc, \ + struct cmc_callbacks * callbacks) \ { \ if (!alloc) \ _queue_->alloc = &cmc_alloc_node_default; \ @@ -328,14 +340,14 @@ static const char *cmc_string_fmt_queue = "struct %s<%s> " \ _queue_->callbacks = callbacks; \ \ - _queue_->flag = cmc_flags.OK; \ + _queue_->flag = CMC_FLAG_OK; \ } \ \ - bool PFX##_enqueue(struct SNAME *_queue_, V value) \ + bool CMC_(PFX, _enqueue)(struct SNAME * _queue_, V value) \ { \ - if (PFX##_full(_queue_)) \ + if (CMC_(PFX, _full)(_queue_)) \ { \ - if (!PFX##_resize(_queue_, _queue_->capacity * 2)) \ + if (!CMC_(PFX, _resize)(_queue_, _queue_->capacity * 2)) \ return false; \ } \ \ @@ -344,7 +356,7 @@ static const char *cmc_string_fmt_queue = "struct %s<%s> " _queue_->back = \ (_queue_->back == _queue_->capacity - 1) ? 0 : _queue_->back + 1; \ _queue_->count++; \ - _queue_->flag = cmc_flags.OK; \ + _queue_->flag = CMC_FLAG_OK; \ \ if (_queue_->callbacks && _queue_->callbacks->create) \ _queue_->callbacks->create(); \ @@ -352,11 +364,11 @@ static const char *cmc_string_fmt_queue = "struct %s<%s> " return true; \ } \ \ - bool PFX##_dequeue(struct SNAME *_queue_) \ + bool CMC_(PFX, _dequeue)(struct SNAME * _queue_) \ { \ - if (PFX##_empty(_queue_)) \ + if (CMC_(PFX, _empty)(_queue_)) \ { \ - _queue_->flag = cmc_flags.EMPTY; \ + _queue_->flag = CMC_FLAG_EMPTY; \ return false; \ } \ \ @@ -366,7 +378,7 @@ static const char *cmc_string_fmt_queue = "struct %s<%s> " ? 0 \ : _queue_->front + 1; \ _queue_->count--; \ - _queue_->flag = cmc_flags.OK; \ + _queue_->flag = CMC_FLAG_OK; \ \ if (_queue_->callbacks && _queue_->callbacks->delete) \ _queue_->callbacks->delete (); \ @@ -374,15 +386,15 @@ static const char *cmc_string_fmt_queue = "struct %s<%s> " return true; \ } \ \ - V PFX##_peek(struct SNAME *_queue_) \ + V CMC_(PFX, _peek)(struct SNAME * _queue_) \ { \ - if (PFX##_empty(_queue_)) \ + if (CMC_(PFX, _empty)(_queue_)) \ { \ - _queue_->flag = cmc_flags.EMPTY; \ + _queue_->flag = CMC_FLAG_EMPTY; \ return (V){ 0 }; \ } \ \ - _queue_->flag = cmc_flags.OK; \ + _queue_->flag = CMC_FLAG_OK; \ \ if (_queue_->callbacks && _queue_->callbacks->read) \ _queue_->callbacks->read(); \ @@ -390,9 +402,9 @@ static const char *cmc_string_fmt_queue = "struct %s<%s> " return _queue_->buffer[_queue_->front]; \ } \ \ - bool PFX##_contains(struct SNAME *_queue_, V value) \ + bool CMC_(PFX, _contains)(struct SNAME * _queue_, V value) \ { \ - _queue_->flag = cmc_flags.OK; \ + _queue_->flag = CMC_FLAG_OK; \ \ bool result = false; \ \ @@ -413,39 +425,39 @@ static const char *cmc_string_fmt_queue = "struct %s<%s> " return result; \ } \ \ - bool PFX##_empty(struct SNAME *_queue_) \ + bool CMC_(PFX, _empty)(struct SNAME * _queue_) \ { \ return _queue_->count == 0; \ } \ \ - bool PFX##_full(struct SNAME *_queue_) \ + bool CMC_(PFX, _full)(struct SNAME * _queue_) \ { \ return _queue_->count >= _queue_->capacity; \ } \ \ - size_t PFX##_count(struct SNAME *_queue_) \ + size_t CMC_(PFX, _count)(struct SNAME * _queue_) \ { \ return _queue_->count; \ } \ \ - size_t PFX##_capacity(struct SNAME *_queue_) \ + size_t CMC_(PFX, _capacity)(struct SNAME * _queue_) \ { \ return _queue_->capacity; \ } \ \ - int PFX##_flag(struct SNAME *_queue_) \ + int CMC_(PFX, _flag)(struct SNAME * _queue_) \ { \ return _queue_->flag; \ } \ \ - bool PFX##_resize(struct SNAME *_queue_, size_t capacity) \ + bool CMC_(PFX, _resize)(struct SNAME * _queue_, size_t capacity) \ { \ if (_queue_->capacity == capacity) \ goto success; \ \ if (capacity < _queue_->count) \ { \ - _queue_->flag = cmc_flags.INVALID; \ + _queue_->flag = CMC_FLAG_INVALID; \ return false; \ } \ \ @@ -453,7 +465,7 @@ static const char *cmc_string_fmt_queue = "struct %s<%s> " \ if (!new_buffer) \ { \ - _queue_->flag = cmc_flags.ALLOC; \ + _queue_->flag = CMC_FLAG_ALLOC; \ return false; \ } \ \ @@ -473,7 +485,7 @@ static const char *cmc_string_fmt_queue = "struct %s<%s> " \ success: \ \ - _queue_->flag = cmc_flags.OK; \ + _queue_->flag = CMC_FLAG_OK; \ \ if (_queue_->callbacks && _queue_->callbacks->resize) \ _queue_->callbacks->resize(); \ @@ -481,15 +493,15 @@ static const char *cmc_string_fmt_queue = "struct %s<%s> " return true; \ } \ \ - struct SNAME *PFX##_copy_of(struct SNAME *_queue_) \ + struct SNAME *CMC_(PFX, _copy_of)(struct SNAME * _queue_) \ { \ struct SNAME *result = \ - PFX##_new_custom(_queue_->capacity, _queue_->f_val, \ - _queue_->alloc, _queue_->callbacks); \ + CMC_(PFX, _new_custom)(_queue_->capacity, _queue_->f_val, \ + _queue_->alloc, _queue_->callbacks); \ \ if (!result) \ { \ - _queue_->flag = cmc_flags.ERROR; \ + _queue_->flag = CMC_FLAG_ERROR; \ return NULL; \ } \ \ @@ -516,15 +528,15 @@ static const char *cmc_string_fmt_queue = "struct %s<%s> " result->front = 0; \ result->back = _queue_->count; \ \ - _queue_->flag = cmc_flags.OK; \ + _queue_->flag = CMC_FLAG_OK; \ \ return result; \ } \ \ - bool PFX##_equals(struct SNAME *_queue1_, struct SNAME *_queue2_) \ + bool CMC_(PFX, _equals)(struct SNAME * _queue1_, struct SNAME * _queue2_) \ { \ - _queue1_->flag = cmc_flags.OK; \ - _queue2_->flag = cmc_flags.OK; \ + _queue1_->flag = CMC_FLAG_OK; \ + _queue2_->flag = CMC_FLAG_OK; \ \ if (_queue1_->count != _queue2_->count) \ return false; \ @@ -544,20 +556,20 @@ static const char *cmc_string_fmt_queue = "struct %s<%s> " return true; \ } \ \ - struct cmc_string PFX##_to_string(struct SNAME *_queue_) \ + struct cmc_string CMC_(PFX, _to_string)(struct SNAME * _queue_) \ { \ struct cmc_string str; \ struct SNAME *q_ = _queue_; \ \ int n = \ - snprintf(str.s, cmc_string_len, cmc_string_fmt_queue, #SNAME, #V, \ - q_, q_->buffer, q_->capacity, q_->count, q_->front, \ + snprintf(str.s, cmc_string_len, cmc_cmc_string_fmt_queue, #SNAME, \ + #V, q_, q_->buffer, q_->capacity, q_->count, q_->front, \ q_->back, q_->flag, q_->f_val, q_->alloc, q_->callbacks); \ \ return n >= 0 ? str : (struct cmc_string){ 0 }; \ } \ \ - bool PFX##_print(struct SNAME *_queue_, FILE *fptr) \ + bool CMC_(PFX, _print)(struct SNAME * _queue_, FILE * fptr) \ { \ for (size_t i = _queue_->front, j = 0; j < _queue_->count; j++) \ { \ @@ -570,26 +582,26 @@ static const char *cmc_string_fmt_queue = "struct %s<%s> " return true; \ } \ \ - struct SNAME##_iter PFX##_iter_start(struct SNAME *target) \ + struct CMC_DEF_ITER(SNAME) CMC_(PFX, _iter_start)(struct SNAME * target) \ { \ - struct SNAME##_iter iter; \ + struct CMC_DEF_ITER(SNAME) iter; \ \ iter.target = target; \ iter.cursor = target->front; \ iter.index = 0; \ iter.start = true; \ - iter.end = PFX##_empty(target); \ + iter.end = CMC_(PFX, _empty)(target); \ \ return iter; \ } \ \ - struct SNAME##_iter PFX##_iter_end(struct SNAME *target) \ + struct CMC_DEF_ITER(SNAME) CMC_(PFX, _iter_end)(struct SNAME * target) \ { \ - struct SNAME##_iter iter; \ + struct CMC_DEF_ITER(SNAME) iter; \ \ iter.target = target; \ \ - if (!PFX##_empty(target)) \ + if (!CMC_(PFX, _empty)(target)) \ { \ if (iter.target->back == 0) \ iter.cursor = iter.target->capacity - 1; \ @@ -604,25 +616,25 @@ static const char *cmc_string_fmt_queue = "struct %s<%s> " iter.index = 0; \ } \ \ - iter.start = PFX##_empty(target); \ + iter.start = CMC_(PFX, _empty)(target); \ iter.end = true; \ \ return iter; \ } \ \ - bool PFX##_iter_at_start(struct SNAME##_iter *iter) \ + bool CMC_(PFX, _iter_at_start)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ - return PFX##_empty(iter->target) || iter->start; \ + return CMC_(PFX, _empty)(iter->target) || iter->start; \ } \ \ - bool PFX##_iter_at_end(struct SNAME##_iter *iter) \ + bool CMC_(PFX, _iter_at_end)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ - return PFX##_empty(iter->target) || iter->end; \ + return CMC_(PFX, _empty)(iter->target) || iter->end; \ } \ \ - bool PFX##_iter_to_start(struct SNAME##_iter *iter) \ + bool CMC_(PFX, _iter_to_start)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ - if (!PFX##_empty(iter->target)) \ + if (!CMC_(PFX, _empty)(iter->target)) \ { \ iter->cursor = iter->target->front; \ iter->index = 0; \ @@ -635,9 +647,9 @@ static const char *cmc_string_fmt_queue = "struct %s<%s> " return false; \ } \ \ - bool PFX##_iter_to_end(struct SNAME##_iter *iter) \ + bool CMC_(PFX, _iter_to_end)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ - if (!PFX##_empty(iter->target)) \ + if (!CMC_(PFX, _empty)(iter->target)) \ { \ if (iter->target->back == 0) \ iter->cursor = iter->target->capacity - 1; \ @@ -655,7 +667,7 @@ static const char *cmc_string_fmt_queue = "struct %s<%s> " return false; \ } \ \ - bool PFX##_iter_next(struct SNAME##_iter *iter) \ + bool CMC_(PFX, _iter_next)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ if (iter->end) \ return false; \ @@ -666,7 +678,7 @@ static const char *cmc_string_fmt_queue = "struct %s<%s> " return false; \ } \ \ - iter->start = PFX##_empty(iter->target); \ + iter->start = CMC_(PFX, _empty)(iter->target); \ \ iter->cursor = (iter->cursor + 1) % (iter->target->capacity); \ iter->index++; \ @@ -674,7 +686,7 @@ static const char *cmc_string_fmt_queue = "struct %s<%s> " return true; \ } \ \ - bool PFX##_iter_prev(struct SNAME##_iter *iter) \ + bool CMC_(PFX, _iter_prev)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ if (iter->start) \ return false; \ @@ -685,7 +697,7 @@ static const char *cmc_string_fmt_queue = "struct %s<%s> " return false; \ } \ \ - iter->end = PFX##_empty(iter->target); \ + iter->end = CMC_(PFX, _empty)(iter->target); \ \ iter->cursor = (iter->cursor == 0) ? iter->target->capacity - 1 \ : iter->cursor - 1; \ @@ -695,7 +707,8 @@ static const char *cmc_string_fmt_queue = "struct %s<%s> " } \ \ /* Returns true only if the iterator moved */ \ - bool PFX##_iter_advance(struct SNAME##_iter *iter, size_t steps) \ + bool CMC_(PFX, _iter_advance)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t steps) \ { \ if (iter->end) \ return false; \ @@ -709,7 +722,7 @@ static const char *cmc_string_fmt_queue = "struct %s<%s> " if (steps == 0 || iter->index + steps >= iter->target->count) \ return false; \ \ - iter->start = PFX##_empty(iter->target); \ + iter->start = CMC_(PFX, _empty)(iter->target); \ \ iter->index += steps; \ iter->cursor = (iter->cursor + steps) % iter->target->capacity; \ @@ -718,7 +731,8 @@ static const char *cmc_string_fmt_queue = "struct %s<%s> " } \ \ /* Returns true only if the iterator moved */ \ - bool PFX##_iter_rewind(struct SNAME##_iter *iter, size_t steps) \ + bool CMC_(PFX, _iter_rewind)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t steps) \ { \ if (iter->start) \ return false; \ @@ -732,7 +746,7 @@ static const char *cmc_string_fmt_queue = "struct %s<%s> " if (steps == 0 || iter->index < steps) \ return false; \ \ - iter->end = PFX##_empty(iter->target); \ + iter->end = CMC_(PFX, _empty)(iter->target); \ \ iter->index -= steps; \ \ @@ -747,38 +761,39 @@ static const char *cmc_string_fmt_queue = "struct %s<%s> " \ /* Returns true only if the iterator was able to be positioned at the */ \ /* given index */ \ - bool PFX##_iter_go_to(struct SNAME##_iter *iter, size_t index) \ + bool CMC_(PFX, _iter_go_to)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t index) \ { \ if (index >= iter->target->count) \ return false; \ \ if (iter->index > index) \ - return PFX##_iter_rewind(iter, iter->index - index); \ + return CMC_(PFX, _iter_rewind)(iter, iter->index - index); \ else if (iter->index < index) \ - return PFX##_iter_advance(iter, index - iter->index); \ + return CMC_(PFX, _iter_advance)(iter, index - iter->index); \ \ return true; \ } \ \ - V PFX##_iter_value(struct SNAME##_iter *iter) \ + V CMC_(PFX, _iter_value)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ - if (PFX##_empty(iter->target)) \ + if (CMC_(PFX, _empty)(iter->target)) \ return (V){ 0 }; \ \ return iter->target->buffer[iter->cursor]; \ } \ \ - V *PFX##_iter_rvalue(struct SNAME##_iter *iter) \ + V *CMC_(PFX, _iter_rvalue)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ - if (PFX##_empty(iter->target)) \ + if (CMC_(PFX, _empty)(iter->target)) \ return NULL; \ \ return &(iter->target->buffer[iter->cursor]); \ } \ \ - size_t PFX##_iter_index(struct SNAME##_iter *iter) \ + size_t CMC_(PFX, _iter_index)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ return iter->index; \ } -#endif /* CMC_QUEUE_H */ +#endif /* CMC_CMC_QUEUE_H */ diff --git a/src/cmc/sortedlist.h b/src/cmc/sortedlist.h index 47edbc7..eddf1df 100644 --- a/src/cmc/sortedlist.h +++ b/src/cmc/sortedlist.h @@ -19,8 +19,8 @@ * variation of quick sort that uses insertion sort for small partitions. */ -#ifndef CMC_SORTEDLIST_H -#define CMC_SORTEDLIST_H +#ifndef CMC_CMC_SORTEDLIST_H +#define CMC_CMC_SORTEDLIST_H /* ------------------------------------------------------------------------- * Core functionalities of the C Macro Collections Library @@ -31,167 +31,179 @@ * SortedList specific * ------------------------------------------------------------------------- */ /* to_string format */ -static const char *cmc_string_fmt_sortedlist = "struct %s<%s> " - "at %p { " - "buffer:%p, " - "capacity:%" PRIuMAX ", " - "count:%" PRIuMAX ", " - "is_sorted:%s, " - "flag:%d, " - "f_val:%p, " - "alloc:%p, " - "callbacks:%p }"; +static const char *cmc_cmc_string_fmt_sortedlist = "struct %s<%s> " + "at %p { " + "buffer:%p, " + "capacity:%" PRIuMAX ", " + "count:%" PRIuMAX ", " + "is_sorted:%s, " + "flag:%d, " + "f_val:%p, " + "alloc:%p, " + "callbacks:%p }"; -#define CMC_GENERATE_SORTEDLIST(PFX, SNAME, V) \ - CMC_GENERATE_SORTEDLIST_HEADER(PFX, SNAME, V) \ - CMC_GENERATE_SORTEDLIST_SOURCE(PFX, SNAME, V) +/** + * Core SortedList implementation + */ +#define CMC_CMC_SORTEDLIST_CORE(BODY) \ + CMC_CMC_SORTEDLIST_CORE_HEADER(BODY) \ + CMC_CMC_SORTEDLIST_CORE_SOURCE(BODY) -#define CMC_WRAPGEN_SORTEDLIST_HEADER(PFX, SNAME, K, V) \ - CMC_GENERATE_SORTEDLIST_HEADER(PFX, SNAME, V) +#define CMC_CMC_SORTEDLIST_CORE_HEADER(BODY) \ + CMC_CMC_SORTEDLIST_CORE_HEADER_(CMC_PARAM_PFX(BODY), \ + CMC_PARAM_SNAME(BODY), CMC_PARAM_V(BODY)) -#define CMC_WRAPGEN_SORTEDLIST_SOURCE(PFX, SNAME, K, V) \ - CMC_GENERATE_SORTEDLIST_SOURCE(PFX, SNAME, V) +#define CMC_CMC_SORTEDLIST_CORE_SOURCE(BODY) \ + CMC_CMC_SORTEDLIST_CORE_SOURCE_(CMC_PARAM_PFX(BODY), \ + CMC_PARAM_SNAME(BODY), CMC_PARAM_V(BODY)) /* ------------------------------------------------------------------------- * Header * ------------------------------------------------------------------------- */ -#define CMC_GENERATE_SORTEDLIST_HEADER(PFX, SNAME, V) \ - \ - /* List Structure */ \ - struct SNAME \ - { \ - /* Dynamic array of elements */ \ - V *buffer; \ - \ - /* Current array capacity */ \ - size_t capacity; \ - \ - /* Current amount of elements */ \ - size_t count; \ - \ - /* Flag if the list is sorted or not, used by lazy evaluation */ \ - bool is_sorted; \ - \ - /* Flags indicating errors or success */ \ - int flag; \ - \ - /* Value function table */ \ - struct SNAME##_fval *f_val; \ - \ - /* Custom allocation functions */ \ - struct cmc_alloc_node *alloc; \ - \ - /* Custom callback functions */ \ - struct cmc_callbacks *callbacks; \ - }; \ - \ - /* Value struct function table */ \ - struct SNAME##_fval \ - { \ - /* Comparator function */ \ - int (*cmp)(V, V); \ - \ - /* Copy function */ \ - V (*cpy)(V); \ - \ - /* To string function */ \ - bool (*str)(FILE *, V); \ - \ - /* Free from memory function */ \ - void (*free)(V); \ - \ - /* Hash function */ \ - size_t (*hash)(V); \ - \ - /* Priority function */ \ - int (*pri)(V, V); \ - }; \ - \ - /* List Iterator */ \ - struct SNAME##_iter \ - { \ - /* Target list */ \ - struct SNAME *target; \ - \ - /* Cursor's position (index) */ \ - size_t cursor; \ - \ - /* If the iterator has reached the start of the iteration */ \ - bool start; \ - \ - /* If the iterator has reached the end of the iteration */ \ - bool end; \ - }; \ - \ - /* Collection Functions */ \ - /* Collection Allocation and Deallocation */ \ - struct SNAME *PFX##_new(size_t capacity, struct SNAME##_fval *f_val); \ - struct SNAME *PFX##_new_custom( \ - size_t capacity, struct SNAME##_fval *f_val, \ - struct cmc_alloc_node *alloc, struct cmc_callbacks *callbacks); \ - void PFX##_clear(struct SNAME *_list_); \ - void PFX##_free(struct SNAME *_list_); \ - /* Customization of Allocation and Callbacks */ \ - void PFX##_customize(struct SNAME *_list_, struct cmc_alloc_node *alloc, \ - struct cmc_callbacks *callbacks); \ - /* Collection Input and Output */ \ - bool PFX##_insert(struct SNAME *_list_, V value); \ - bool PFX##_remove(struct SNAME *_list_, size_t index); \ - /* Element Access */ \ - V PFX##_max(struct SNAME *_list_); \ - V PFX##_min(struct SNAME *_list_); \ - V PFX##_get(struct SNAME *_list_, size_t index); \ - size_t PFX##_index_of(struct SNAME *_list_, V value, bool from_start); \ - /* Collection State */ \ - bool PFX##_contains(struct SNAME *_list_, V value); \ - bool PFX##_empty(struct SNAME *_list_); \ - bool PFX##_full(struct SNAME *_list_); \ - size_t PFX##_count(struct SNAME *_list_); \ - size_t PFX##_capacity(struct SNAME *_list_); \ - int PFX##_flag(struct SNAME *_list_); \ - /* Collection Utility */ \ - bool PFX##_resize(struct SNAME *_list_, size_t capacity); \ - void PFX##_sort(struct SNAME *_list_); \ - struct SNAME *PFX##_copy_of(struct SNAME *_list_); \ - bool PFX##_equals(struct SNAME *_list1_, struct SNAME *_list2_); \ - struct cmc_string PFX##_to_string(struct SNAME *_list_); \ - bool PFX##_print(struct SNAME *_list_, FILE *fptr); \ - \ - /* Iterator Functions */ \ - /* Iterator Initialization */ \ - struct SNAME##_iter PFX##_iter_start(struct SNAME *target); \ - struct SNAME##_iter PFX##_iter_end(struct SNAME *target); \ - /* Iterator State */ \ - bool PFX##_iter_at_start(struct SNAME##_iter *iter); \ - bool PFX##_iter_at_end(struct SNAME##_iter *iter); \ - /* Iterator Movement */ \ - bool PFX##_iter_to_start(struct SNAME##_iter *iter); \ - bool PFX##_iter_to_end(struct SNAME##_iter *iter); \ - bool PFX##_iter_next(struct SNAME##_iter *iter); \ - bool PFX##_iter_prev(struct SNAME##_iter *iter); \ - bool PFX##_iter_advance(struct SNAME##_iter *iter, size_t steps); \ - bool PFX##_iter_rewind(struct SNAME##_iter *iter, size_t steps); \ - bool PFX##_iter_go_to(struct SNAME##_iter *iter, size_t index); \ - /* Iterator Access */ \ - V PFX##_iter_value(struct SNAME##_iter *iter); \ - size_t PFX##_iter_index(struct SNAME##_iter *iter); +#define CMC_CMC_SORTEDLIST_CORE_HEADER_(PFX, SNAME, V) \ + \ + /* List Structure */ \ + struct SNAME \ + { \ + /* Dynamic array of elements */ \ + V *buffer; \ + \ + /* Current array capacity */ \ + size_t capacity; \ + \ + /* Current amount of elements */ \ + size_t count; \ + \ + /* Flag if the list is sorted or not, used by lazy evaluation */ \ + bool is_sorted; \ + \ + /* Flags indicating errors or success */ \ + int flag; \ + \ + /* Value function table */ \ + struct CMC_DEF_FVAL(SNAME) * f_val; \ + \ + /* Custom allocation functions */ \ + struct cmc_alloc_node *alloc; \ + \ + /* Custom callback functions */ \ + struct cmc_callbacks *callbacks; \ + }; \ + \ + /* Value struct function table */ \ + struct CMC_DEF_FVAL(SNAME) \ + { \ + /* Comparator function */ \ + int (*cmp)(V, V); \ + \ + /* Copy function */ \ + V (*cpy)(V); \ + \ + /* To string function */ \ + bool (*str)(FILE *, V); \ + \ + /* Free from memory function */ \ + void (*free)(V); \ + \ + /* Hash function */ \ + size_t (*hash)(V); \ + \ + /* Priority function */ \ + int (*pri)(V, V); \ + }; \ + \ + /* List Iterator */ \ + struct CMC_DEF_ITER(SNAME) \ + { \ + /* Target list */ \ + struct SNAME *target; \ + \ + /* Cursor's position (index) */ \ + size_t cursor; \ + \ + /* If the iterator has reached the start of the iteration */ \ + bool start; \ + \ + /* If the iterator has reached the end of the iteration */ \ + bool end; \ + }; \ + \ + /* Collection Functions */ \ + /* Collection Allocation and Deallocation */ \ + struct SNAME *CMC_(PFX, _new)(size_t capacity, \ + struct CMC_DEF_FVAL(SNAME) * f_val); \ + struct SNAME *CMC_(PFX, _new_custom)( \ + size_t capacity, struct CMC_DEF_FVAL(SNAME) * f_val, \ + struct cmc_alloc_node * alloc, struct cmc_callbacks * callbacks); \ + void CMC_(PFX, _clear)(struct SNAME * _list_); \ + void CMC_(PFX, _free)(struct SNAME * _list_); \ + /* Customization of Allocation and Callbacks */ \ + void CMC_(PFX, _customize)(struct SNAME * _list_, \ + struct cmc_alloc_node * alloc, \ + struct cmc_callbacks * callbacks); \ + /* Collection Input and Output */ \ + bool CMC_(PFX, _insert)(struct SNAME * _list_, V value); \ + bool CMC_(PFX, _remove)(struct SNAME * _list_, size_t index); \ + /* Element Access */ \ + V CMC_(PFX, _max)(struct SNAME * _list_); \ + V CMC_(PFX, _min)(struct SNAME * _list_); \ + V CMC_(PFX, _get)(struct SNAME * _list_, size_t index); \ + size_t CMC_(PFX, _index_of)(struct SNAME * _list_, V value, \ + bool from_start); \ + /* Collection State */ \ + bool CMC_(PFX, _contains)(struct SNAME * _list_, V value); \ + bool CMC_(PFX, _empty)(struct SNAME * _list_); \ + bool CMC_(PFX, _full)(struct SNAME * _list_); \ + size_t CMC_(PFX, _count)(struct SNAME * _list_); \ + size_t CMC_(PFX, _capacity)(struct SNAME * _list_); \ + int CMC_(PFX, _flag)(struct SNAME * _list_); \ + /* Collection Utility */ \ + bool CMC_(PFX, _resize)(struct SNAME * _list_, size_t capacity); \ + void CMC_(PFX, _sort)(struct SNAME * _list_); \ + struct SNAME *CMC_(PFX, _copy_of)(struct SNAME * _list_); \ + bool CMC_(PFX, _equals)(struct SNAME * _list1_, struct SNAME * _list2_); \ + struct cmc_string CMC_(PFX, _to_string)(struct SNAME * _list_); \ + bool CMC_(PFX, _print)(struct SNAME * _list_, FILE * fptr); \ + \ + /* Iterator Functions */ \ + /* Iterator Initialization */ \ + struct CMC_DEF_ITER(SNAME) CMC_(PFX, _iter_start)(struct SNAME * target); \ + struct CMC_DEF_ITER(SNAME) CMC_(PFX, _iter_end)(struct SNAME * target); \ + /* Iterator State */ \ + bool CMC_(PFX, _iter_at_start)(struct CMC_DEF_ITER(SNAME) * iter); \ + bool CMC_(PFX, _iter_at_end)(struct CMC_DEF_ITER(SNAME) * iter); \ + /* Iterator Movement */ \ + bool CMC_(PFX, _iter_to_start)(struct CMC_DEF_ITER(SNAME) * iter); \ + bool CMC_(PFX, _iter_to_end)(struct CMC_DEF_ITER(SNAME) * iter); \ + bool CMC_(PFX, _iter_next)(struct CMC_DEF_ITER(SNAME) * iter); \ + bool CMC_(PFX, _iter_prev)(struct CMC_DEF_ITER(SNAME) * iter); \ + bool CMC_(PFX, _iter_advance)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t steps); \ + bool CMC_(PFX, _iter_rewind)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t steps); \ + bool CMC_(PFX, _iter_go_to)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t index); \ + /* Iterator Access */ \ + V CMC_(PFX, _iter_value)(struct CMC_DEF_ITER(SNAME) * iter); \ + size_t CMC_(PFX, _iter_index)(struct CMC_DEF_ITER(SNAME) * iter); /* ------------------------------------------------------------------------- * Source * ------------------------------------------------------------------------- */ -#define CMC_GENERATE_SORTEDLIST_SOURCE(PFX, SNAME, V) \ +#define CMC_CMC_SORTEDLIST_CORE_SOURCE_(PFX, SNAME, V) \ \ /* Implementation Detail Functions */ \ - static size_t PFX##_impl_binary_search_first(struct SNAME *_list_, \ - V value); \ - static size_t PFX##_impl_binary_search_last(struct SNAME *_list_, \ - V value); \ - void PFX##_impl_sort_quicksort(V *array, int (*cmp)(V, V), size_t low, \ - size_t high); \ - void PFX##_impl_sort_insertion(V *array, int (*cmp)(V, V), size_t low, \ - size_t high); \ + static size_t CMC_(PFX, _impl_binary_search_first)(struct SNAME * _list_, \ + V value); \ + static size_t CMC_(PFX, _impl_binary_search_last)(struct SNAME * _list_, \ + V value); \ + void CMC_(PFX, _impl_sort_quicksort)(V * array, int (*cmp)(V, V), \ + size_t low, size_t high); \ + void CMC_(PFX, _impl_sort_insertion)(V * array, int (*cmp)(V, V), \ + size_t low, size_t high); \ \ - struct SNAME *PFX##_new(size_t capacity, struct SNAME##_fval *f_val) \ + struct SNAME *CMC_(PFX, _new)(size_t capacity, \ + struct CMC_DEF_FVAL(SNAME) * f_val) \ { \ struct cmc_alloc_node *alloc = &cmc_alloc_node_default; \ \ @@ -217,7 +229,7 @@ static const char *cmc_string_fmt_sortedlist = "struct %s<%s> " _list_->capacity = capacity; \ _list_->count = 0; \ _list_->is_sorted = false; \ - _list_->flag = cmc_flags.OK; \ + _list_->flag = CMC_FLAG_OK; \ _list_->f_val = f_val; \ _list_->alloc = alloc; \ _list_->callbacks = NULL; \ @@ -225,9 +237,9 @@ static const char *cmc_string_fmt_sortedlist = "struct %s<%s> " return _list_; \ } \ \ - struct SNAME *PFX##_new_custom( \ - size_t capacity, struct SNAME##_fval *f_val, \ - struct cmc_alloc_node *alloc, struct cmc_callbacks *callbacks) \ + struct SNAME *CMC_(PFX, _new_custom)( \ + size_t capacity, struct CMC_DEF_FVAL(SNAME) * f_val, \ + struct cmc_alloc_node * alloc, struct cmc_callbacks * callbacks) \ { \ if (capacity < 1) \ return NULL; \ @@ -251,7 +263,7 @@ static const char *cmc_string_fmt_sortedlist = "struct %s<%s> " _list_->capacity = capacity; \ _list_->count = 0; \ _list_->is_sorted = false; \ - _list_->flag = cmc_flags.OK; \ + _list_->flag = CMC_FLAG_OK; \ _list_->f_val = f_val; \ _list_->alloc = alloc; \ _list_->callbacks = callbacks; \ @@ -259,7 +271,7 @@ static const char *cmc_string_fmt_sortedlist = "struct %s<%s> " return _list_; \ } \ \ - void PFX##_clear(struct SNAME *_list_) \ + void CMC_(PFX, _clear)(struct SNAME * _list_) \ { \ if (_list_->f_val->free) \ { \ @@ -270,10 +282,10 @@ static const char *cmc_string_fmt_sortedlist = "struct %s<%s> " memset(_list_->buffer, 0, sizeof(V) * _list_->capacity); \ \ _list_->count = 0; \ - _list_->flag = cmc_flags.OK; \ + _list_->flag = CMC_FLAG_OK; \ } \ \ - void PFX##_free(struct SNAME *_list_) \ + void CMC_(PFX, _free)(struct SNAME * _list_) \ { \ if (_list_->f_val->free) \ { \ @@ -285,8 +297,9 @@ static const char *cmc_string_fmt_sortedlist = "struct %s<%s> " _list_->alloc->free(_list_); \ } \ \ - void PFX##_customize(struct SNAME *_list_, struct cmc_alloc_node *alloc, \ - struct cmc_callbacks *callbacks) \ + void CMC_(PFX, _customize)(struct SNAME * _list_, \ + struct cmc_alloc_node * alloc, \ + struct cmc_callbacks * callbacks) \ { \ if (!alloc) \ _list_->alloc = &cmc_alloc_node_default; \ @@ -295,21 +308,21 @@ static const char *cmc_string_fmt_sortedlist = "struct %s<%s> " \ _list_->callbacks = callbacks; \ \ - _list_->flag = cmc_flags.OK; \ + _list_->flag = CMC_FLAG_OK; \ } \ \ - bool PFX##_insert(struct SNAME *_list_, V value) \ + bool CMC_(PFX, _insert)(struct SNAME * _list_, V value) \ { \ - if (PFX##_full(_list_)) \ + if (CMC_(PFX, _full)(_list_)) \ { \ - if (!PFX##_resize(_list_, _list_->capacity * 2)) \ + if (!CMC_(PFX, _resize)(_list_, _list_->capacity * 2)) \ return false; \ } \ \ _list_->buffer[_list_->count++] = value; \ \ _list_->is_sorted = false; \ - _list_->flag = cmc_flags.OK; \ + _list_->flag = CMC_FLAG_OK; \ \ if (_list_->callbacks && _list_->callbacks->create) \ _list_->callbacks->create(); \ @@ -317,17 +330,17 @@ static const char *cmc_string_fmt_sortedlist = "struct %s<%s> " return true; \ } \ \ - bool PFX##_remove(struct SNAME *_list_, size_t index) \ + bool CMC_(PFX, _remove)(struct SNAME * _list_, size_t index) \ { \ - if (PFX##_empty(_list_)) \ + if (CMC_(PFX, _empty)(_list_)) \ { \ - _list_->flag = cmc_flags.EMPTY; \ + _list_->flag = CMC_FLAG_EMPTY; \ return false; \ } \ \ if (index >= _list_->count) \ { \ - _list_->flag = cmc_flags.RANGE; \ + _list_->flag = CMC_FLAG_RANGE; \ return false; \ } \ \ @@ -336,7 +349,7 @@ static const char *cmc_string_fmt_sortedlist = "struct %s<%s> " \ _list_->buffer[--_list_->count] = (V){ 0 }; \ \ - _list_->flag = cmc_flags.OK; \ + _list_->flag = CMC_FLAG_OK; \ \ if (_list_->callbacks && _list_->callbacks->delete) \ _list_->callbacks->delete (); \ @@ -344,17 +357,17 @@ static const char *cmc_string_fmt_sortedlist = "struct %s<%s> " return true; \ } \ \ - V PFX##_max(struct SNAME *_list_) \ + V CMC_(PFX, _max)(struct SNAME * _list_) \ { \ - if (PFX##_empty(_list_)) \ + if (CMC_(PFX, _empty)(_list_)) \ { \ - _list_->flag = cmc_flags.EMPTY; \ + _list_->flag = CMC_FLAG_EMPTY; \ return (V){ 0 }; \ } \ \ - PFX##_sort(_list_); \ + CMC_(PFX, _sort)(_list_); \ \ - _list_->flag = cmc_flags.OK; \ + _list_->flag = CMC_FLAG_OK; \ \ if (_list_->callbacks && _list_->callbacks->read) \ _list_->callbacks->read(); \ @@ -362,17 +375,17 @@ static const char *cmc_string_fmt_sortedlist = "struct %s<%s> " return _list_->buffer[_list_->count - 1]; \ } \ \ - V PFX##_min(struct SNAME *_list_) \ + V CMC_(PFX, _min)(struct SNAME * _list_) \ { \ - if (PFX##_empty(_list_)) \ + if (CMC_(PFX, _empty)(_list_)) \ { \ - _list_->flag = cmc_flags.EMPTY; \ + _list_->flag = CMC_FLAG_EMPTY; \ return (V){ 0 }; \ } \ \ - PFX##_sort(_list_); \ + CMC_(PFX, _sort)(_list_); \ \ - _list_->flag = cmc_flags.OK; \ + _list_->flag = CMC_FLAG_OK; \ \ if (_list_->callbacks && _list_->callbacks->read) \ _list_->callbacks->read(); \ @@ -380,23 +393,23 @@ static const char *cmc_string_fmt_sortedlist = "struct %s<%s> " return _list_->buffer[0]; \ } \ \ - V PFX##_get(struct SNAME *_list_, size_t index) \ + V CMC_(PFX, _get)(struct SNAME * _list_, size_t index) \ { \ - if (PFX##_empty(_list_)) \ + if (CMC_(PFX, _empty)(_list_)) \ { \ - _list_->flag = cmc_flags.EMPTY; \ + _list_->flag = CMC_FLAG_EMPTY; \ return (V){ 0 }; \ } \ \ if (index >= _list_->count) \ { \ - _list_->flag = cmc_flags.RANGE; \ + _list_->flag = CMC_FLAG_RANGE; \ return (V){ 0 }; \ } \ \ - PFX##_sort(_list_); \ + CMC_(PFX, _sort)(_list_); \ \ - _list_->flag = cmc_flags.OK; \ + _list_->flag = CMC_FLAG_OK; \ \ if (_list_->callbacks && _list_->callbacks->read) \ _list_->callbacks->read(); \ @@ -404,71 +417,73 @@ static const char *cmc_string_fmt_sortedlist = "struct %s<%s> " return _list_->buffer[index]; \ } \ \ - size_t PFX##_index_of(struct SNAME *_list_, V value, bool from_start) \ + size_t CMC_(PFX, _index_of)(struct SNAME * _list_, V value, \ + bool from_start) \ { \ - _list_->flag = cmc_flags.OK; \ + _list_->flag = CMC_FLAG_OK; \ \ - PFX##_sort(_list_); \ + CMC_(PFX, _sort)(_list_); \ \ if (_list_->callbacks && _list_->callbacks->read) \ _list_->callbacks->read(); \ \ if (from_start) \ { \ - return PFX##_impl_binary_search_first(_list_, value); \ + return CMC_(PFX, _impl_binary_search_first)(_list_, value); \ } \ \ - return PFX##_impl_binary_search_last(_list_, value); \ + return CMC_(PFX, _impl_binary_search_last)(_list_, value); \ } \ \ - bool PFX##_contains(struct SNAME *_list_, V value) \ + bool CMC_(PFX, _contains)(struct SNAME * _list_, V value) \ { \ - _list_->flag = cmc_flags.OK; \ + _list_->flag = CMC_FLAG_OK; \ \ - if (PFX##_empty(_list_)) \ + if (CMC_(PFX, _empty)(_list_)) \ return false; \ \ - PFX##_sort(_list_); \ + CMC_(PFX, _sort)(_list_); \ \ if (_list_->callbacks && _list_->callbacks->read) \ _list_->callbacks->read(); \ \ - return PFX##_impl_binary_search_first(_list_, value) < _list_->count; \ + return CMC_(PFX, _impl_binary_search_first)(_list_, value) < \ + _list_->count; \ } \ \ - bool PFX##_empty(struct SNAME *_list_) \ + bool CMC_(PFX, _empty)(struct SNAME * _list_) \ { \ return _list_->count == 0; \ } \ \ - bool PFX##_full(struct SNAME *_list_) \ + bool CMC_(PFX, _full)(struct SNAME * _list_) \ { \ return _list_->count >= _list_->capacity; \ } \ \ - size_t PFX##_count(struct SNAME *_list_) \ + size_t CMC_(PFX, _count)(struct SNAME * _list_) \ { \ return _list_->count; \ } \ \ - size_t PFX##_capacity(struct SNAME *_list_) \ + size_t CMC_(PFX, _capacity)(struct SNAME * _list_) \ { \ return _list_->capacity; \ } \ \ - int PFX##_flag(struct SNAME *_list_) \ + int CMC_(PFX, _flag)(struct SNAME * _list_) \ { \ return _list_->flag; \ } \ \ - bool PFX##_resize(struct SNAME *_list_, size_t capacity) \ + bool CMC_(PFX, _resize)(struct SNAME * _list_, size_t capacity) \ { \ if (_list_->capacity == capacity) \ goto success; \ \ if (capacity < _list_->count) \ { \ - _list_->flag = cmc_flags.INVALID; \ + _list_->flag = CMC_FLAG_INVALID; \ return false; \ } \ \ @@ -477,7 +492,7 @@ static const char *cmc_string_fmt_sortedlist = "struct %s<%s> " \ if (!new_buffer) \ { \ - _list_->flag = cmc_flags.ALLOC; \ + _list_->flag = CMC_FLAG_ALLOC; \ return false; \ } \ \ @@ -488,7 +503,7 @@ static const char *cmc_string_fmt_sortedlist = "struct %s<%s> " \ success: \ \ - _list_->flag = cmc_flags.OK; \ + _list_->flag = CMC_FLAG_OK; \ \ if (_list_->callbacks && _list_->callbacks->resize) \ _list_->callbacks->resize(); \ @@ -496,28 +511,28 @@ static const char *cmc_string_fmt_sortedlist = "struct %s<%s> " return true; \ } \ \ - void PFX##_sort(struct SNAME *_list_) \ + void CMC_(PFX, _sort)(struct SNAME * _list_) \ { \ - _list_->flag = cmc_flags.OK; \ + _list_->flag = CMC_FLAG_OK; \ \ if (!_list_->is_sorted && _list_->count > 1) \ { \ - PFX##_impl_sort_quicksort(_list_->buffer, _list_->f_val->cmp, 0, \ - _list_->count - 1); \ + CMC_(PFX, _impl_sort_quicksort) \ + (_list_->buffer, _list_->f_val->cmp, 0, _list_->count - 1); \ \ _list_->is_sorted = true; \ } \ } \ \ - struct SNAME *PFX##_copy_of(struct SNAME *_list_) \ + struct SNAME *CMC_(PFX, _copy_of)(struct SNAME * _list_) \ { \ struct SNAME *result = \ - PFX##_new_custom(_list_->capacity, _list_->f_val, _list_->alloc, \ - _list_->callbacks); \ + CMC_(PFX, _new_custom)(_list_->capacity, _list_->f_val, \ + _list_->alloc, _list_->callbacks); \ \ if (!result) \ { \ - _list_->flag = cmc_flags.ERROR; \ + _list_->flag = CMC_FLAG_ERROR; \ return NULL; \ } \ \ @@ -531,18 +546,18 @@ static const char *cmc_string_fmt_sortedlist = "struct %s<%s> " \ result->count = _list_->count; \ \ - _list_->flag = cmc_flags.OK; \ + _list_->flag = CMC_FLAG_OK; \ \ return result; \ } \ \ - bool PFX##_equals(struct SNAME *_list1_, struct SNAME *_list2_) \ + bool CMC_(PFX, _equals)(struct SNAME * _list1_, struct SNAME * _list2_) \ { \ if (_list1_->count != _list2_->count) \ return false; \ \ - PFX##_sort(_list1_); \ - PFX##_sort(_list2_); \ + CMC_(PFX, _sort)(_list1_); \ + CMC_(PFX, _sort)(_list2_); \ \ for (size_t i = 0; i < _list1_->count; i++) \ { \ @@ -554,12 +569,12 @@ static const char *cmc_string_fmt_sortedlist = "struct %s<%s> " return true; \ } \ \ - struct cmc_string PFX##_to_string(struct SNAME *_list_) \ + struct cmc_string CMC_(PFX, _to_string)(struct SNAME * _list_) \ { \ struct cmc_string str; \ struct SNAME *l_ = _list_; \ \ - int n = snprintf(str.s, cmc_string_len, cmc_string_fmt_sortedlist, \ + int n = snprintf(str.s, cmc_string_len, cmc_cmc_string_fmt_sortedlist, \ #SNAME, #V, l_, l_->buffer, l_->capacity, l_->count, \ l_->is_sorted ? "true" : "false", l_->flag, \ l_->f_val, l_->alloc, l_->callbacks); \ @@ -567,9 +582,9 @@ static const char *cmc_string_fmt_sortedlist = "struct %s<%s> " return n >= 0 ? str : (struct cmc_string){ 0 }; \ } \ \ - bool PFX##_print(struct SNAME *_list_, FILE *fptr) \ + bool CMC_(PFX, _print)(struct SNAME * _list_, FILE * fptr) \ { \ - PFX##_sort(_list_); \ + CMC_(PFX, _sort)(_list_); \ \ for (size_t i = 0; i < _list_->count; i++) \ { \ @@ -580,54 +595,54 @@ static const char *cmc_string_fmt_sortedlist = "struct %s<%s> " return true; \ } \ \ - struct SNAME##_iter PFX##_iter_start(struct SNAME *target) \ + struct CMC_DEF_ITER(SNAME) CMC_(PFX, _iter_start)(struct SNAME * target) \ { \ - PFX##_sort(target); \ + CMC_(PFX, _sort)(target); \ \ - struct SNAME##_iter iter; \ + struct CMC_DEF_ITER(SNAME) iter; \ \ iter.target = target; \ iter.cursor = 0; \ iter.start = true; \ - iter.end = PFX##_empty(target); \ + iter.end = CMC_(PFX, _empty)(target); \ \ return iter; \ } \ \ - struct SNAME##_iter PFX##_iter_end(struct SNAME *target) \ + struct CMC_DEF_ITER(SNAME) CMC_(PFX, _iter_end)(struct SNAME * target) \ { \ - PFX##_sort(target); \ + CMC_(PFX, _sort)(target); \ \ - struct SNAME##_iter iter; \ + struct CMC_DEF_ITER(SNAME) iter; \ \ iter.target = target; \ iter.cursor = 0; \ - iter.start = PFX##_empty(target); \ + iter.start = CMC_(PFX, _empty)(target); \ iter.end = true; \ \ - if (!PFX##_empty(target)) \ + if (!CMC_(PFX, _empty)(target)) \ iter.cursor = target->count - 1; \ \ return iter; \ } \ \ - bool PFX##_iter_at_start(struct SNAME##_iter *iter) \ + bool CMC_(PFX, _iter_at_start)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ - return PFX##_empty(iter->target) || iter->start; \ + return CMC_(PFX, _empty)(iter->target) || iter->start; \ } \ \ - bool PFX##_iter_at_end(struct SNAME##_iter *iter) \ + bool CMC_(PFX, _iter_at_end)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ - return PFX##_empty(iter->target) || iter->end; \ + return CMC_(PFX, _empty)(iter->target) || iter->end; \ } \ \ - bool PFX##_iter_to_start(struct SNAME##_iter *iter) \ + bool CMC_(PFX, _iter_to_start)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ - if (!PFX##_empty(iter->target)) \ + if (!CMC_(PFX, _empty)(iter->target)) \ { \ iter->cursor = 0; \ iter->start = true; \ - iter->end = PFX##_empty(iter->target); \ + iter->end = CMC_(PFX, _empty)(iter->target); \ \ return true; \ } \ @@ -635,11 +650,11 @@ static const char *cmc_string_fmt_sortedlist = "struct %s<%s> " return false; \ } \ \ - bool PFX##_iter_to_end(struct SNAME##_iter *iter) \ + bool CMC_(PFX, _iter_to_end)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ - if (!PFX##_empty(iter->target)) \ + if (!CMC_(PFX, _empty)(iter->target)) \ { \ - iter->start = PFX##_empty(iter->target); \ + iter->start = CMC_(PFX, _empty)(iter->target); \ iter->cursor = iter->target->count - 1; \ iter->end = true; \ \ @@ -649,7 +664,7 @@ static const char *cmc_string_fmt_sortedlist = "struct %s<%s> " return false; \ } \ \ - bool PFX##_iter_next(struct SNAME##_iter *iter) \ + bool CMC_(PFX, _iter_next)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ if (iter->end) \ return false; \ @@ -660,14 +675,14 @@ static const char *cmc_string_fmt_sortedlist = "struct %s<%s> " return false; \ } \ \ - iter->start = PFX##_empty(iter->target); \ + iter->start = CMC_(PFX, _empty)(iter->target); \ \ iter->cursor++; \ \ return true; \ } \ \ - bool PFX##_iter_prev(struct SNAME##_iter *iter) \ + bool CMC_(PFX, _iter_prev)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ if (iter->start) \ return false; \ @@ -678,7 +693,7 @@ static const char *cmc_string_fmt_sortedlist = "struct %s<%s> " return false; \ } \ \ - iter->end = PFX##_empty(iter->target); \ + iter->end = CMC_(PFX, _empty)(iter->target); \ \ iter->cursor--; \ \ @@ -686,7 +701,8 @@ static const char *cmc_string_fmt_sortedlist = "struct %s<%s> " } \ \ /* Returns true only if the iterator moved */ \ - bool PFX##_iter_advance(struct SNAME##_iter *iter, size_t steps) \ + bool CMC_(PFX, _iter_advance)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t steps) \ { \ if (iter->end) \ return false; \ @@ -700,7 +716,7 @@ static const char *cmc_string_fmt_sortedlist = "struct %s<%s> " if (steps == 0 || iter->cursor + steps >= iter->target->count) \ return false; \ \ - iter->start = PFX##_empty(iter->target); \ + iter->start = CMC_(PFX, _empty)(iter->target); \ \ iter->cursor += steps; \ \ @@ -708,7 +724,8 @@ static const char *cmc_string_fmt_sortedlist = "struct %s<%s> " } \ \ /* Returns true only if the iterator moved */ \ - bool PFX##_iter_rewind(struct SNAME##_iter *iter, size_t steps) \ + bool CMC_(PFX, _iter_rewind)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t steps) \ { \ if (iter->start) \ return false; \ @@ -722,7 +739,7 @@ static const char *cmc_string_fmt_sortedlist = "struct %s<%s> " if (steps == 0 || iter->cursor < steps) \ return false; \ \ - iter->end = PFX##_empty(iter->target); \ + iter->end = CMC_(PFX, _empty)(iter->target); \ \ iter->cursor -= steps; \ \ @@ -731,36 +748,37 @@ static const char *cmc_string_fmt_sortedlist = "struct %s<%s> " \ /* Returns true only if the iterator was able to be positioned at the */ \ /* given index */ \ - bool PFX##_iter_go_to(struct SNAME##_iter *iter, size_t index) \ + bool CMC_(PFX, _iter_go_to)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t index) \ { \ if (index >= iter->target->count) \ return false; \ \ if (iter->cursor > index) \ - return PFX##_iter_rewind(iter, iter->cursor - index); \ + return CMC_(PFX, _iter_rewind)(iter, iter->cursor - index); \ else if (iter->cursor < index) \ - return PFX##_iter_advance(iter, index - iter->cursor); \ + return CMC_(PFX, _iter_advance)(iter, index - iter->cursor); \ \ return true; \ } \ \ - V PFX##_iter_value(struct SNAME##_iter *iter) \ + V CMC_(PFX, _iter_value)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ - if (PFX##_empty(iter->target)) \ + if (CMC_(PFX, _empty)(iter->target)) \ return (V){ 0 }; \ \ return iter->target->buffer[iter->cursor]; \ } \ \ - size_t PFX##_iter_index(struct SNAME##_iter *iter) \ + size_t CMC_(PFX, _iter_index)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ return iter->cursor; \ } \ \ - static size_t PFX##_impl_binary_search_first(struct SNAME *_list_, \ - V value) \ + static size_t CMC_(PFX, _impl_binary_search_first)(struct SNAME * _list_, \ + V value) \ { \ - if (PFX##_empty(_list_)) \ + if (CMC_(PFX, _empty)(_list_)) \ return 1; \ \ size_t L = 0; \ @@ -783,9 +801,10 @@ static const char *cmc_string_fmt_sortedlist = "struct %s<%s> " return _list_->count; \ } \ \ - static size_t PFX##_impl_binary_search_last(struct SNAME *_list_, V value) \ + static size_t CMC_(PFX, _impl_binary_search_last)(struct SNAME * _list_, \ + V value) \ { \ - if (PFX##_empty(_list_)) \ + if (CMC_(PFX, _empty)(_list_)) \ return 1; \ \ size_t L = 0; \ @@ -812,8 +831,8 @@ static const char *cmc_string_fmt_sortedlist = "struct %s<%s> " /* - Hybrid: uses insertion sort for small arrays */ \ /* - Partition: Lomuto's Method */ \ /* - Tail recursion: minimize recursion depth */ \ - void PFX##_impl_sort_quicksort(V *array, int (*cmp)(V, V), size_t low, \ - size_t high) \ + void CMC_(PFX, _impl_sort_quicksort)(V * array, int (*cmp)(V, V), \ + size_t low, size_t high) \ { \ while (low < high) \ { \ @@ -821,7 +840,7 @@ static const char *cmc_string_fmt_sortedlist = "struct %s<%s> " /* insertion sort do the job */ \ if (high - low < 10) \ { \ - PFX##_impl_sort_insertion(array, cmp, low, high); \ + CMC_(PFX, _impl_sort_insertion)(array, cmp, low, high); \ break; \ } \ else \ @@ -850,13 +869,15 @@ static const char *cmc_string_fmt_sortedlist = "struct %s<%s> " /* Tail recursion */ \ if (pindex - low < high - pindex) \ { \ - PFX##_impl_sort_quicksort(array, cmp, low, pindex - 1); \ + CMC_(PFX, _impl_sort_quicksort) \ + (array, cmp, low, pindex - 1); \ \ low = pindex + 1; \ } \ else \ { \ - PFX##_impl_sort_quicksort(array, cmp, pindex + 1, high); \ + CMC_(PFX, _impl_sort_quicksort) \ + (array, cmp, pindex + 1, high); \ \ high = pindex - 1; \ } \ @@ -864,8 +885,8 @@ static const char *cmc_string_fmt_sortedlist = "struct %s<%s> " } \ } \ \ - void PFX##_impl_sort_insertion(V *array, int (*cmp)(V, V), size_t low, \ - size_t high) \ + void CMC_(PFX, _impl_sort_insertion)(V * array, int (*cmp)(V, V), \ + size_t low, size_t high) \ { \ for (size_t i = low + 1; i <= high; i++) \ { \ @@ -882,4 +903,4 @@ static const char *cmc_string_fmt_sortedlist = "struct %s<%s> " } \ } -#endif /* CMC_SORTEDLIST_H */ +#endif /* CMC_CMC_SORTEDLIST_H */ diff --git a/src/cmc/stack.h b/src/cmc/stack.h index 1efa5f0..e34dc3f 100644 --- a/src/cmc/stack.h +++ b/src/cmc/stack.h @@ -25,8 +25,8 @@ * expression evaluation, syntax parsing and many more. */ -#ifndef CMC_STACK_H -#define CMC_STACK_H +#ifndef CMC_CMC_STACK_H +#define CMC_CMC_STACK_H /* ------------------------------------------------------------------------- * Core functionalities of the C Macro Collections Library @@ -37,153 +37,164 @@ * Stack specific * ------------------------------------------------------------------------- */ /* to_string format */ -static const char *cmc_string_fmt_stack = "struct %s<%s> " - "at %p { " - "buffer:%p, " - "capacity:%" PRIuMAX ", " - "count:%" PRIuMAX ", " - "flag:%d, " - "f_val:%p, " - "alloc:%p, " - "callbacks:%p }"; +static const char *cmc_cmc_string_fmt_stack = "struct %s<%s> " + "at %p { " + "buffer:%p, " + "capacity:%" PRIuMAX ", " + "count:%" PRIuMAX ", " + "flag:%d, " + "f_val:%p, " + "alloc:%p, " + "callbacks:%p }"; -#define CMC_GENERATE_STACK(PFX, SNAME, V) \ - CMC_GENERATE_STACK_HEADER(PFX, SNAME, V) \ - CMC_GENERATE_STACK_SOURCE(PFX, SNAME, V) +/** + * Core Stack implementation + */ +#define CMC_CMC_STACK_CORE(BODY) \ + CMC_CMC_STACK_CORE_HEADER(BODY) \ + CMC_CMC_STACK_CORE_SOURCE(BODY) -#define CMC_WRAPGEN_STACK_HEADER(PFX, SNAME, K, V) \ - CMC_GENERATE_STACK_HEADER(PFX, SNAME, V) +#define CMC_CMC_STACK_CORE_HEADER(BODY) \ + CMC_CMC_STACK_CORE_HEADER_(CMC_PARAM_PFX(BODY), CMC_PARAM_SNAME(BODY), \ + CMC_PARAM_V(BODY)) -#define CMC_WRAPGEN_STACK_SOURCE(PFX, SNAME, K, V) \ - CMC_GENERATE_STACK_SOURCE(PFX, SNAME, V) +#define CMC_CMC_STACK_CORE_SOURCE(BODY) \ + CMC_CMC_STACK_CORE_SOURCE_(CMC_PARAM_PFX(BODY), CMC_PARAM_SNAME(BODY), \ + CMC_PARAM_V(BODY)) /* ------------------------------------------------------------------------- * Header * ------------------------------------------------------------------------- */ -#define CMC_GENERATE_STACK_HEADER(PFX, SNAME, V) \ - \ - /* Stack Structure */ \ - struct SNAME \ - { \ - /* Dynamic array of elements */ \ - V *buffer; \ - \ - /* Current array capacity */ \ - size_t capacity; \ - \ - /* Current amount of elements */ \ - size_t count; \ - \ - /* Flags indicating errors or success */ \ - int flag; \ - \ - /* Value function table */ \ - struct SNAME##_fval *f_val; \ - \ - /* Custom allocation functions */ \ - struct cmc_alloc_node *alloc; \ - \ - /* Custom callback functions */ \ - struct cmc_callbacks *callbacks; \ - }; \ - \ - /* Value struct function table */ \ - struct SNAME##_fval \ - { \ - /* Comparator function */ \ - int (*cmp)(V, V); \ - \ - /* Copy function */ \ - V (*cpy)(V); \ - \ - /* To string function */ \ - bool (*str)(FILE *, V); \ - \ - /* Free from memory function */ \ - void (*free)(V); \ - \ - /* Hash function */ \ - size_t (*hash)(V); \ - \ - /* Priority function */ \ - int (*pri)(V, V); \ - }; \ - \ - /* Stack Iterator */ \ - struct SNAME##_iter \ - { \ - /* Target stack */ \ - struct SNAME *target; \ - \ - /* Cursor's position (index) */ \ - size_t cursor; \ - \ - /* If the iterator has reached the start of the iteration */ \ - bool start; \ - \ - /* If the iterator has reached the end of the iteration */ \ - bool end; \ - }; \ - \ - /* Collection Functions */ \ - /* Collection Allocation and Deallocation */ \ - struct SNAME *PFX##_new(size_t capacity, struct SNAME##_fval *f_val); \ - struct SNAME *PFX##_new_custom( \ - size_t capacity, struct SNAME##_fval *f_val, \ - struct cmc_alloc_node *alloc, struct cmc_callbacks *callbacks); \ - void PFX##_clear(struct SNAME *_stack_); \ - void PFX##_free(struct SNAME *_stack_); \ - /* Customization of Allocation and Callbacks */ \ - void PFX##_customize(struct SNAME *_stack_, struct cmc_alloc_node *alloc, \ - struct cmc_callbacks *callbacks); \ - /* Collection Input and Output */ \ - bool PFX##_push(struct SNAME *_stack_, V value); \ - bool PFX##_pop(struct SNAME *_stack_); \ - /* Element Access */ \ - V PFX##_top(struct SNAME *_stack_); \ - /* Collection State */ \ - bool PFX##_contains(struct SNAME *_stack_, V value); \ - bool PFX##_empty(struct SNAME *_stack_); \ - bool PFX##_full(struct SNAME *_stack_); \ - size_t PFX##_count(struct SNAME *_stack_); \ - size_t PFX##_capacity(struct SNAME *_stack_); \ - int PFX##_flag(struct SNAME *_stack_); \ - /* Collection Utility */ \ - bool PFX##_resize(struct SNAME *_stack_, size_t capacity); \ - struct SNAME *PFX##_copy_of(struct SNAME *_stack_); \ - bool PFX##_equals(struct SNAME *_stack1_, struct SNAME *_stack2_); \ - struct cmc_string PFX##_to_string(struct SNAME *_stack_); \ - bool PFX##_print(struct SNAME *_stack_, FILE *fptr); \ - \ - /* Iterator Functions */ \ - /* Iterator Initialization */ \ - struct SNAME##_iter PFX##_iter_start(struct SNAME *target); \ - struct SNAME##_iter PFX##_iter_end(struct SNAME *target); \ - /* Iterator State */ \ - bool PFX##_iter_at_start(struct SNAME##_iter *iter); \ - bool PFX##_iter_at_end(struct SNAME##_iter *iter); \ - /* Iterator Movement */ \ - bool PFX##_iter_to_start(struct SNAME##_iter *iter); \ - bool PFX##_iter_to_end(struct SNAME##_iter *iter); \ - bool PFX##_iter_next(struct SNAME##_iter *iter); \ - bool PFX##_iter_prev(struct SNAME##_iter *iter); \ - bool PFX##_iter_advance(struct SNAME##_iter *iter, size_t steps); \ - bool PFX##_iter_rewind(struct SNAME##_iter *iter, size_t steps); \ - bool PFX##_iter_go_to(struct SNAME##_iter *iter, size_t index); \ - /* Iterator Access */ \ - V PFX##_iter_value(struct SNAME##_iter *iter); \ - V *PFX##_iter_rvalue(struct SNAME##_iter *iter); \ - size_t PFX##_iter_index(struct SNAME##_iter *iter); +#define CMC_CMC_STACK_CORE_HEADER_(PFX, SNAME, V) \ + \ + /* Stack Structure */ \ + struct SNAME \ + { \ + /* Dynamic array of elements */ \ + V *buffer; \ + \ + /* Current array capacity */ \ + size_t capacity; \ + \ + /* Current amount of elements */ \ + size_t count; \ + \ + /* Flags indicating errors or success */ \ + int flag; \ + \ + /* Value function table */ \ + struct CMC_DEF_FVAL(SNAME) * f_val; \ + \ + /* Custom allocation functions */ \ + struct cmc_alloc_node *alloc; \ + \ + /* Custom callback functions */ \ + struct cmc_callbacks *callbacks; \ + }; \ + \ + /* Value struct function table */ \ + struct CMC_DEF_FVAL(SNAME) \ + { \ + /* Comparator function */ \ + int (*cmp)(V, V); \ + \ + /* Copy function */ \ + V (*cpy)(V); \ + \ + /* To string function */ \ + bool (*str)(FILE *, V); \ + \ + /* Free from memory function */ \ + void (*free)(V); \ + \ + /* Hash function */ \ + size_t (*hash)(V); \ + \ + /* Priority function */ \ + int (*pri)(V, V); \ + }; \ + \ + /* Stack Iterator */ \ + struct CMC_DEF_ITER(SNAME) \ + { \ + /* Target stack */ \ + struct SNAME *target; \ + \ + /* Cursor's position (index) */ \ + size_t cursor; \ + \ + /* If the iterator has reached the start of the iteration */ \ + bool start; \ + \ + /* If the iterator has reached the end of the iteration */ \ + bool end; \ + }; \ + \ + /* Collection Functions */ \ + /* Collection Allocation and Deallocation */ \ + struct SNAME *CMC_(PFX, _new)(size_t capacity, \ + struct CMC_DEF_FVAL(SNAME) * f_val); \ + struct SNAME *CMC_(PFX, _new_custom)( \ + size_t capacity, struct CMC_DEF_FVAL(SNAME) * f_val, \ + struct cmc_alloc_node * alloc, struct cmc_callbacks * callbacks); \ + void CMC_(PFX, _clear)(struct SNAME * _stack_); \ + void CMC_(PFX, _free)(struct SNAME * _stack_); \ + /* Customization of Allocation and Callbacks */ \ + void CMC_(PFX, _customize)(struct SNAME * _stack_, \ + struct cmc_alloc_node * alloc, \ + struct cmc_callbacks * callbacks); \ + /* Collection Input and Output */ \ + bool CMC_(PFX, _push)(struct SNAME * _stack_, V value); \ + bool CMC_(PFX, _pop)(struct SNAME * _stack_); \ + /* Element Access */ \ + V CMC_(PFX, _top)(struct SNAME * _stack_); \ + /* Collection State */ \ + bool CMC_(PFX, _contains)(struct SNAME * _stack_, V value); \ + bool CMC_(PFX, _empty)(struct SNAME * _stack_); \ + bool CMC_(PFX, _full)(struct SNAME * _stack_); \ + size_t CMC_(PFX, _count)(struct SNAME * _stack_); \ + size_t CMC_(PFX, _capacity)(struct SNAME * _stack_); \ + int CMC_(PFX, _flag)(struct SNAME * _stack_); \ + /* Collection Utility */ \ + bool CMC_(PFX, _resize)(struct SNAME * _stack_, size_t capacity); \ + struct SNAME *CMC_(PFX, _copy_of)(struct SNAME * _stack_); \ + bool CMC_(PFX, _equals)(struct SNAME * _stack1_, struct SNAME * _stack2_); \ + struct cmc_string CMC_(PFX, _to_string)(struct SNAME * _stack_); \ + bool CMC_(PFX, _print)(struct SNAME * _stack_, FILE * fptr); \ + \ + /* Iterator Functions */ \ + /* Iterator Initialization */ \ + struct CMC_DEF_ITER(SNAME) CMC_(PFX, _iter_start)(struct SNAME * target); \ + struct CMC_DEF_ITER(SNAME) CMC_(PFX, _iter_end)(struct SNAME * target); \ + /* Iterator State */ \ + bool CMC_(PFX, _iter_at_start)(struct CMC_DEF_ITER(SNAME) * iter); \ + bool CMC_(PFX, _iter_at_end)(struct CMC_DEF_ITER(SNAME) * iter); \ + /* Iterator Movement */ \ + bool CMC_(PFX, _iter_to_start)(struct CMC_DEF_ITER(SNAME) * iter); \ + bool CMC_(PFX, _iter_to_end)(struct CMC_DEF_ITER(SNAME) * iter); \ + bool CMC_(PFX, _iter_next)(struct CMC_DEF_ITER(SNAME) * iter); \ + bool CMC_(PFX, _iter_prev)(struct CMC_DEF_ITER(SNAME) * iter); \ + bool CMC_(PFX, _iter_advance)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t steps); \ + bool CMC_(PFX, _iter_rewind)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t steps); \ + bool CMC_(PFX, _iter_go_to)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t index); \ + /* Iterator Access */ \ + V CMC_(PFX, _iter_value)(struct CMC_DEF_ITER(SNAME) * iter); \ + V *CMC_(PFX, _iter_rvalue)(struct CMC_DEF_ITER(SNAME) * iter); \ + size_t CMC_(PFX, _iter_index)(struct CMC_DEF_ITER(SNAME) * iter); /* ------------------------------------------------------------------------- * Source * ------------------------------------------------------------------------- */ -#define CMC_GENERATE_STACK_SOURCE(PFX, SNAME, V) \ +#define CMC_CMC_STACK_CORE_SOURCE_(PFX, SNAME, V) \ \ /* Implementation Detail Functions */ \ /* None */ \ \ - struct SNAME *PFX##_new(size_t capacity, struct SNAME##_fval *f_val) \ + struct SNAME *CMC_(PFX, _new)(size_t capacity, \ + struct CMC_DEF_FVAL(SNAME) * f_val) \ { \ struct cmc_alloc_node *alloc = &cmc_alloc_node_default; \ \ @@ -208,7 +219,7 @@ static const char *cmc_string_fmt_stack = "struct %s<%s> " \ _stack_->capacity = capacity; \ _stack_->count = 0; \ - _stack_->flag = cmc_flags.OK; \ + _stack_->flag = CMC_FLAG_OK; \ _stack_->f_val = f_val; \ _stack_->alloc = alloc; \ _stack_->callbacks = NULL; \ @@ -216,9 +227,9 @@ static const char *cmc_string_fmt_stack = "struct %s<%s> " return _stack_; \ } \ \ - struct SNAME *PFX##_new_custom( \ - size_t capacity, struct SNAME##_fval *f_val, \ - struct cmc_alloc_node *alloc, struct cmc_callbacks *callbacks) \ + struct SNAME *CMC_(PFX, _new_custom)( \ + size_t capacity, struct CMC_DEF_FVAL(SNAME) * f_val, \ + struct cmc_alloc_node * alloc, struct cmc_callbacks * callbacks) \ { \ if (capacity < 1) \ return NULL; \ @@ -243,7 +254,7 @@ static const char *cmc_string_fmt_stack = "struct %s<%s> " \ _stack_->capacity = capacity; \ _stack_->count = 0; \ - _stack_->flag = cmc_flags.OK; \ + _stack_->flag = CMC_FLAG_OK; \ _stack_->f_val = f_val; \ _stack_->alloc = alloc; \ _stack_->callbacks = callbacks; \ @@ -251,7 +262,7 @@ static const char *cmc_string_fmt_stack = "struct %s<%s> " return _stack_; \ } \ \ - void PFX##_clear(struct SNAME *_stack_) \ + void CMC_(PFX, _clear)(struct SNAME * _stack_) \ { \ if (_stack_->f_val->free) \ { \ @@ -262,10 +273,10 @@ static const char *cmc_string_fmt_stack = "struct %s<%s> " memset(_stack_->buffer, 0, sizeof(V) * _stack_->capacity); \ \ _stack_->count = 0; \ - _stack_->flag = cmc_flags.OK; \ + _stack_->flag = CMC_FLAG_OK; \ } \ \ - void PFX##_free(struct SNAME *_stack_) \ + void CMC_(PFX, _free)(struct SNAME * _stack_) \ { \ if (_stack_->f_val->free) \ { \ @@ -277,8 +288,9 @@ static const char *cmc_string_fmt_stack = "struct %s<%s> " _stack_->alloc->free(_stack_); \ } \ \ - void PFX##_customize(struct SNAME *_stack_, struct cmc_alloc_node *alloc, \ - struct cmc_callbacks *callbacks) \ + void CMC_(PFX, _customize)(struct SNAME * _stack_, \ + struct cmc_alloc_node * alloc, \ + struct cmc_callbacks * callbacks) \ { \ if (!alloc) \ _stack_->alloc = &cmc_alloc_node_default; \ @@ -287,20 +299,20 @@ static const char *cmc_string_fmt_stack = "struct %s<%s> " \ _stack_->callbacks = callbacks; \ \ - _stack_->flag = cmc_flags.OK; \ + _stack_->flag = CMC_FLAG_OK; \ } \ \ - bool PFX##_push(struct SNAME *_stack_, V value) \ + bool CMC_(PFX, _push)(struct SNAME * _stack_, V value) \ { \ - if (PFX##_full(_stack_)) \ + if (CMC_(PFX, _full)(_stack_)) \ { \ - if (!PFX##_resize(_stack_, _stack_->capacity * 2)) \ + if (!CMC_(PFX, _resize)(_stack_, _stack_->capacity * 2)) \ return false; \ } \ \ _stack_->buffer[_stack_->count++] = value; \ \ - _stack_->flag = cmc_flags.OK; \ + _stack_->flag = CMC_FLAG_OK; \ \ if (_stack_->callbacks && _stack_->callbacks->create) \ _stack_->callbacks->create(); \ @@ -308,17 +320,17 @@ static const char *cmc_string_fmt_stack = "struct %s<%s> " return true; \ } \ \ - bool PFX##_pop(struct SNAME *_stack_) \ + bool CMC_(PFX, _pop)(struct SNAME * _stack_) \ { \ - if (PFX##_empty(_stack_)) \ + if (CMC_(PFX, _empty)(_stack_)) \ { \ - _stack_->flag = cmc_flags.EMPTY; \ + _stack_->flag = CMC_FLAG_EMPTY; \ return false; \ } \ \ _stack_->buffer[--_stack_->count] = (V){ 0 }; \ \ - _stack_->flag = cmc_flags.OK; \ + _stack_->flag = CMC_FLAG_OK; \ \ if (_stack_->callbacks && _stack_->callbacks->delete) \ _stack_->callbacks->delete (); \ @@ -326,15 +338,15 @@ static const char *cmc_string_fmt_stack = "struct %s<%s> " return true; \ } \ \ - V PFX##_top(struct SNAME *_stack_) \ + V CMC_(PFX, _top)(struct SNAME * _stack_) \ { \ - if (PFX##_empty(_stack_)) \ + if (CMC_(PFX, _empty)(_stack_)) \ { \ - _stack_->flag = cmc_flags.EMPTY; \ + _stack_->flag = CMC_FLAG_EMPTY; \ return (V){ 0 }; \ } \ \ - _stack_->flag = cmc_flags.OK; \ + _stack_->flag = CMC_FLAG_OK; \ \ if (_stack_->callbacks && _stack_->callbacks->read) \ _stack_->callbacks->read(); \ @@ -342,9 +354,9 @@ static const char *cmc_string_fmt_stack = "struct %s<%s> " return _stack_->buffer[_stack_->count - 1]; \ } \ \ - bool PFX##_contains(struct SNAME *_stack_, V value) \ + bool CMC_(PFX, _contains)(struct SNAME * _stack_, V value) \ { \ - _stack_->flag = cmc_flags.OK; \ + _stack_->flag = CMC_FLAG_OK; \ \ bool result = false; \ \ @@ -363,39 +375,39 @@ static const char *cmc_string_fmt_stack = "struct %s<%s> " return result; \ } \ \ - bool PFX##_empty(struct SNAME *_stack_) \ + bool CMC_(PFX, _empty)(struct SNAME * _stack_) \ { \ return _stack_->count == 0; \ } \ \ - bool PFX##_full(struct SNAME *_stack_) \ + bool CMC_(PFX, _full)(struct SNAME * _stack_) \ { \ return _stack_->count >= _stack_->capacity; \ } \ \ - size_t PFX##_count(struct SNAME *_stack_) \ + size_t CMC_(PFX, _count)(struct SNAME * _stack_) \ { \ return _stack_->count; \ } \ \ - size_t PFX##_capacity(struct SNAME *_stack_) \ + size_t CMC_(PFX, _capacity)(struct SNAME * _stack_) \ { \ return _stack_->capacity; \ } \ \ - int PFX##_flag(struct SNAME *_stack_) \ + int CMC_(PFX, _flag)(struct SNAME * _stack_) \ { \ return _stack_->flag; \ } \ \ - bool PFX##_resize(struct SNAME *_stack_, size_t capacity) \ + bool CMC_(PFX, _resize)(struct SNAME * _stack_, size_t capacity) \ { \ if (_stack_->capacity == capacity) \ goto success; \ \ if (capacity < _stack_->count) \ { \ - _stack_->flag = cmc_flags.INVALID; \ + _stack_->flag = CMC_FLAG_INVALID; \ return false; \ } \ \ @@ -404,7 +416,7 @@ static const char *cmc_string_fmt_stack = "struct %s<%s> " \ if (!new_buffer) \ { \ - _stack_->flag = cmc_flags.ALLOC; \ + _stack_->flag = CMC_FLAG_ALLOC; \ return false; \ } \ \ @@ -415,7 +427,7 @@ static const char *cmc_string_fmt_stack = "struct %s<%s> " \ success: \ \ - _stack_->flag = cmc_flags.OK; \ + _stack_->flag = CMC_FLAG_OK; \ \ if (_stack_->callbacks && _stack_->callbacks->resize) \ _stack_->callbacks->resize(); \ @@ -423,15 +435,15 @@ static const char *cmc_string_fmt_stack = "struct %s<%s> " return true; \ } \ \ - struct SNAME *PFX##_copy_of(struct SNAME *_stack_) \ + struct SNAME *CMC_(PFX, _copy_of)(struct SNAME * _stack_) \ { \ struct SNAME *result = \ - PFX##_new_custom(_stack_->capacity, _stack_->f_val, \ - _stack_->alloc, _stack_->callbacks); \ + CMC_(PFX, _new_custom)(_stack_->capacity, _stack_->f_val, \ + _stack_->alloc, _stack_->callbacks); \ \ if (!result) \ { \ - _stack_->flag = cmc_flags.ERROR; \ + _stack_->flag = CMC_FLAG_ERROR; \ return NULL; \ } \ \ @@ -446,15 +458,15 @@ static const char *cmc_string_fmt_stack = "struct %s<%s> " \ result->count = _stack_->count; \ \ - _stack_->flag = cmc_flags.OK; \ + _stack_->flag = CMC_FLAG_OK; \ \ return result; \ } \ \ - bool PFX##_equals(struct SNAME *_stack1_, struct SNAME *_stack2_) \ + bool CMC_(PFX, _equals)(struct SNAME * _stack1_, struct SNAME * _stack2_) \ { \ - _stack1_->flag = cmc_flags.OK; \ - _stack2_->flag = cmc_flags.OK; \ + _stack1_->flag = CMC_FLAG_OK; \ + _stack2_->flag = CMC_FLAG_OK; \ \ if (_stack1_->count != _stack2_->count) \ return false; \ @@ -469,19 +481,19 @@ static const char *cmc_string_fmt_stack = "struct %s<%s> " return true; \ } \ \ - struct cmc_string PFX##_to_string(struct SNAME *_stack_) \ + struct cmc_string CMC_(PFX, _to_string)(struct SNAME * _stack_) \ { \ struct cmc_string str; \ struct SNAME *s_ = _stack_; \ \ - int n = snprintf(str.s, cmc_string_len, cmc_string_fmt_stack, #SNAME, \ - #V, s_, s_->buffer, s_->capacity, s_->count, \ + int n = snprintf(str.s, cmc_string_len, cmc_cmc_string_fmt_stack, \ + #SNAME, #V, s_, s_->buffer, s_->capacity, s_->count, \ s_->flag, s_->f_val, s_->alloc, s_->callbacks); \ \ return n >= 0 ? str : (struct cmc_string){ 0 }; \ } \ \ - bool PFX##_print(struct SNAME *_stack_, FILE *fptr) \ + bool CMC_(PFX, _print)(struct SNAME * _stack_, FILE * fptr) \ { \ for (size_t i = 0; i < _stack_->count; i++) \ { \ @@ -492,50 +504,50 @@ static const char *cmc_string_fmt_stack = "struct %s<%s> " return true; \ } \ \ - struct SNAME##_iter PFX##_iter_start(struct SNAME *target) \ + struct CMC_DEF_ITER(SNAME) CMC_(PFX, _iter_start)(struct SNAME * target) \ { \ - struct SNAME##_iter iter; \ + struct CMC_DEF_ITER(SNAME) iter; \ \ iter.target = target; \ iter.cursor = 0; \ iter.start = true; \ - iter.end = PFX##_empty(target); \ + iter.end = CMC_(PFX, _empty)(target); \ \ - if (!PFX##_empty(target)) \ + if (!CMC_(PFX, _empty)(target)) \ iter.cursor = target->count - 1; \ \ return iter; \ } \ \ - struct SNAME##_iter PFX##_iter_end(struct SNAME *target) \ + struct CMC_DEF_ITER(SNAME) CMC_(PFX, _iter_end)(struct SNAME * target) \ { \ - struct SNAME##_iter iter; \ + struct CMC_DEF_ITER(SNAME) iter; \ \ iter.target = target; \ iter.cursor = 0; \ - iter.start = PFX##_empty(target); \ + iter.start = CMC_(PFX, _empty)(target); \ iter.end = true; \ \ return iter; \ } \ \ - bool PFX##_iter_at_start(struct SNAME##_iter *iter) \ + bool CMC_(PFX, _iter_at_start)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ - return PFX##_empty(iter->target) || iter->start; \ + return CMC_(PFX, _empty)(iter->target) || iter->start; \ } \ \ - bool PFX##_iter_at_end(struct SNAME##_iter *iter) \ + bool CMC_(PFX, _iter_at_end)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ - return PFX##_empty(iter->target) || iter->end; \ + return CMC_(PFX, _empty)(iter->target) || iter->end; \ } \ \ - bool PFX##_iter_to_start(struct SNAME##_iter *iter) \ + bool CMC_(PFX, _iter_to_start)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ - if (!PFX##_empty(iter->target)) \ + if (!CMC_(PFX, _empty)(iter->target)) \ { \ iter->cursor = iter->target->count - 1; \ iter->start = true; \ - iter->end = PFX##_empty(iter->target); \ + iter->end = CMC_(PFX, _empty)(iter->target); \ \ return true; \ } \ @@ -543,12 +555,12 @@ static const char *cmc_string_fmt_stack = "struct %s<%s> " return false; \ } \ \ - bool PFX##_iter_to_end(struct SNAME##_iter *iter) \ + bool CMC_(PFX, _iter_to_end)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ - if (!PFX##_empty(iter->target)) \ + if (!CMC_(PFX, _empty)(iter->target)) \ { \ iter->cursor = 0; \ - iter->start = PFX##_empty(iter->target); \ + iter->start = CMC_(PFX, _empty)(iter->target); \ iter->end = true; \ \ return true; \ @@ -557,7 +569,7 @@ static const char *cmc_string_fmt_stack = "struct %s<%s> " return false; \ } \ \ - bool PFX##_iter_next(struct SNAME##_iter *iter) \ + bool CMC_(PFX, _iter_next)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ if (iter->end) \ return false; \ @@ -568,14 +580,14 @@ static const char *cmc_string_fmt_stack = "struct %s<%s> " return false; \ } \ \ - iter->start = PFX##_empty(iter->target); \ + iter->start = CMC_(PFX, _empty)(iter->target); \ \ iter->cursor--; \ \ return true; \ } \ \ - bool PFX##_iter_prev(struct SNAME##_iter *iter) \ + bool CMC_(PFX, _iter_prev)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ if (iter->start) \ return false; \ @@ -586,7 +598,7 @@ static const char *cmc_string_fmt_stack = "struct %s<%s> " return false; \ } \ \ - iter->end = PFX##_empty(iter->target); \ + iter->end = CMC_(PFX, _empty)(iter->target); \ \ iter->cursor++; \ \ @@ -594,7 +606,8 @@ static const char *cmc_string_fmt_stack = "struct %s<%s> " } \ \ /* Returns true only if the iterator moved */ \ - bool PFX##_iter_advance(struct SNAME##_iter *iter, size_t steps) \ + bool CMC_(PFX, _iter_advance)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t steps) \ { \ if (iter->end) \ return false; \ @@ -608,7 +621,7 @@ static const char *cmc_string_fmt_stack = "struct %s<%s> " if (steps == 0 || iter->cursor < steps) \ return false; \ \ - iter->start = PFX##_empty(iter->target); \ + iter->start = CMC_(PFX, _empty)(iter->target); \ \ iter->cursor -= steps; \ \ @@ -616,7 +629,8 @@ static const char *cmc_string_fmt_stack = "struct %s<%s> " } \ \ /* Returns true only if the iterator moved */ \ - bool PFX##_iter_rewind(struct SNAME##_iter *iter, size_t steps) \ + bool CMC_(PFX, _iter_rewind)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t steps) \ { \ if (iter->start) \ return false; \ @@ -630,7 +644,7 @@ static const char *cmc_string_fmt_stack = "struct %s<%s> " if (steps == 0 || iter->cursor + steps >= iter->target->count) \ return false; \ \ - iter->end = PFX##_empty(iter->target); \ + iter->end = CMC_(PFX, _empty)(iter->target); \ \ iter->cursor += steps; \ \ @@ -639,41 +653,42 @@ static const char *cmc_string_fmt_stack = "struct %s<%s> " \ /* Returns true only if the iterator was able to be positioned at the */ \ /* given index */ \ - bool PFX##_iter_go_to(struct SNAME##_iter *iter, size_t index) \ + bool CMC_(PFX, _iter_go_to)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t index) \ { \ if (index >= iter->target->count) \ return false; \ \ if (iter->cursor > index) \ - return PFX##_iter_advance(iter, iter->cursor - index); \ + return CMC_(PFX, _iter_advance)(iter, iter->cursor - index); \ else if (iter->cursor < index) \ - return PFX##_iter_rewind(iter, index - iter->cursor); \ + return CMC_(PFX, _iter_rewind)(iter, index - iter->cursor); \ \ return true; \ } \ \ - V PFX##_iter_value(struct SNAME##_iter *iter) \ + V CMC_(PFX, _iter_value)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ - if (PFX##_empty(iter->target)) \ + if (CMC_(PFX, _empty)(iter->target)) \ return (V){ 0 }; \ \ return iter->target->buffer[iter->cursor]; \ } \ \ - V *PFX##_iter_rvalue(struct SNAME##_iter *iter) \ + V *CMC_(PFX, _iter_rvalue)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ - if (PFX##_empty(iter->target)) \ + if (CMC_(PFX, _empty)(iter->target)) \ return NULL; \ \ return &(iter->target->buffer[iter->cursor]); \ } \ \ - size_t PFX##_iter_index(struct SNAME##_iter *iter) \ + size_t CMC_(PFX, _iter_index)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ - if (PFX##_empty(iter->target)) \ + if (CMC_(PFX, _empty)(iter->target)) \ return 0; \ \ return iter->target->count - 1 - iter->cursor; \ } -#endif /* CMC_STACK_H */ +#endif /* CMC_CMC_STACK_H */ diff --git a/src/cmc/treemap.h b/src/cmc/treemap.h index ebc1474..d5c3528 100644 --- a/src/cmc/treemap.h +++ b/src/cmc/treemap.h @@ -16,8 +16,8 @@ * tree called AVL Tree that uses the height of nodes to keep its keys balanced. */ -#ifndef CMC_TREEMAP_H -#define CMC_TREEMAP_H +#ifndef CMC_CMC_TREEMAP_H +#define CMC_CMC_TREEMAP_H /* ------------------------------------------------------------------------- * Core functionalities of the C Macro Collections Library @@ -28,36 +28,41 @@ * TreeMap specific * ------------------------------------------------------------------------- */ /* to_string format */ -static const char *cmc_string_fmt_treemap = "struct %s<%s, %s> " - "at %p { " - "root:%p, " - "count:%" PRIuMAX ", " - "flag:%d, " - "f_val:%p, " - "f_key:%p, " - "alloc:%p, " - "callbacks:%p }"; +static const char *cmc_cmc_string_fmt_treemap = "struct %s<%s, %s> " + "at %p { " + "root:%p, " + "count:%" PRIuMAX ", " + "flag:%d, " + "f_val:%p, " + "f_key:%p, " + "alloc:%p, " + "callbacks:%p }"; -#define CMC_GENERATE_TREEMAP(PFX, SNAME, K, V) \ - CMC_GENERATE_TREEMAP_HEADER(PFX, SNAME, K, V) \ - CMC_GENERATE_TREEMAP_SOURCE(PFX, SNAME, K, V) +/** + * Core TreeMap implementation + */ +#define CMC_CMC_TREEMAP_CORE(BODY) \ + CMC_CMC_TREEMAP_CORE_HEADER(BODY) \ + CMC_CMC_TREEMAP_CORE_SOURCE(BODY) -#define CMC_WRAPGEN_TREEMAP_HEADER(PFX, SNAME, K, V) \ - CMC_GENERATE_TREEMAP_HEADER(PFX, SNAME, K, V) +#define CMC_CMC_TREEMAP_CORE_HEADER(BODY) \ + CMC_CMC_TREEMAP_CORE_HEADER_(CMC_PARAM_PFX(BODY), CMC_PARAM_SNAME(BODY), \ + CMC_PARAM_K(BODY), CMC_PARAM_V(BODY)) -#define CMC_WRAPGEN_TREEMAP_SOURCE(PFX, SNAME, K, V) \ - CMC_GENERATE_TREEMAP_SOURCE(PFX, SNAME, K, V) +#define CMC_CMC_TREEMAP_CORE_SOURCE(BODY) \ + CMC_CMC_TREEMAP_CORE_SOURCE_(CMC_PARAM_PFX(BODY), CMC_PARAM_SNAME(BODY), \ + CMC_PARAM_K(BODY), CMC_PARAM_V(BODY)) /* ------------------------------------------------------------------------- * Header * ------------------------------------------------------------------------- */ -#define CMC_GENERATE_TREEMAP_HEADER(PFX, SNAME, K, V) \ +#define CMC_CMC_TREEMAP_CORE_HEADER_(PFX, SNAME, K, V) \ \ /* Treemap Structure */ \ struct SNAME \ { \ /* Root node */ \ - struct SNAME##_node *root; \ + struct CMC_DEF_NODE(SNAME) * root; \ \ /* Current amount of keys */ \ size_t count; \ @@ -66,10 +71,10 @@ static const char *cmc_string_fmt_treemap = "struct %s<%s, %s> " int flag; \ \ /* Key function table */ \ - struct SNAME##_fkey *f_key; \ + struct CMC_DEF_FKEY(SNAME) * f_key; \ \ /* Value function table */ \ - struct SNAME##_fval *f_val; \ + struct CMC_DEF_FVAL(SNAME) * f_val; \ \ /* Custom allocation functions */ \ struct cmc_alloc_node *alloc; \ @@ -79,7 +84,7 @@ static const char *cmc_string_fmt_treemap = "struct %s<%s, %s> " }; \ \ /* Treemap Node */ \ - struct SNAME##_node \ + struct CMC_DEF_NODE(SNAME) \ { \ /* Node Key */ \ K key; \ @@ -91,17 +96,17 @@ static const char *cmc_string_fmt_treemap = "struct %s<%s, %s> " unsigned char height; \ \ /* Right child node or subtree */ \ - struct SNAME##_node *right; \ + struct CMC_DEF_NODE(SNAME) * right; \ \ /* Left child node or subtree */ \ - struct SNAME##_node *left; \ + struct CMC_DEF_NODE(SNAME) * left; \ \ /* Parent node */ \ - struct SNAME##_node *parent; \ + struct CMC_DEF_NODE(SNAME) * parent; \ }; \ \ /* Key struct function table */ \ - struct SNAME##_fkey \ + struct CMC_DEF_FKEY(SNAME) \ { \ /* Comparator function */ \ int (*cmp)(K, K); \ @@ -123,7 +128,7 @@ static const char *cmc_string_fmt_treemap = "struct %s<%s, %s> " }; \ \ /* Value struct function table */ \ - struct SNAME##_fval \ + struct CMC_DEF_FVAL(SNAME) \ { \ /* Comparator function */ \ int (*cmp)(V, V); \ @@ -145,19 +150,19 @@ static const char *cmc_string_fmt_treemap = "struct %s<%s, %s> " }; \ \ /* Treemap Iterator */ \ - struct SNAME##_iter \ + struct CMC_DEF_ITER(SNAME) \ { \ /* Target treemap */ \ struct SNAME *target; \ \ /* Cursor's current node */ \ - struct SNAME##_node *cursor; \ + struct CMC_DEF_NODE(SNAME) * cursor; \ \ /* The first node in the iteration */ \ - struct SNAME##_node *first; \ + struct CMC_DEF_NODE(SNAME) * first; \ \ /* The last node in the iteration */ \ - struct SNAME##_node *last; \ + struct CMC_DEF_NODE(SNAME) * last; \ \ /* Keeps track of relative index to the iteration of elements */ \ size_t index; \ @@ -171,76 +176,85 @@ static const char *cmc_string_fmt_treemap = "struct %s<%s, %s> " \ /* Collection Functions */ \ /* Collection Allocation and Deallocation */ \ - struct SNAME *PFX##_new(struct SNAME##_fkey *f_key, \ - struct SNAME##_fval *f_val); \ - struct SNAME *PFX##_new_custom( \ - struct SNAME##_fkey *f_key, struct SNAME##_fval *f_val, \ - struct cmc_alloc_node *alloc, struct cmc_callbacks *callbacks); \ - void PFX##_clear(struct SNAME *_map_); \ - void PFX##_free(struct SNAME *_map_); \ + struct SNAME *CMC_(PFX, _new)(struct CMC_DEF_FKEY(SNAME) * f_key, \ + struct CMC_DEF_FVAL(SNAME) * f_val); \ + struct SNAME *CMC_(PFX, _new_custom)(struct CMC_DEF_FKEY(SNAME) * f_key, \ + struct CMC_DEF_FVAL(SNAME) * f_val, \ + struct cmc_alloc_node * alloc, \ + struct cmc_callbacks * callbacks); \ + void CMC_(PFX, _clear)(struct SNAME * _map_); \ + void CMC_(PFX, _free)(struct SNAME * _map_); \ /* Customization of Allocation and Callbacks */ \ - void PFX##_customize(struct SNAME *_map_, struct cmc_alloc_node *alloc, \ - struct cmc_callbacks *callbacks); \ + void CMC_(PFX, _customize)(struct SNAME * _map_, \ + struct cmc_alloc_node * alloc, \ + struct cmc_callbacks * callbacks); \ /* Collection Input and Output */ \ - bool PFX##_insert(struct SNAME *_map_, K key, V value); \ - bool PFX##_update(struct SNAME *_map_, K key, V new_value, V *old_value); \ - bool PFX##_remove(struct SNAME *_map_, K key, V *out_value); \ + bool CMC_(PFX, _insert)(struct SNAME * _map_, K key, V value); \ + bool CMC_(PFX, _update)(struct SNAME * _map_, K key, V new_value, \ + V * old_value); \ + bool CMC_(PFX, _remove)(struct SNAME * _map_, K key, V * out_value); \ /* Element Access */ \ - bool PFX##_max(struct SNAME *_map_, K *key, V *value); \ - bool PFX##_min(struct SNAME *_map_, K *key, V *value); \ - V PFX##_get(struct SNAME *_map_, K key); \ - V *PFX##_get_ref(struct SNAME *_map_, K key); \ + bool CMC_(PFX, _max)(struct SNAME * _map_, K * key, V * value); \ + bool CMC_(PFX, _min)(struct SNAME * _map_, K * key, V * value); \ + V CMC_(PFX, _get)(struct SNAME * _map_, K key); \ + V *CMC_(PFX, _get_ref)(struct SNAME * _map_, K key); \ /* Collection State */ \ - bool PFX##_contains(struct SNAME *_map_, K key); \ - bool PFX##_empty(struct SNAME *_map_); \ - size_t PFX##_count(struct SNAME *_map_); \ - int PFX##_flag(struct SNAME *_map_); \ + bool CMC_(PFX, _contains)(struct SNAME * _map_, K key); \ + bool CMC_(PFX, _empty)(struct SNAME * _map_); \ + size_t CMC_(PFX, _count)(struct SNAME * _map_); \ + int CMC_(PFX, _flag)(struct SNAME * _map_); \ /* Collection Utility */ \ - struct SNAME *PFX##_copy_of(struct SNAME *_map_); \ - bool PFX##_equals(struct SNAME *_map1_, struct SNAME *_map2_); \ - struct cmc_string PFX##_to_string(struct SNAME *_map_); \ - bool PFX##_print(struct SNAME *_map_, FILE *fptr); \ + struct SNAME *CMC_(PFX, _copy_of)(struct SNAME * _map_); \ + bool CMC_(PFX, _equals)(struct SNAME * _map1_, struct SNAME * _map2_); \ + struct cmc_string CMC_(PFX, _to_string)(struct SNAME * _map_); \ + bool CMC_(PFX, _print)(struct SNAME * _map_, FILE * fptr); \ \ /* Iterator Functions */ \ /* Iterator Initialization */ \ - struct SNAME##_iter PFX##_iter_start(struct SNAME *target); \ - struct SNAME##_iter PFX##_iter_end(struct SNAME *target); \ + struct CMC_DEF_ITER(SNAME) CMC_(PFX, _iter_start)(struct SNAME * target); \ + struct CMC_DEF_ITER(SNAME) CMC_(PFX, _iter_end)(struct SNAME * target); \ /* Iterator State */ \ - bool PFX##_iter_at_start(struct SNAME##_iter *iter); \ - bool PFX##_iter_at_end(struct SNAME##_iter *iter); \ + bool CMC_(PFX, _iter_at_start)(struct CMC_DEF_ITER(SNAME) * iter); \ + bool CMC_(PFX, _iter_at_end)(struct CMC_DEF_ITER(SNAME) * iter); \ /* Iterator Movement */ \ - bool PFX##_iter_to_start(struct SNAME##_iter *iter); \ - bool PFX##_iter_to_end(struct SNAME##_iter *iter); \ - bool PFX##_iter_next(struct SNAME##_iter *iter); \ - bool PFX##_iter_prev(struct SNAME##_iter *iter); \ - bool PFX##_iter_advance(struct SNAME##_iter *iter, size_t steps); \ - bool PFX##_iter_rewind(struct SNAME##_iter *iter, size_t steps); \ - bool PFX##_iter_go_to(struct SNAME##_iter *iter, size_t index); \ + bool CMC_(PFX, _iter_to_start)(struct CMC_DEF_ITER(SNAME) * iter); \ + bool CMC_(PFX, _iter_to_end)(struct CMC_DEF_ITER(SNAME) * iter); \ + bool CMC_(PFX, _iter_next)(struct CMC_DEF_ITER(SNAME) * iter); \ + bool CMC_(PFX, _iter_prev)(struct CMC_DEF_ITER(SNAME) * iter); \ + bool CMC_(PFX, _iter_advance)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t steps); \ + bool CMC_(PFX, _iter_rewind)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t steps); \ + bool CMC_(PFX, _iter_go_to)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t index); \ /* Iterator Access */ \ - K PFX##_iter_key(struct SNAME##_iter *iter); \ - V PFX##_iter_value(struct SNAME##_iter *iter); \ - V *PFX##_iter_rvalue(struct SNAME##_iter *iter); \ - size_t PFX##_iter_index(struct SNAME##_iter *iter); + K CMC_(PFX, _iter_key)(struct CMC_DEF_ITER(SNAME) * iter); \ + V CMC_(PFX, _iter_value)(struct CMC_DEF_ITER(SNAME) * iter); \ + V *CMC_(PFX, _iter_rvalue)(struct CMC_DEF_ITER(SNAME) * iter); \ + size_t CMC_(PFX, _iter_index)(struct CMC_DEF_ITER(SNAME) * iter); /* ------------------------------------------------------------------------- * Source * ------------------------------------------------------------------------- */ -#define CMC_GENERATE_TREEMAP_SOURCE(PFX, SNAME, K, V) \ +#define CMC_CMC_TREEMAP_CORE_SOURCE_(PFX, SNAME, K, V) \ \ /* Implementation Detail Functions */ \ - static struct SNAME##_node *PFX##_impl_new_node(struct SNAME *_map_, \ - K key, V value); \ - static struct SNAME##_node *PFX##_impl_get_node(struct SNAME *_map_, \ - K key); \ - static unsigned char PFX##_impl_h(struct SNAME##_node *node); \ - static unsigned char PFX##_impl_hupdate(struct SNAME##_node *node); \ - static void PFX##_impl_rotate_right(struct SNAME##_node **Z); \ - static void PFX##_impl_rotate_left(struct SNAME##_node **Z); \ - static void PFX##_impl_rebalance(struct SNAME *_map_, \ - struct SNAME##_node *node); \ + static struct CMC_DEF_NODE(SNAME) * \ + CMC_(PFX, _impl_new_node)(struct SNAME * _map_, K key, V value); \ + static struct CMC_DEF_NODE(SNAME) * \ + CMC_(PFX, _impl_get_node)(struct SNAME * _map_, K key); \ + static unsigned char CMC_(PFX, \ + _impl_h)(struct CMC_DEF_NODE(SNAME) * node); \ + static unsigned char CMC_(PFX, _impl_hupdate)(struct CMC_DEF_NODE(SNAME) * \ + node); \ + static void CMC_(PFX, \ + _impl_rotate_right)(struct CMC_DEF_NODE(SNAME) * *Z); \ + static void CMC_(PFX, _impl_rotate_left)(struct CMC_DEF_NODE(SNAME) * *Z); \ + static void CMC_(PFX, _impl_rebalance)(struct SNAME * _map_, \ + struct CMC_DEF_NODE(SNAME) * node); \ \ - struct SNAME *PFX##_new(struct SNAME##_fkey *f_key, \ - struct SNAME##_fval *f_val) \ + struct SNAME *CMC_(PFX, _new)(struct CMC_DEF_FKEY(SNAME) * f_key, \ + struct CMC_DEF_FVAL(SNAME) * f_val) \ { \ if (!f_key || !f_val) \ return NULL; \ @@ -254,7 +268,7 @@ static const char *cmc_string_fmt_treemap = "struct %s<%s, %s> " \ _map_->count = 0; \ _map_->root = NULL; \ - _map_->flag = cmc_flags.OK; \ + _map_->flag = CMC_FLAG_OK; \ _map_->f_key = f_key; \ _map_->f_val = f_val; \ _map_->alloc = alloc; \ @@ -263,9 +277,10 @@ static const char *cmc_string_fmt_treemap = "struct %s<%s, %s> " return _map_; \ } \ \ - struct SNAME *PFX##_new_custom( \ - struct SNAME##_fkey *f_key, struct SNAME##_fval *f_val, \ - struct cmc_alloc_node *alloc, struct cmc_callbacks *callbacks) \ + struct SNAME *CMC_(PFX, _new_custom)(struct CMC_DEF_FKEY(SNAME) * f_key, \ + struct CMC_DEF_FVAL(SNAME) * f_val, \ + struct cmc_alloc_node * alloc, \ + struct cmc_callbacks * callbacks) \ { \ if (!f_key || !f_val) \ return NULL; \ @@ -280,7 +295,7 @@ static const char *cmc_string_fmt_treemap = "struct %s<%s, %s> " \ _map_->count = 0; \ _map_->root = NULL; \ - _map_->flag = cmc_flags.OK; \ + _map_->flag = CMC_FLAG_OK; \ _map_->f_key = f_key; \ _map_->f_val = f_val; \ _map_->alloc = alloc; \ @@ -289,16 +304,16 @@ static const char *cmc_string_fmt_treemap = "struct %s<%s, %s> " return _map_; \ } \ \ - void PFX##_clear(struct SNAME *_map_) \ + void CMC_(PFX, _clear)(struct SNAME * _map_) \ { \ - struct SNAME##_node *scan = _map_->root; \ - struct SNAME##_node *up = NULL; \ + struct CMC_DEF_NODE(SNAME) *scan = _map_->root; \ + struct CMC_DEF_NODE(SNAME) *up = NULL; \ \ while (scan != NULL) \ { \ if (scan->left != NULL) \ { \ - struct SNAME##_node *left = scan->left; \ + struct CMC_DEF_NODE(SNAME) *left = scan->left; \ \ scan->left = up; \ up = scan; \ @@ -306,7 +321,7 @@ static const char *cmc_string_fmt_treemap = "struct %s<%s, %s> " } \ else if (scan->right != NULL) \ { \ - struct SNAME##_node *right = scan->right; \ + struct CMC_DEF_NODE(SNAME) *right = scan->right; \ \ scan->left = up; \ scan->right = NULL; \ @@ -352,18 +367,19 @@ static const char *cmc_string_fmt_treemap = "struct %s<%s, %s> " \ _map_->count = 0; \ _map_->root = NULL; \ - _map_->flag = cmc_flags.OK; \ + _map_->flag = CMC_FLAG_OK; \ } \ \ - void PFX##_free(struct SNAME *_map_) \ + void CMC_(PFX, _free)(struct SNAME * _map_) \ { \ - PFX##_clear(_map_); \ + CMC_(PFX, _clear)(_map_); \ \ _map_->alloc->free(_map_); \ } \ \ - void PFX##_customize(struct SNAME *_map_, struct cmc_alloc_node *alloc, \ - struct cmc_callbacks *callbacks) \ + void CMC_(PFX, _customize)(struct SNAME * _map_, \ + struct cmc_alloc_node * alloc, \ + struct cmc_callbacks * callbacks) \ { \ if (!alloc) \ _map_->alloc = &cmc_alloc_node_default; \ @@ -372,25 +388,25 @@ static const char *cmc_string_fmt_treemap = "struct %s<%s, %s> " \ _map_->callbacks = callbacks; \ \ - _map_->flag = cmc_flags.OK; \ + _map_->flag = CMC_FLAG_OK; \ } \ \ - bool PFX##_insert(struct SNAME *_map_, K key, V value) \ + bool CMC_(PFX, _insert)(struct SNAME * _map_, K key, V value) \ { \ - if (PFX##_empty(_map_)) \ + if (CMC_(PFX, _empty)(_map_)) \ { \ - _map_->root = PFX##_impl_new_node(_map_, key, value); \ + _map_->root = CMC_(PFX, _impl_new_node)(_map_, key, value); \ \ if (!_map_->root) \ { \ - _map_->flag = cmc_flags.ALLOC; \ + _map_->flag = CMC_FLAG_ALLOC; \ return false; \ } \ } \ else \ { \ - struct SNAME##_node *scan = _map_->root; \ - struct SNAME##_node *parent = scan; \ + struct CMC_DEF_NODE(SNAME) *scan = _map_->root; \ + struct CMC_DEF_NODE(SNAME) *parent = scan; \ \ while (scan != NULL) \ { \ @@ -402,20 +418,20 @@ static const char *cmc_string_fmt_treemap = "struct %s<%s, %s> " scan = scan->right; \ else \ { \ - _map_->flag = cmc_flags.DUPLICATE; \ + _map_->flag = CMC_FLAG_DUPLICATE; \ return false; \ } \ } \ \ - struct SNAME##_node *node; \ + struct CMC_DEF_NODE(SNAME) * node; \ \ if (_map_->f_key->cmp(parent->key, key) > 0) \ { \ - parent->left = PFX##_impl_new_node(_map_, key, value); \ + parent->left = CMC_(PFX, _impl_new_node)(_map_, key, value); \ \ if (!parent->left) \ { \ - _map_->flag = cmc_flags.ALLOC; \ + _map_->flag = CMC_FLAG_ALLOC; \ return false; \ } \ \ @@ -424,11 +440,11 @@ static const char *cmc_string_fmt_treemap = "struct %s<%s, %s> " } \ else \ { \ - parent->right = PFX##_impl_new_node(_map_, key, value); \ + parent->right = CMC_(PFX, _impl_new_node)(_map_, key, value); \ \ if (!parent->right) \ { \ - _map_->flag = cmc_flags.ALLOC; \ + _map_->flag = CMC_FLAG_ALLOC; \ return false; \ } \ \ @@ -436,11 +452,11 @@ static const char *cmc_string_fmt_treemap = "struct %s<%s, %s> " node = parent->right; \ } \ \ - PFX##_impl_rebalance(_map_, node); \ + CMC_(PFX, _impl_rebalance)(_map_, node); \ } \ \ _map_->count++; \ - _map_->flag = cmc_flags.OK; \ + _map_->flag = CMC_FLAG_OK; \ \ if (_map_->callbacks && _map_->callbacks->create) \ _map_->callbacks->create(); \ @@ -448,13 +464,15 @@ static const char *cmc_string_fmt_treemap = "struct %s<%s, %s> " return true; \ } \ \ - bool PFX##_update(struct SNAME *_map_, K key, V new_value, V *old_value) \ + bool CMC_(PFX, _update)(struct SNAME * _map_, K key, V new_value, \ + V * old_value) \ { \ - struct SNAME##_node *node = PFX##_impl_get_node(_map_, key); \ + struct CMC_DEF_NODE(SNAME) *node = \ + CMC_(PFX, _impl_get_node)(_map_, key); \ \ if (!node) \ { \ - _map_->flag = cmc_flags.NOT_FOUND; \ + _map_->flag = CMC_FLAG_NOT_FOUND; \ return false; \ } \ \ @@ -463,7 +481,7 @@ static const char *cmc_string_fmt_treemap = "struct %s<%s, %s> " \ node->value = new_value; \ \ - _map_->flag = cmc_flags.OK; \ + _map_->flag = CMC_FLAG_OK; \ \ if (_map_->callbacks && _map_->callbacks->update) \ _map_->callbacks->update(); \ @@ -471,26 +489,27 @@ static const char *cmc_string_fmt_treemap = "struct %s<%s, %s> " return true; \ } \ \ - bool PFX##_remove(struct SNAME *_map_, K key, V *out_value) \ + bool CMC_(PFX, _remove)(struct SNAME * _map_, K key, V * out_value) \ { \ - if (PFX##_empty(_map_)) \ + if (CMC_(PFX, _empty)(_map_)) \ { \ - _map_->flag = cmc_flags.EMPTY; \ + _map_->flag = CMC_FLAG_EMPTY; \ return false; \ } \ \ - struct SNAME##_node *node = PFX##_impl_get_node(_map_, key); \ + struct CMC_DEF_NODE(SNAME) *node = \ + CMC_(PFX, _impl_get_node)(_map_, key); \ \ if (!node) \ { \ - _map_->flag = cmc_flags.NOT_FOUND; \ + _map_->flag = CMC_FLAG_NOT_FOUND; \ return false; \ } \ \ if (out_value) \ *out_value = node->value; \ \ - struct SNAME##_node *temp = NULL, *unbalanced = NULL; \ + struct CMC_DEF_NODE(SNAME) *temp = NULL, *unbalanced = NULL; \ \ bool is_root = node->parent == NULL; \ \ @@ -596,13 +615,13 @@ static const char *cmc_string_fmt_treemap = "struct %s<%s, %s> " } \ \ if (unbalanced != NULL) \ - PFX##_impl_rebalance(_map_, unbalanced); \ + CMC_(PFX, _impl_rebalance)(_map_, unbalanced); \ \ if (_map_->count == 0) \ _map_->root = NULL; \ \ _map_->count--; \ - _map_->flag = cmc_flags.OK; \ + _map_->flag = CMC_FLAG_OK; \ \ if (_map_->callbacks && _map_->callbacks->delete) \ _map_->callbacks->delete (); \ @@ -610,15 +629,15 @@ static const char *cmc_string_fmt_treemap = "struct %s<%s, %s> " return true; \ } \ \ - bool PFX##_max(struct SNAME *_map_, K *key, V *value) \ + bool CMC_(PFX, _max)(struct SNAME * _map_, K * key, V * value) \ { \ - if (PFX##_empty(_map_)) \ + if (CMC_(PFX, _empty)(_map_)) \ { \ - _map_->flag = cmc_flags.EMPTY; \ + _map_->flag = CMC_FLAG_EMPTY; \ return false; \ } \ \ - struct SNAME##_node *scan = _map_->root; \ + struct CMC_DEF_NODE(SNAME) *scan = _map_->root; \ \ while (scan->right != NULL) \ scan = scan->right; \ @@ -628,7 +647,7 @@ static const char *cmc_string_fmt_treemap = "struct %s<%s, %s> " if (value) \ *value = scan->value; \ \ - _map_->flag = cmc_flags.OK; \ + _map_->flag = CMC_FLAG_OK; \ \ if (_map_->callbacks && _map_->callbacks->read) \ _map_->callbacks->read(); \ @@ -636,15 +655,15 @@ static const char *cmc_string_fmt_treemap = "struct %s<%s, %s> " return true; \ } \ \ - bool PFX##_min(struct SNAME *_map_, K *key, V *value) \ + bool CMC_(PFX, _min)(struct SNAME * _map_, K * key, V * value) \ { \ - if (PFX##_empty(_map_)) \ + if (CMC_(PFX, _empty)(_map_)) \ { \ - _map_->flag = cmc_flags.EMPTY; \ + _map_->flag = CMC_FLAG_EMPTY; \ return false; \ } \ \ - struct SNAME##_node *scan = _map_->root; \ + struct CMC_DEF_NODE(SNAME) *scan = _map_->root; \ \ while (scan->left != NULL) \ scan = scan->left; \ @@ -654,7 +673,7 @@ static const char *cmc_string_fmt_treemap = "struct %s<%s, %s> " if (value) \ *value = scan->value; \ \ - _map_->flag = cmc_flags.OK; \ + _map_->flag = CMC_FLAG_OK; \ \ if (_map_->callbacks && _map_->callbacks->read) \ _map_->callbacks->read(); \ @@ -662,23 +681,24 @@ static const char *cmc_string_fmt_treemap = "struct %s<%s, %s> " return true; \ } \ \ - V PFX##_get(struct SNAME *_map_, K key) \ + V CMC_(PFX, _get)(struct SNAME * _map_, K key) \ { \ - if (PFX##_empty(_map_)) \ + if (CMC_(PFX, _empty)(_map_)) \ { \ - _map_->flag = cmc_flags.EMPTY; \ + _map_->flag = CMC_FLAG_EMPTY; \ return false; \ } \ \ - struct SNAME##_node *node = PFX##_impl_get_node(_map_, key); \ + struct CMC_DEF_NODE(SNAME) *node = \ + CMC_(PFX, _impl_get_node)(_map_, key); \ \ if (!node) \ { \ - _map_->flag = cmc_flags.NOT_FOUND; \ + _map_->flag = CMC_FLAG_NOT_FOUND; \ return (V){ 0 }; \ } \ \ - _map_->flag = cmc_flags.OK; \ + _map_->flag = CMC_FLAG_OK; \ \ if (_map_->callbacks && _map_->callbacks->read) \ _map_->callbacks->read(); \ @@ -686,23 +706,24 @@ static const char *cmc_string_fmt_treemap = "struct %s<%s, %s> " return node->value; \ } \ \ - V *PFX##_get_ref(struct SNAME *_map_, K key) \ + V *CMC_(PFX, _get_ref)(struct SNAME * _map_, K key) \ { \ - if (PFX##_empty(_map_)) \ + if (CMC_(PFX, _empty)(_map_)) \ { \ - _map_->flag = cmc_flags.EMPTY; \ + _map_->flag = CMC_FLAG_EMPTY; \ return false; \ } \ \ - struct SNAME##_node *node = PFX##_impl_get_node(_map_, key); \ + struct CMC_DEF_NODE(SNAME) *node = \ + CMC_(PFX, _impl_get_node)(_map_, key); \ \ if (!node) \ { \ - _map_->flag = cmc_flags.NOT_FOUND; \ + _map_->flag = CMC_FLAG_NOT_FOUND; \ return NULL; \ } \ \ - _map_->flag = cmc_flags.OK; \ + _map_->flag = CMC_FLAG_OK; \ \ if (_map_->callbacks && _map_->callbacks->read) \ _map_->callbacks->read(); \ @@ -710,9 +731,9 @@ static const char *cmc_string_fmt_treemap = "struct %s<%s, %s> " return &(node->value); \ } \ \ - bool PFX##_contains(struct SNAME *_map_, K key) \ + bool CMC_(PFX, _contains)(struct SNAME * _map_, K key) \ { \ - bool result = PFX##_impl_get_node(_map_, key) != NULL; \ + bool result = CMC_(PFX, _impl_get_node)(_map_, key) != NULL; \ \ if (_map_->callbacks && _map_->callbacks->read) \ _map_->callbacks->read(); \ @@ -720,40 +741,40 @@ static const char *cmc_string_fmt_treemap = "struct %s<%s, %s> " return result; \ } \ \ - bool PFX##_empty(struct SNAME *_map_) \ + bool CMC_(PFX, _empty)(struct SNAME * _map_) \ { \ return _map_->count == 0; \ } \ \ - size_t PFX##_count(struct SNAME *_map_) \ + size_t CMC_(PFX, _count)(struct SNAME * _map_) \ { \ return _map_->count; \ } \ \ - int PFX##_flag(struct SNAME *_map_) \ + int CMC_(PFX, _flag)(struct SNAME * _map_) \ { \ return _map_->flag; \ } \ \ - struct SNAME *PFX##_copy_of(struct SNAME *_map_) \ + struct SNAME *CMC_(PFX, _copy_of)(struct SNAME * _map_) \ { \ /* Callback will be added later */ \ - struct SNAME *result = \ - PFX##_new_custom(_map_->f_key, _map_->f_val, _map_->alloc, NULL); \ + struct SNAME *result = CMC_(PFX, _new_custom)( \ + _map_->f_key, _map_->f_val, _map_->alloc, NULL); \ \ if (!result) \ { \ - _map_->flag = cmc_flags.ERROR; \ + _map_->flag = CMC_FLAG_ERROR; \ return NULL; \ } \ \ /* TODO turn this into a normal loop */ \ - struct SNAME##_iter iter = PFX##_iter_start(_map_); \ + struct CMC_DEF_ITER(SNAME) iter = CMC_(PFX, _iter_start)(_map_); \ \ - for (; !PFX##_iter_at_end(&iter); PFX##_iter_next(&iter)) \ + for (; !CMC_(PFX, _iter_at_end)(&iter); CMC_(PFX, _iter_next)(&iter)) \ { \ - K key = PFX##_iter_key(&iter); \ - V value = PFX##_iter_value(&iter); \ + K key = CMC_(PFX, _iter_key)(&iter); \ + V value = CMC_(PFX, _iter_value)(&iter); \ \ if (_map_->f_key->cpy) \ key = _map_->f_key->cpy(key); \ @@ -761,56 +782,57 @@ static const char *cmc_string_fmt_treemap = "struct %s<%s, %s> " value = _map_->f_val->cpy(value); \ \ /* TODO check this for errors */ \ - PFX##_insert(result, key, value); \ + CMC_(PFX, _insert)(result, key, value); \ } \ \ result->callbacks = _map_->callbacks; \ - _map_->flag = cmc_flags.OK; \ + _map_->flag = CMC_FLAG_OK; \ \ return result; \ } \ \ - bool PFX##_equals(struct SNAME *_map1_, struct SNAME *_map2_) \ + bool CMC_(PFX, _equals)(struct SNAME * _map1_, struct SNAME * _map2_) \ { \ - _map1_->flag = cmc_flags.OK; \ - _map2_->flag = cmc_flags.OK; \ + _map1_->flag = CMC_FLAG_OK; \ + _map2_->flag = CMC_FLAG_OK; \ \ if (_map1_->count != _map2_->count) \ return false; \ \ /* TODO turn this into a normal loop */ \ - struct SNAME##_iter iter = PFX##_iter_start(_map1_); \ + struct CMC_DEF_ITER(SNAME) iter = CMC_(PFX, _iter_start)(_map1_); \ \ - for (; !PFX##_iter_at_end(&iter); PFX##_iter_next(&iter)) \ + for (; !CMC_(PFX, _iter_at_end)(&iter); CMC_(PFX, _iter_next)(&iter)) \ { \ - struct SNAME##_node *node = \ - PFX##_impl_get_node(_map2_, PFX##_iter_key(&iter)); \ + struct CMC_DEF_NODE(SNAME) *node = CMC_(PFX, _impl_get_node)( \ + _map2_, CMC_(PFX, _iter_key)(&iter)); \ \ if (node == NULL) \ return false; \ \ - if (_map1_->f_val->cmp(node->value, PFX##_iter_value(&iter)) != 0) \ + if (_map1_->f_val->cmp(node->value, \ + CMC_(PFX, _iter_value)(&iter)) != 0) \ return false; \ } \ \ return true; \ } \ \ - struct cmc_string PFX##_to_string(struct SNAME *_map_) \ + struct cmc_string CMC_(PFX, _to_string)(struct SNAME * _map_) \ { \ struct cmc_string str; \ struct SNAME *m_ = _map_; \ \ - int n = snprintf(str.s, cmc_string_len, cmc_string_fmt_treemap, \ + int n = snprintf(str.s, cmc_string_len, cmc_cmc_string_fmt_treemap, \ #SNAME, #K, #V, m_, m_->root, m_->count, m_->flag, \ m_->f_key, m_->f_val, m_->alloc, m_->callbacks); \ \ return n >= 0 ? str : (struct cmc_string){ 0 }; \ } \ \ - bool PFX##_print(struct SNAME *_map_, FILE *fptr) \ + bool CMC_(PFX, _print)(struct SNAME * _map_, FILE * fptr) \ { \ - struct SNAME##_node *root = _map_->root; \ + struct CMC_DEF_NODE(SNAME) *root = _map_->root; \ \ bool left_done = false; \ \ @@ -850,9 +872,9 @@ static const char *cmc_string_fmt_treemap = "struct %s<%s, %s> " return true; \ } \ \ - struct SNAME##_iter PFX##_iter_start(struct SNAME *target) \ + struct CMC_DEF_ITER(SNAME) CMC_(PFX, _iter_start)(struct SNAME * target) \ { \ - struct SNAME##_iter iter; \ + struct CMC_DEF_ITER(SNAME) iter; \ \ iter.target = target; \ iter.cursor = target->root; \ @@ -860,9 +882,9 @@ static const char *cmc_string_fmt_treemap = "struct %s<%s, %s> " iter.last = NULL; \ iter.index = 0; \ iter.start = true; \ - iter.end = PFX##_empty(target); \ + iter.end = CMC_(PFX, _empty)(target); \ \ - if (!PFX##_empty(target)) \ + if (!CMC_(PFX, _empty)(target)) \ { \ while (iter.cursor->left != NULL) \ iter.cursor = iter.cursor->left; \ @@ -877,19 +899,19 @@ static const char *cmc_string_fmt_treemap = "struct %s<%s, %s> " return iter; \ } \ \ - struct SNAME##_iter PFX##_iter_end(struct SNAME *target) \ + struct CMC_DEF_ITER(SNAME) CMC_(PFX, _iter_end)(struct SNAME * target) \ { \ - struct SNAME##_iter iter; \ + struct CMC_DEF_ITER(SNAME) iter; \ \ iter.target = target; \ iter.cursor = target->root; \ iter.first = NULL; \ iter.last = NULL; \ iter.index = 0; \ - iter.start = PFX##_empty(target); \ + iter.start = CMC_(PFX, _empty)(target); \ iter.end = true; \ \ - if (!PFX##_empty(target)) \ + if (!CMC_(PFX, _empty)(target)) \ { \ while (iter.cursor->right != NULL) \ iter.cursor = iter.cursor->right; \ @@ -906,23 +928,23 @@ static const char *cmc_string_fmt_treemap = "struct %s<%s, %s> " return iter; \ } \ \ - bool PFX##_iter_at_start(struct SNAME##_iter *iter) \ + bool CMC_(PFX, _iter_at_start)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ - return PFX##_empty(iter->target) || iter->start; \ + return CMC_(PFX, _empty)(iter->target) || iter->start; \ } \ \ - bool PFX##_iter_at_end(struct SNAME##_iter *iter) \ + bool CMC_(PFX, _iter_at_end)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ - return PFX##_empty(iter->target) || iter->end; \ + return CMC_(PFX, _empty)(iter->target) || iter->end; \ } \ \ - bool PFX##_iter_to_start(struct SNAME##_iter *iter) \ + bool CMC_(PFX, _iter_to_start)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ - if (!PFX##_empty(iter->target)) \ + if (!CMC_(PFX, _empty)(iter->target)) \ { \ iter->index = 0; \ iter->start = true; \ - iter->end = PFX##_empty(iter->target); \ + iter->end = CMC_(PFX, _empty)(iter->target); \ iter->cursor = iter->first; \ \ return true; \ @@ -931,12 +953,12 @@ static const char *cmc_string_fmt_treemap = "struct %s<%s, %s> " return false; \ } \ \ - bool PFX##_iter_to_end(struct SNAME##_iter *iter) \ + bool CMC_(PFX, _iter_to_end)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ - if (!PFX##_empty(iter->target)) \ + if (!CMC_(PFX, _empty)(iter->target)) \ { \ iter->index = iter->target->count - 1; \ - iter->start = PFX##_empty(iter->target); \ + iter->start = CMC_(PFX, _empty)(iter->target); \ iter->end = true; \ iter->cursor = iter->last; \ \ @@ -946,7 +968,7 @@ static const char *cmc_string_fmt_treemap = "struct %s<%s, %s> " return false; \ } \ \ - bool PFX##_iter_next(struct SNAME##_iter *iter) \ + bool CMC_(PFX, _iter_next)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ if (iter->end) \ return false; \ @@ -957,7 +979,7 @@ static const char *cmc_string_fmt_treemap = "struct %s<%s, %s> " return false; \ } \ \ - iter->start = PFX##_empty(iter->target); \ + iter->start = CMC_(PFX, _empty)(iter->target); \ \ if (iter->cursor->right != NULL) \ { \ @@ -986,7 +1008,7 @@ static const char *cmc_string_fmt_treemap = "struct %s<%s, %s> " } \ } \ \ - bool PFX##_iter_prev(struct SNAME##_iter *iter) \ + bool CMC_(PFX, _iter_prev)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ if (iter->start) \ return false; \ @@ -997,7 +1019,7 @@ static const char *cmc_string_fmt_treemap = "struct %s<%s, %s> " return false; \ } \ \ - iter->end = PFX##_empty(iter->target); \ + iter->end = CMC_(PFX, _empty)(iter->target); \ \ if (iter->cursor->left != NULL) \ { \ @@ -1027,7 +1049,8 @@ static const char *cmc_string_fmt_treemap = "struct %s<%s, %s> " } \ \ /* Returns true only if the iterator moved */ \ - bool PFX##_iter_advance(struct SNAME##_iter *iter, size_t steps) \ + bool CMC_(PFX, _iter_advance)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t steps) \ { \ if (iter->end) \ return false; \ @@ -1042,13 +1065,14 @@ static const char *cmc_string_fmt_treemap = "struct %s<%s, %s> " return false; \ \ for (size_t i = 0; i < steps; i++) \ - PFX##_iter_next(iter); \ + CMC_(PFX, _iter_next)(iter); \ \ return true; \ } \ \ /* Returns true only if the iterator moved */ \ - bool PFX##_iter_rewind(struct SNAME##_iter *iter, size_t steps) \ + bool CMC_(PFX, _iter_rewind)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t steps) \ { \ if (iter->start) \ return false; \ @@ -1063,60 +1087,61 @@ static const char *cmc_string_fmt_treemap = "struct %s<%s, %s> " return false; \ \ for (size_t i = 0; i < steps; i++) \ - PFX##_iter_prev(iter); \ + CMC_(PFX, _iter_prev)(iter); \ \ return true; \ } \ \ /* Returns true only if the iterator was able to be positioned at the */ \ /* given index */ \ - bool PFX##_iter_go_to(struct SNAME##_iter *iter, size_t index) \ + bool CMC_(PFX, _iter_go_to)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t index) \ { \ if (index >= iter->target->count) \ return false; \ \ if (iter->index > index) \ - return PFX##_iter_rewind(iter, iter->index - index); \ + return CMC_(PFX, _iter_rewind)(iter, iter->index - index); \ else if (iter->index < index) \ - return PFX##_iter_advance(iter, index - iter->index); \ + return CMC_(PFX, _iter_advance)(iter, index - iter->index); \ \ return true; \ } \ \ - K PFX##_iter_key(struct SNAME##_iter *iter) \ + K CMC_(PFX, _iter_key)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ - if (PFX##_empty(iter->target)) \ + if (CMC_(PFX, _empty)(iter->target)) \ return (K){ 0 }; \ \ return iter->cursor->key; \ } \ \ - V PFX##_iter_value(struct SNAME##_iter *iter) \ + V CMC_(PFX, _iter_value)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ - if (PFX##_empty(iter->target)) \ + if (CMC_(PFX, _empty)(iter->target)) \ return (V){ 0 }; \ \ return iter->cursor->value; \ } \ \ - V *PFX##_iter_rvalue(struct SNAME##_iter *iter) \ + V *CMC_(PFX, _iter_rvalue)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ - if (PFX##_empty(iter->target)) \ + if (CMC_(PFX, _empty)(iter->target)) \ return NULL; \ \ return &(iter->cursor->value); \ } \ \ - size_t PFX##_iter_index(struct SNAME##_iter *iter) \ + size_t CMC_(PFX, _iter_index)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ return iter->index; \ } \ \ - static struct SNAME##_node *PFX##_impl_new_node(struct SNAME *_map_, \ - K key, V value) \ + static struct CMC_DEF_NODE(SNAME) * \ + CMC_(PFX, _impl_new_node)(struct SNAME * _map_, K key, V value) \ { \ - struct SNAME##_node *node = \ - _map_->alloc->malloc(sizeof(struct SNAME##_node)); \ + struct CMC_DEF_NODE(SNAME) *node = \ + _map_->alloc->malloc(sizeof(struct CMC_DEF_NODE(SNAME))); \ \ if (!node) \ return NULL; \ @@ -1131,10 +1156,10 @@ static const char *cmc_string_fmt_treemap = "struct %s<%s, %s> " return node; \ } \ \ - static struct SNAME##_node *PFX##_impl_get_node(struct SNAME *_map_, \ - K key) \ + static struct CMC_DEF_NODE(SNAME) * \ + CMC_(PFX, _impl_get_node)(struct SNAME * _map_, K key) \ { \ - struct SNAME##_node *scan = _map_->root; \ + struct CMC_DEF_NODE(SNAME) *scan = _map_->root; \ \ while (scan != NULL) \ { \ @@ -1149,7 +1174,7 @@ static const char *cmc_string_fmt_treemap = "struct %s<%s, %s> " return NULL; \ } \ \ - static unsigned char PFX##_impl_h(struct SNAME##_node *node) \ + static unsigned char CMC_(PFX, _impl_h)(struct CMC_DEF_NODE(SNAME) * node) \ { \ if (node == NULL) \ return 0; \ @@ -1157,21 +1182,22 @@ static const char *cmc_string_fmt_treemap = "struct %s<%s, %s> " return node->height; \ } \ \ - static unsigned char PFX##_impl_hupdate(struct SNAME##_node *node) \ + static unsigned char CMC_(PFX, _impl_hupdate)(struct CMC_DEF_NODE(SNAME) * \ + node) \ { \ if (node == NULL) \ return 0; \ \ - unsigned char h_l = PFX##_impl_h(node->left); \ - unsigned char h_r = PFX##_impl_h(node->right); \ + unsigned char h_l = CMC_(PFX, _impl_h)(node->left); \ + unsigned char h_r = CMC_(PFX, _impl_h)(node->right); \ \ return 1 + (h_l > h_r ? h_l : h_r); \ } \ \ - static void PFX##_impl_rotate_right(struct SNAME##_node **Z) \ + static void CMC_(PFX, _impl_rotate_right)(struct CMC_DEF_NODE(SNAME) * *Z) \ { \ - struct SNAME##_node *root = *Z; \ - struct SNAME##_node *new_root = root->left; \ + struct CMC_DEF_NODE(SNAME) *root = *Z; \ + struct CMC_DEF_NODE(SNAME) *new_root = root->left; \ \ if (root->parent != NULL) \ { \ @@ -1191,16 +1217,16 @@ static const char *cmc_string_fmt_treemap = "struct %s<%s, %s> " \ new_root->right = root; \ \ - root->height = PFX##_impl_hupdate(root); \ - new_root->height = PFX##_impl_hupdate(new_root); \ + root->height = CMC_(PFX, _impl_hupdate)(root); \ + new_root->height = CMC_(PFX, _impl_hupdate)(new_root); \ \ *Z = new_root; \ } \ \ - static void PFX##_impl_rotate_left(struct SNAME##_node **Z) \ + static void CMC_(PFX, _impl_rotate_left)(struct CMC_DEF_NODE(SNAME) * *Z) \ { \ - struct SNAME##_node *root = *Z; \ - struct SNAME##_node *new_root = root->right; \ + struct CMC_DEF_NODE(SNAME) *root = *Z; \ + struct CMC_DEF_NODE(SNAME) *new_root = root->right; \ \ if (root->parent != NULL) \ { \ @@ -1220,16 +1246,16 @@ static const char *cmc_string_fmt_treemap = "struct %s<%s, %s> " \ new_root->left = root; \ \ - root->height = PFX##_impl_hupdate(root); \ - new_root->height = PFX##_impl_hupdate(new_root); \ + root->height = CMC_(PFX, _impl_hupdate)(root); \ + new_root->height = CMC_(PFX, _impl_hupdate)(new_root); \ \ *Z = new_root; \ } \ \ - static void PFX##_impl_rebalance(struct SNAME *_map_, \ - struct SNAME##_node *node) \ + static void CMC_(PFX, _impl_rebalance)(struct SNAME * _map_, \ + struct CMC_DEF_NODE(SNAME) * node) \ { \ - struct SNAME##_node *scan = node, *child = NULL; \ + struct CMC_DEF_NODE(SNAME) *scan = node, *child = NULL; \ \ int balance; \ bool is_root = false; \ @@ -1239,26 +1265,29 @@ static const char *cmc_string_fmt_treemap = "struct %s<%s, %s> " if (scan->parent == NULL) \ is_root = true; \ \ - scan->height = PFX##_impl_hupdate(scan); \ - balance = PFX##_impl_h(scan->right) - PFX##_impl_h(scan->left); \ + scan->height = CMC_(PFX, _impl_hupdate)(scan); \ + balance = CMC_(PFX, _impl_h)(scan->right) - \ + CMC_(PFX, _impl_h)(scan->left); \ \ if (balance >= 2) \ { \ child = scan->right; \ \ - if (PFX##_impl_h(child->right) < PFX##_impl_h(child->left)) \ - PFX##_impl_rotate_right(&(scan->right)); \ + if (CMC_(PFX, _impl_h)(child->right) < \ + CMC_(PFX, _impl_h)(child->left)) \ + CMC_(PFX, _impl_rotate_right)(&(scan->right)); \ \ - PFX##_impl_rotate_left(&scan); \ + CMC_(PFX, _impl_rotate_left)(&scan); \ } \ else if (balance <= -2) \ { \ child = scan->left; \ \ - if (PFX##_impl_h(child->left) < PFX##_impl_h(child->right)) \ - PFX##_impl_rotate_left(&(scan->left)); \ + if (CMC_(PFX, _impl_h)(child->left) < \ + CMC_(PFX, _impl_h)(child->right)) \ + CMC_(PFX, _impl_rotate_left)(&(scan->left)); \ \ - PFX##_impl_rotate_right(&scan); \ + CMC_(PFX, _impl_rotate_right)(&scan); \ } \ \ if (is_root) \ @@ -1271,4 +1300,4 @@ static const char *cmc_string_fmt_treemap = "struct %s<%s, %s> " } \ } -#endif /* CMC_TREEMAP_H */ +#endif /* CMC_CMC_TREEMAP_H */ diff --git a/src/cmc/treeset.h b/src/cmc/treeset.h index 2c2a103..eb853e3 100644 --- a/src/cmc/treeset.h +++ b/src/cmc/treeset.h @@ -16,8 +16,8 @@ * tree called AVL Tree that uses the height of nodes to keep its keys balanced. */ -#ifndef CMC_TREESET_H -#define CMC_TREESET_H +#ifndef CMC_CMC_TREESET_H +#define CMC_CMC_TREESET_H /* ------------------------------------------------------------------------- * Core functionalities of the C Macro Collections Library @@ -28,207 +28,224 @@ * TreeSet specific * ------------------------------------------------------------------------- */ /* to_string format */ -static const char *cmc_string_fmt_treeset = "struct %s<%s> " - "at %p { " - "root:%p, " - "count:%" PRIuMAX ", " - "flag:%d, " - "f_val:%p, " - "alloc:%p, " - "callbacks:%p }"; +static const char *cmc_cmc_string_fmt_treeset = "struct %s<%s> " + "at %p { " + "root:%p, " + "count:%" PRIuMAX ", " + "flag:%d, " + "f_val:%p, " + "alloc:%p, " + "callbacks:%p }"; -#define CMC_GENERATE_TREESET(PFX, SNAME, V) \ - CMC_GENERATE_TREESET_HEADER(PFX, SNAME, V) \ - CMC_GENERATE_TREESET_SOURCE(PFX, SNAME, V) +/** + * Core TreeSet implementation + */ +#define CMC_CMC_TREESET_CORE(BODY) \ + CMC_CMC_TREESET_CORE_HEADER(BODY) \ + CMC_CMC_TREESET_CORE_SOURCE(BODY) -#define CMC_WRAPGEN_TREESET_HEADER(PFX, SNAME, K, V) \ - CMC_GENERATE_TREESET_HEADER(PFX, SNAME, V) +#define CMC_CMC_TREESET_CORE_HEADER(BODY) \ + CMC_CMC_TREESET_CORE_HEADER_(CMC_PARAM_PFX(BODY), CMC_PARAM_SNAME(BODY), \ + CMC_PARAM_V(BODY)) -#define CMC_WRAPGEN_TREESET_SOURCE(PFX, SNAME, K, V) \ - CMC_GENERATE_TREESET_SOURCE(PFX, SNAME, V) +#define CMC_CMC_TREESET_CORE_SOURCE(BODY) \ + CMC_CMC_TREESET_CORE_SOURCE_(CMC_PARAM_PFX(BODY), CMC_PARAM_SNAME(BODY), \ + CMC_PARAM_V(BODY)) /* ------------------------------------------------------------------------- * Header * ------------------------------------------------------------------------- */ -#define CMC_GENERATE_TREESET_HEADER(PFX, SNAME, V) \ - \ - /* Treeset Structure */ \ - struct SNAME \ - { \ - /* Root node */ \ - struct SNAME##_node *root; \ - \ - /* Current amount of elements */ \ - size_t count; \ - \ - /* Flags indicating errors or success */ \ - int flag; \ - \ - /* Value function table */ \ - struct SNAME##_fval *f_val; \ - \ - /* Custom allocation functions */ \ - struct cmc_alloc_node *alloc; \ - \ - /* Custom callback functions */ \ - struct cmc_callbacks *callbacks; \ - }; \ - \ - /* Treeset Node */ \ - struct SNAME##_node \ - { \ - /* Node element */ \ - V value; \ - \ - /* Node height used by the AVL tree to keep it strictly balanced */ \ - unsigned char height; \ - \ - /* Right child node or subtree */ \ - struct SNAME##_node *right; \ - \ - /* Left child node or subtree */ \ - struct SNAME##_node *left; \ - \ - /* Parent node */ \ - struct SNAME##_node *parent; \ - }; \ - \ - /* Value struct function table */ \ - struct SNAME##_fval \ - { \ - /* Comparator function */ \ - int (*cmp)(V, V); \ - \ - /* Copy function */ \ - V (*cpy)(V); \ - \ - /* To string function */ \ - bool (*str)(FILE *, V); \ - \ - /* Free from memory function */ \ - void (*free)(V); \ - \ - /* Hash function */ \ - size_t (*hash)(V); \ - \ - /* Priority function */ \ - int (*pri)(V, V); \ - }; \ - \ - /* Treeset Iterator */ \ - struct SNAME##_iter \ - { \ - /* Target treeset */ \ - struct SNAME *target; \ - \ - /* Cursor's current node */ \ - struct SNAME##_node *cursor; \ - \ - /* The first node in the iteration */ \ - struct SNAME##_node *first; \ - \ - /* The last node in the iteration */ \ - struct SNAME##_node *last; \ - \ - /* Keeps track of relative index to the iteration of elements */ \ - size_t index; \ - \ - /* If the iterator has reached the start of the iteration */ \ - bool start; \ - \ - /* If the iterator has reached the end of the iteration */ \ - bool end; \ - }; \ - \ - /* Collection Functions */ \ - /* Collection Allocation and Deallocation */ \ - struct SNAME *PFX##_new(struct SNAME##_fval *f_val); \ - struct SNAME *PFX##_new_custom(struct SNAME##_fval *f_val, \ - struct cmc_alloc_node *alloc, \ - struct cmc_callbacks *callbacks); \ - void PFX##_clear(struct SNAME *_set_); \ - void PFX##_free(struct SNAME *_set_); \ - /* Customization of Allocation and Callbacks */ \ - void PFX##_customize(struct SNAME *_set_, struct cmc_alloc_node *alloc, \ - struct cmc_callbacks *callbacks); \ - /* Collection Input and Output */ \ - bool PFX##_insert(struct SNAME *_set_, V value); \ - bool PFX##_remove(struct SNAME *_set_, V value); \ - /* Element Access */ \ - bool PFX##_max(struct SNAME *_set_, V *value); \ - bool PFX##_min(struct SNAME *_set_, V *value); \ - /* Collection State */ \ - bool PFX##_contains(struct SNAME *_set_, V value); \ - bool PFX##_empty(struct SNAME *_set_); \ - size_t PFX##_count(struct SNAME *_set_); \ - int PFX##_flag(struct SNAME *_set_); \ - /* Collection Utility */ \ - struct SNAME *PFX##_copy_of(struct SNAME *_set_); \ - bool PFX##_equals(struct SNAME *_set1_, struct SNAME *_set2_); \ - struct cmc_string PFX##_to_string(struct SNAME *_set_); \ - bool PFX##_print(struct SNAME *_set_, FILE *fptr); \ - \ - /* Set Operations */ \ - struct SNAME *PFX##_union(struct SNAME *_set1_, struct SNAME *_set2_); \ - struct SNAME *PFX##_intersection(struct SNAME *_set1_, \ - struct SNAME *_set2_); \ - struct SNAME *PFX##_difference(struct SNAME *_set1_, \ - struct SNAME *_set2_); \ - struct SNAME *PFX##_symmetric_difference(struct SNAME *_set1_, \ - struct SNAME *_set2_); \ - bool PFX##_is_subset(struct SNAME *_set1_, struct SNAME *_set2_); \ - bool PFX##_is_superset(struct SNAME *_set1_, struct SNAME *_set2_); \ - bool PFX##_is_proper_subset(struct SNAME *_set1_, struct SNAME *_set2_); \ - bool PFX##_is_proper_superset(struct SNAME *_set1_, struct SNAME *_set2_); \ - bool PFX##_is_disjointset(struct SNAME *_set1_, struct SNAME *_set2_); \ - \ - /* Iterator Functions */ \ - /* Iterator Initialization */ \ - struct SNAME##_iter PFX##_iter_start(struct SNAME *target); \ - struct SNAME##_iter PFX##_iter_end(struct SNAME *target); \ - /* Iterator State */ \ - bool PFX##_iter_at_start(struct SNAME##_iter *iter); \ - bool PFX##_iter_at_end(struct SNAME##_iter *iter); \ - /* Iterator Movement */ \ - bool PFX##_iter_to_start(struct SNAME##_iter *iter); \ - bool PFX##_iter_to_end(struct SNAME##_iter *iter); \ - bool PFX##_iter_next(struct SNAME##_iter *iter); \ - bool PFX##_iter_prev(struct SNAME##_iter *iter); \ - bool PFX##_iter_advance(struct SNAME##_iter *iter, size_t steps); \ - bool PFX##_iter_rewind(struct SNAME##_iter *iter, size_t steps); \ - bool PFX##_iter_go_to(struct SNAME##_iter *iter, size_t index); \ - /* Iterator Access */ \ - V PFX##_iter_value(struct SNAME##_iter *iter); \ - size_t PFX##_iter_index(struct SNAME##_iter *iter); \ - \ - /* Default Value */ \ - static inline V PFX##_impl_default_value(void) \ - { \ - V _empty_value_; \ - \ - memset(&_empty_value_, 0, sizeof(V)); \ - \ - return _empty_value_; \ +#define CMC_CMC_TREESET_CORE_HEADER_(PFX, SNAME, V) \ + \ + /* Treeset Structure */ \ + struct SNAME \ + { \ + /* Root node */ \ + struct CMC_DEF_NODE(SNAME) * root; \ + \ + /* Current amount of elements */ \ + size_t count; \ + \ + /* Flags indicating errors or success */ \ + int flag; \ + \ + /* Value function table */ \ + struct CMC_DEF_FVAL(SNAME) * f_val; \ + \ + /* Custom allocation functions */ \ + struct cmc_alloc_node *alloc; \ + \ + /* Custom callback functions */ \ + struct cmc_callbacks *callbacks; \ + }; \ + \ + /* Treeset Node */ \ + struct CMC_DEF_NODE(SNAME) \ + { \ + /* Node element */ \ + V value; \ + \ + /* Node height used by the AVL tree to keep it strictly balanced */ \ + unsigned char height; \ + \ + /* Right child node or subtree */ \ + struct CMC_DEF_NODE(SNAME) * right; \ + \ + /* Left child node or subtree */ \ + struct CMC_DEF_NODE(SNAME) * left; \ + \ + /* Parent node */ \ + struct CMC_DEF_NODE(SNAME) * parent; \ + }; \ + \ + /* Value struct function table */ \ + struct CMC_DEF_FVAL(SNAME) \ + { \ + /* Comparator function */ \ + int (*cmp)(V, V); \ + \ + /* Copy function */ \ + V (*cpy)(V); \ + \ + /* To string function */ \ + bool (*str)(FILE *, V); \ + \ + /* Free from memory function */ \ + void (*free)(V); \ + \ + /* Hash function */ \ + size_t (*hash)(V); \ + \ + /* Priority function */ \ + int (*pri)(V, V); \ + }; \ + \ + /* Treeset Iterator */ \ + struct CMC_DEF_ITER(SNAME) \ + { \ + /* Target treeset */ \ + struct SNAME *target; \ + \ + /* Cursor's current node */ \ + struct CMC_DEF_NODE(SNAME) * cursor; \ + \ + /* The first node in the iteration */ \ + struct CMC_DEF_NODE(SNAME) * first; \ + \ + /* The last node in the iteration */ \ + struct CMC_DEF_NODE(SNAME) * last; \ + \ + /* Keeps track of relative index to the iteration of elements */ \ + size_t index; \ + \ + /* If the iterator has reached the start of the iteration */ \ + bool start; \ + \ + /* If the iterator has reached the end of the iteration */ \ + bool end; \ + }; \ + \ + /* Collection Functions */ \ + /* Collection Allocation and Deallocation */ \ + struct SNAME *CMC_(PFX, _new)(struct CMC_DEF_FVAL(SNAME) * f_val); \ + struct SNAME *CMC_(PFX, _new_custom)(struct CMC_DEF_FVAL(SNAME) * f_val, \ + struct cmc_alloc_node * alloc, \ + struct cmc_callbacks * callbacks); \ + void CMC_(PFX, _clear)(struct SNAME * _set_); \ + void CMC_(PFX, _free)(struct SNAME * _set_); \ + /* Customization of Allocation and Callbacks */ \ + void CMC_(PFX, _customize)(struct SNAME * _set_, \ + struct cmc_alloc_node * alloc, \ + struct cmc_callbacks * callbacks); \ + /* Collection Input and Output */ \ + bool CMC_(PFX, _insert)(struct SNAME * _set_, V value); \ + bool CMC_(PFX, _remove)(struct SNAME * _set_, V value); \ + /* Element Access */ \ + bool CMC_(PFX, _max)(struct SNAME * _set_, V * value); \ + bool CMC_(PFX, _min)(struct SNAME * _set_, V * value); \ + /* Collection State */ \ + bool CMC_(PFX, _contains)(struct SNAME * _set_, V value); \ + bool CMC_(PFX, _empty)(struct SNAME * _set_); \ + size_t CMC_(PFX, _count)(struct SNAME * _set_); \ + int CMC_(PFX, _flag)(struct SNAME * _set_); \ + /* Collection Utility */ \ + struct SNAME *CMC_(PFX, _copy_of)(struct SNAME * _set_); \ + bool CMC_(PFX, _equals)(struct SNAME * _set1_, struct SNAME * _set2_); \ + struct cmc_string CMC_(PFX, _to_string)(struct SNAME * _set_); \ + bool CMC_(PFX, _print)(struct SNAME * _set_, FILE * fptr); \ + \ + /* Set Operations */ \ + struct SNAME *CMC_(PFX, _union)(struct SNAME * _set1_, \ + struct SNAME * _set2_); \ + struct SNAME *CMC_(PFX, _intersection)(struct SNAME * _set1_, \ + struct SNAME * _set2_); \ + struct SNAME *CMC_(PFX, _difference)(struct SNAME * _set1_, \ + struct SNAME * _set2_); \ + struct SNAME *CMC_(PFX, _symmetric_difference)(struct SNAME * _set1_, \ + struct SNAME * _set2_); \ + bool CMC_(PFX, _is_subset)(struct SNAME * _set1_, struct SNAME * _set2_); \ + bool CMC_(PFX, _is_superset)(struct SNAME * _set1_, \ + struct SNAME * _set2_); \ + bool CMC_(PFX, _is_proper_subset)(struct SNAME * _set1_, \ + struct SNAME * _set2_); \ + bool CMC_(PFX, _is_proper_superset)(struct SNAME * _set1_, \ + struct SNAME * _set2_); \ + bool CMC_(PFX, _is_disjointset)(struct SNAME * _set1_, \ + struct SNAME * _set2_); \ + \ + /* Iterator Functions */ \ + /* Iterator Initialization */ \ + struct CMC_DEF_ITER(SNAME) CMC_(PFX, _iter_start)(struct SNAME * target); \ + struct CMC_DEF_ITER(SNAME) CMC_(PFX, _iter_end)(struct SNAME * target); \ + /* Iterator State */ \ + bool CMC_(PFX, _iter_at_start)(struct CMC_DEF_ITER(SNAME) * iter); \ + bool CMC_(PFX, _iter_at_end)(struct CMC_DEF_ITER(SNAME) * iter); \ + /* Iterator Movement */ \ + bool CMC_(PFX, _iter_to_start)(struct CMC_DEF_ITER(SNAME) * iter); \ + bool CMC_(PFX, _iter_to_end)(struct CMC_DEF_ITER(SNAME) * iter); \ + bool CMC_(PFX, _iter_next)(struct CMC_DEF_ITER(SNAME) * iter); \ + bool CMC_(PFX, _iter_prev)(struct CMC_DEF_ITER(SNAME) * iter); \ + bool CMC_(PFX, _iter_advance)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t steps); \ + bool CMC_(PFX, _iter_rewind)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t steps); \ + bool CMC_(PFX, _iter_go_to)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t index); \ + /* Iterator Access */ \ + V CMC_(PFX, _iter_value)(struct CMC_DEF_ITER(SNAME) * iter); \ + size_t CMC_(PFX, _iter_index)(struct CMC_DEF_ITER(SNAME) * iter); \ + \ + /* Default Value */ \ + static inline V CMC_(PFX, _impl_default_value)(void) \ + { \ + V _empty_value_; \ + \ + memset(&_empty_value_, 0, sizeof(V)); \ + \ + return _empty_value_; \ } /* ------------------------------------------------------------------------- * Source * ------------------------------------------------------------------------- */ -#define CMC_GENERATE_TREESET_SOURCE(PFX, SNAME, V) \ +#define CMC_CMC_TREESET_CORE_SOURCE_(PFX, SNAME, V) \ \ /* Implementation Detail Functions */ \ - static struct SNAME##_node *PFX##_impl_new_node(struct SNAME *_set_, \ - V value); \ - static struct SNAME##_node *PFX##_impl_get_node(struct SNAME *_set_, \ - V value); \ - static unsigned char PFX##_impl_h(struct SNAME##_node *node); \ - static unsigned char PFX##_impl_hupdate(struct SNAME##_node *node); \ - static void PFX##_impl_rotate_right(struct SNAME##_node **Z); \ - static void PFX##_impl_rotate_left(struct SNAME##_node **Z); \ - static void PFX##_impl_rebalance(struct SNAME *_set_, \ - struct SNAME##_node *node); \ + static struct CMC_DEF_NODE(SNAME) * \ + CMC_(PFX, _impl_new_node)(struct SNAME * _set_, V value); \ + static struct CMC_DEF_NODE(SNAME) * \ + CMC_(PFX, _impl_get_node)(struct SNAME * _set_, V value); \ + static unsigned char CMC_(PFX, \ + _impl_h)(struct CMC_DEF_NODE(SNAME) * node); \ + static unsigned char CMC_(PFX, _impl_hupdate)(struct CMC_DEF_NODE(SNAME) * \ + node); \ + static void CMC_(PFX, \ + _impl_rotate_right)(struct CMC_DEF_NODE(SNAME) * *Z); \ + static void CMC_(PFX, _impl_rotate_left)(struct CMC_DEF_NODE(SNAME) * *Z); \ + static void CMC_(PFX, _impl_rebalance)(struct SNAME * _set_, \ + struct CMC_DEF_NODE(SNAME) * node); \ \ - struct SNAME *PFX##_new(struct SNAME##_fval *f_val) \ + struct SNAME *CMC_(PFX, _new)(struct CMC_DEF_FVAL(SNAME) * f_val) \ { \ if (!f_val) \ return NULL; \ @@ -242,7 +259,7 @@ static const char *cmc_string_fmt_treeset = "struct %s<%s> " \ _set_->count = 0; \ _set_->root = NULL; \ - _set_->flag = cmc_flags.OK; \ + _set_->flag = CMC_FLAG_OK; \ _set_->f_val = f_val; \ _set_->alloc = alloc; \ _set_->callbacks = NULL; \ @@ -250,9 +267,9 @@ static const char *cmc_string_fmt_treeset = "struct %s<%s> " return _set_; \ } \ \ - struct SNAME *PFX##_new_custom(struct SNAME##_fval *f_val, \ - struct cmc_alloc_node *alloc, \ - struct cmc_callbacks *callbacks) \ + struct SNAME *CMC_(PFX, _new_custom)(struct CMC_DEF_FVAL(SNAME) * f_val, \ + struct cmc_alloc_node * alloc, \ + struct cmc_callbacks * callbacks) \ { \ if (!f_val) \ return NULL; \ @@ -267,7 +284,7 @@ static const char *cmc_string_fmt_treeset = "struct %s<%s> " \ _set_->count = 0; \ _set_->root = NULL; \ - _set_->flag = cmc_flags.OK; \ + _set_->flag = CMC_FLAG_OK; \ _set_->f_val = f_val; \ _set_->alloc = alloc; \ _set_->callbacks = callbacks; \ @@ -275,16 +292,16 @@ static const char *cmc_string_fmt_treeset = "struct %s<%s> " return _set_; \ } \ \ - void PFX##_clear(struct SNAME *_set_) \ + void CMC_(PFX, _clear)(struct SNAME * _set_) \ { \ - struct SNAME##_node *scan = _set_->root; \ - struct SNAME##_node *up = NULL; \ + struct CMC_DEF_NODE(SNAME) *scan = _set_->root; \ + struct CMC_DEF_NODE(SNAME) *up = NULL; \ \ while (scan != NULL) \ { \ if (scan->left != NULL) \ { \ - struct SNAME##_node *left = scan->left; \ + struct CMC_DEF_NODE(SNAME) *left = scan->left; \ \ scan->left = up; \ up = scan; \ @@ -292,7 +309,7 @@ static const char *cmc_string_fmt_treeset = "struct %s<%s> " } \ else if (scan->right != NULL) \ { \ - struct SNAME##_node *right = scan->right; \ + struct CMC_DEF_NODE(SNAME) *right = scan->right; \ \ scan->left = up; \ scan->right = NULL; \ @@ -334,18 +351,19 @@ static const char *cmc_string_fmt_treeset = "struct %s<%s> " \ _set_->count = 0; \ _set_->root = NULL; \ - _set_->flag = cmc_flags.OK; \ + _set_->flag = CMC_FLAG_OK; \ } \ \ - void PFX##_free(struct SNAME *_set_) \ + void CMC_(PFX, _free)(struct SNAME * _set_) \ { \ - PFX##_clear(_set_); \ + CMC_(PFX, _clear)(_set_); \ \ _set_->alloc->free(_set_); \ } \ \ - void PFX##_customize(struct SNAME *_set_, struct cmc_alloc_node *alloc, \ - struct cmc_callbacks *callbacks) \ + void CMC_(PFX, _customize)(struct SNAME * _set_, \ + struct cmc_alloc_node * alloc, \ + struct cmc_callbacks * callbacks) \ { \ if (!alloc) \ _set_->alloc = &cmc_alloc_node_default; \ @@ -354,25 +372,25 @@ static const char *cmc_string_fmt_treeset = "struct %s<%s> " \ _set_->callbacks = callbacks; \ \ - _set_->flag = cmc_flags.OK; \ + _set_->flag = CMC_FLAG_OK; \ } \ \ - bool PFX##_insert(struct SNAME *_set_, V value) \ + bool CMC_(PFX, _insert)(struct SNAME * _set_, V value) \ { \ - if (PFX##_empty(_set_)) \ + if (CMC_(PFX, _empty)(_set_)) \ { \ - _set_->root = PFX##_impl_new_node(_set_, value); \ + _set_->root = CMC_(PFX, _impl_new_node)(_set_, value); \ \ if (!_set_->root) \ { \ - _set_->flag = cmc_flags.ALLOC; \ + _set_->flag = CMC_FLAG_ALLOC; \ return false; \ } \ } \ else \ { \ - struct SNAME##_node *scan = _set_->root; \ - struct SNAME##_node *parent = scan; \ + struct CMC_DEF_NODE(SNAME) *scan = _set_->root; \ + struct CMC_DEF_NODE(SNAME) *parent = scan; \ \ while (scan != NULL) \ { \ @@ -384,20 +402,20 @@ static const char *cmc_string_fmt_treeset = "struct %s<%s> " scan = scan->right; \ else \ { \ - _set_->flag = cmc_flags.DUPLICATE; \ + _set_->flag = CMC_FLAG_DUPLICATE; \ return false; \ } \ } \ \ - struct SNAME##_node *node; \ + struct CMC_DEF_NODE(SNAME) * node; \ \ if (_set_->f_val->cmp(parent->value, value) > 0) \ { \ - parent->left = PFX##_impl_new_node(_set_, value); \ + parent->left = CMC_(PFX, _impl_new_node)(_set_, value); \ \ if (!parent->left) \ { \ - _set_->flag = cmc_flags.ALLOC; \ + _set_->flag = CMC_FLAG_ALLOC; \ return false; \ } \ \ @@ -406,11 +424,11 @@ static const char *cmc_string_fmt_treeset = "struct %s<%s> " } \ else \ { \ - parent->right = PFX##_impl_new_node(_set_, value); \ + parent->right = CMC_(PFX, _impl_new_node)(_set_, value); \ \ if (!parent->right) \ { \ - _set_->flag = cmc_flags.ALLOC; \ + _set_->flag = CMC_FLAG_ALLOC; \ return false; \ } \ \ @@ -418,11 +436,11 @@ static const char *cmc_string_fmt_treeset = "struct %s<%s> " node = parent->right; \ } \ \ - PFX##_impl_rebalance(_set_, node); \ + CMC_(PFX, _impl_rebalance)(_set_, node); \ } \ \ _set_->count++; \ - _set_->flag = cmc_flags.OK; \ + _set_->flag = CMC_FLAG_OK; \ \ if (_set_->callbacks && _set_->callbacks->create) \ _set_->callbacks->create(); \ @@ -430,23 +448,24 @@ static const char *cmc_string_fmt_treeset = "struct %s<%s> " return true; \ } \ \ - bool PFX##_remove(struct SNAME *_set_, V value) \ + bool CMC_(PFX, _remove)(struct SNAME * _set_, V value) \ { \ - if (PFX##_empty(_set_)) \ + if (CMC_(PFX, _empty)(_set_)) \ { \ - _set_->flag = cmc_flags.EMPTY; \ + _set_->flag = CMC_FLAG_EMPTY; \ return false; \ } \ \ - struct SNAME##_node *node = PFX##_impl_get_node(_set_, value); \ + struct CMC_DEF_NODE(SNAME) *node = \ + CMC_(PFX, _impl_get_node)(_set_, value); \ \ if (!node) \ { \ - _set_->flag = cmc_flags.NOT_FOUND; \ + _set_->flag = CMC_FLAG_NOT_FOUND; \ return false; \ } \ \ - struct SNAME##_node *temp = NULL, *unbalanced = NULL; \ + struct CMC_DEF_NODE(SNAME) *temp = NULL, *unbalanced = NULL; \ \ bool is_root = node->parent == NULL; \ \ @@ -550,13 +569,13 @@ static const char *cmc_string_fmt_treeset = "struct %s<%s> " } \ \ if (unbalanced != NULL) \ - PFX##_impl_rebalance(_set_, unbalanced); \ + CMC_(PFX, _impl_rebalance)(_set_, unbalanced); \ \ if (_set_->count == 0) \ _set_->root = NULL; \ \ _set_->count--; \ - _set_->flag = cmc_flags.OK; \ + _set_->flag = CMC_FLAG_OK; \ \ if (_set_->callbacks && _set_->callbacks->delete) \ _set_->callbacks->delete (); \ @@ -564,15 +583,15 @@ static const char *cmc_string_fmt_treeset = "struct %s<%s> " return true; \ } \ \ - bool PFX##_max(struct SNAME *_set_, V *value) \ + bool CMC_(PFX, _max)(struct SNAME * _set_, V * value) \ { \ - if (PFX##_empty(_set_)) \ + if (CMC_(PFX, _empty)(_set_)) \ { \ - _set_->flag = cmc_flags.EMPTY; \ + _set_->flag = CMC_FLAG_EMPTY; \ return false; \ } \ \ - struct SNAME##_node *scan = _set_->root; \ + struct CMC_DEF_NODE(SNAME) *scan = _set_->root; \ \ while (scan->right != NULL) \ scan = scan->right; \ @@ -580,7 +599,7 @@ static const char *cmc_string_fmt_treeset = "struct %s<%s> " if (value) \ *value = scan->value; \ \ - _set_->flag = cmc_flags.OK; \ + _set_->flag = CMC_FLAG_OK; \ \ if (_set_->callbacks && _set_->callbacks->read) \ _set_->callbacks->read(); \ @@ -588,15 +607,15 @@ static const char *cmc_string_fmt_treeset = "struct %s<%s> " return true; \ } \ \ - bool PFX##_min(struct SNAME *_set_, V *value) \ + bool CMC_(PFX, _min)(struct SNAME * _set_, V * value) \ { \ - if (PFX##_empty(_set_)) \ + if (CMC_(PFX, _empty)(_set_)) \ { \ - _set_->flag = cmc_flags.EMPTY; \ + _set_->flag = CMC_FLAG_EMPTY; \ return false; \ } \ \ - struct SNAME##_node *scan = _set_->root; \ + struct CMC_DEF_NODE(SNAME) *scan = _set_->root; \ \ while (scan->left != NULL) \ scan = scan->left; \ @@ -604,7 +623,7 @@ static const char *cmc_string_fmt_treeset = "struct %s<%s> " if (value) \ *value = scan->value; \ \ - _set_->flag = cmc_flags.OK; \ + _set_->flag = CMC_FLAG_OK; \ \ if (_set_->callbacks && _set_->callbacks->read) \ _set_->callbacks->read(); \ @@ -612,9 +631,9 @@ static const char *cmc_string_fmt_treeset = "struct %s<%s> " return true; \ } \ \ - bool PFX##_contains(struct SNAME *_set_, V value) \ + bool CMC_(PFX, _contains)(struct SNAME * _set_, V value) \ { \ - bool result = PFX##_impl_get_node(_set_, value) != NULL; \ + bool result = CMC_(PFX, _impl_get_node)(_set_, value) != NULL; \ \ if (_set_->callbacks && _set_->callbacks->read) \ _set_->callbacks->read(); \ @@ -622,85 +641,88 @@ static const char *cmc_string_fmt_treeset = "struct %s<%s> " return result; \ } \ \ - bool PFX##_empty(struct SNAME *_set_) \ + bool CMC_(PFX, _empty)(struct SNAME * _set_) \ { \ return _set_->count == 0; \ } \ \ - size_t PFX##_count(struct SNAME *_set_) \ + size_t CMC_(PFX, _count)(struct SNAME * _set_) \ { \ return _set_->count; \ } \ \ - int PFX##_flag(struct SNAME *_set_) \ + int CMC_(PFX, _flag)(struct SNAME * _set_) \ { \ return _set_->flag; \ } \ \ - struct SNAME *PFX##_copy_of(struct SNAME *_set_) \ + struct SNAME *CMC_(PFX, _copy_of)(struct SNAME * _set_) \ { \ - struct SNAME *result = \ - PFX##_new_custom(_set_->f_val, _set_->alloc, _set_->callbacks); \ + struct SNAME *result = CMC_(PFX, _new_custom)( \ + _set_->f_val, _set_->alloc, _set_->callbacks); \ \ if (!result) \ { \ - _set_->flag = cmc_flags.ERROR; \ + _set_->flag = CMC_FLAG_ERROR; \ return NULL; \ } \ \ - if (!PFX##_empty(_set_)) \ + if (!CMC_(PFX, _empty)(_set_)) \ { \ - struct SNAME##_iter iter = PFX##_iter_start(_set_); \ + struct CMC_DEF_ITER(SNAME) iter = CMC_(PFX, _iter_start)(_set_); \ \ - for (; !PFX##_iter_at_end(&iter); PFX##_iter_next(&iter)) \ + for (; !CMC_(PFX, _iter_at_end)(&iter); \ + CMC_(PFX, _iter_next)(&iter)) \ { \ if (_set_->f_val->cpy) \ - PFX##_insert(result, \ - _set_->f_val->cpy(PFX##_iter_value(&iter))); \ + CMC_(PFX, _insert) \ + (result, \ + _set_->f_val->cpy(CMC_(PFX, _iter_value)(&iter))); \ else \ - PFX##_insert(result, PFX##_iter_value(&iter)); \ + CMC_(PFX, _insert)(result, CMC_(PFX, _iter_value)(&iter)); \ } \ } \ \ - _set_->flag = cmc_flags.OK; \ + _set_->flag = CMC_FLAG_OK; \ \ return result; \ } \ \ - bool PFX##_equals(struct SNAME *_set1_, struct SNAME *_set2_) \ + bool CMC_(PFX, _equals)(struct SNAME * _set1_, struct SNAME * _set2_) \ { \ - _set1_->flag = cmc_flags.OK; \ - _set2_->flag = cmc_flags.OK; \ + _set1_->flag = CMC_FLAG_OK; \ + _set2_->flag = CMC_FLAG_OK; \ \ if (_set1_->count != _set2_->count) \ return false; \ \ - struct SNAME##_iter iter = PFX##_iter_start(_set1_); \ + struct CMC_DEF_ITER(SNAME) iter = CMC_(PFX, _iter_start)(_set1_); \ \ - for (; !PFX##_iter_at_end(&iter); PFX##_iter_next(&iter)) \ + for (; !CMC_(PFX, _iter_at_end)(&iter); CMC_(PFX, _iter_next)(&iter)) \ { \ - if (PFX##_impl_get_node(_set2_, PFX##_iter_value(&iter)) == NULL) \ + if (CMC_(PFX, _impl_get_node)( \ + _set2_, CMC_(PFX, _iter_value)(&iter)) == NULL) \ return false; \ } \ \ return true; \ } \ \ - struct cmc_string PFX##_to_string(struct SNAME *_set_) \ + struct cmc_string CMC_(PFX, _to_string)(struct SNAME * _set_) \ { \ struct cmc_string str; \ struct SNAME *s_ = _set_; \ \ - int n = snprintf(str.s, cmc_string_len, cmc_string_fmt_treeset, \ + int n = snprintf(str.s, cmc_string_len, cmc_cmc_string_fmt_treeset, \ #SNAME, #V, s_, s_->root, s_->count, s_->flag, \ s_->f_val, s_->alloc, s_->callbacks); \ \ return n >= 0 ? str : (struct cmc_string){ 0 }; \ } \ \ - bool PFX##_print(struct SNAME *_set_, FILE *fptr) \ + bool CMC_(PFX, _print)(struct SNAME * _set_, FILE * fptr) \ { \ - struct SNAME##_node *root = _set_->root; \ + struct CMC_DEF_NODE(SNAME) *root = _set_->root; \ \ bool left_done = false; \ \ @@ -739,35 +761,38 @@ static const char *cmc_string_fmt_treeset = "struct %s<%s> " return true; \ } \ \ - struct SNAME *PFX##_union(struct SNAME *_set1_, struct SNAME *_set2_) \ + struct SNAME *CMC_(PFX, _union)(struct SNAME * _set1_, \ + struct SNAME * _set2_) \ { \ - struct SNAME *_set_r_ = \ - PFX##_new_custom(_set1_->f_val, _set1_->alloc, _set1_->callbacks); \ + struct SNAME *_set_r_ = CMC_(PFX, _new_custom)( \ + _set1_->f_val, _set1_->alloc, _set1_->callbacks); \ \ if (!_set_r_) \ return NULL; \ \ - struct SNAME##_iter iter1 = PFX##_iter_start(_set1_); \ - struct SNAME##_iter iter2 = PFX##_iter_start(_set2_); \ + struct CMC_DEF_ITER(SNAME) iter1 = CMC_(PFX, _iter_start)(_set1_); \ + struct CMC_DEF_ITER(SNAME) iter2 = CMC_(PFX, _iter_start)(_set2_); \ \ - for (; !PFX##_iter_at_end(&iter1); PFX##_iter_next(&iter1)) \ + for (; !CMC_(PFX, _iter_at_end)(&iter1); \ + CMC_(PFX, _iter_next)(&iter1)) \ { \ - PFX##_insert(_set_r_, PFX##_iter_value(&iter1)); \ + CMC_(PFX, _insert)(_set_r_, CMC_(PFX, _iter_value)(&iter1)); \ } \ \ - for (; !PFX##_iter_at_end(&iter2); PFX##_iter_next(&iter2)) \ + for (; !CMC_(PFX, _iter_at_end)(&iter2); \ + CMC_(PFX, _iter_next)(&iter2)) \ { \ - PFX##_insert(_set_r_, PFX##_iter_value(&iter2)); \ + CMC_(PFX, _insert)(_set_r_, CMC_(PFX, _iter_value)(&iter2)); \ } \ \ return _set_r_; \ } \ \ - struct SNAME *PFX##_intersection(struct SNAME *_set1_, \ - struct SNAME *_set2_) \ + struct SNAME *CMC_(PFX, _intersection)(struct SNAME * _set1_, \ + struct SNAME * _set2_) \ { \ - struct SNAME *_set_r_ = \ - PFX##_new_custom(_set1_->f_val, _set1_->alloc, _set1_->callbacks); \ + struct SNAME *_set_r_ = CMC_(PFX, _new_custom)( \ + _set1_->f_val, _set1_->alloc, _set1_->callbacks); \ \ if (!_set_r_) \ return NULL; \ @@ -777,66 +802,69 @@ static const char *cmc_string_fmt_treeset = "struct %s<%s> " _set1_->count < _set2_->count ? _set1_ : _set2_; \ struct SNAME *_set_B_ = _set_A_ == _set1_ ? _set2_ : _set1_; \ \ - struct SNAME##_iter iter = PFX##_iter_start(_set_A_); \ + struct CMC_DEF_ITER(SNAME) iter = CMC_(PFX, _iter_start)(_set_A_); \ \ - for (; !PFX##_iter_at_end(&iter); PFX##_iter_next(&iter)) \ + for (; !CMC_(PFX, _iter_at_end)(&iter); CMC_(PFX, _iter_next)(&iter)) \ { \ - V value = PFX##_iter_value(&iter); \ + V value = CMC_(PFX, _iter_value)(&iter); \ \ - if (PFX##_impl_get_node(_set_B_, value) != NULL) \ - PFX##_insert(_set_r_, value); \ + if (CMC_(PFX, _impl_get_node)(_set_B_, value) != NULL) \ + CMC_(PFX, _insert)(_set_r_, value); \ } \ \ return _set_r_; \ } \ \ - struct SNAME *PFX##_difference(struct SNAME *_set1_, struct SNAME *_set2_) \ + struct SNAME *CMC_(PFX, _difference)(struct SNAME * _set1_, \ + struct SNAME * _set2_) \ { \ - struct SNAME *_set_r_ = \ - PFX##_new_custom(_set1_->f_val, _set1_->alloc, _set1_->callbacks); \ + struct SNAME *_set_r_ = CMC_(PFX, _new_custom)( \ + _set1_->f_val, _set1_->alloc, _set1_->callbacks); \ \ if (!_set_r_) \ return NULL; \ \ - struct SNAME##_iter iter = PFX##_iter_start(_set1_); \ + struct CMC_DEF_ITER(SNAME) iter = CMC_(PFX, _iter_start)(_set1_); \ \ - for (; !PFX##_iter_at_end(&iter); PFX##_iter_next(&iter)) \ + for (; !CMC_(PFX, _iter_at_end)(&iter); CMC_(PFX, _iter_next)(&iter)) \ { \ - V value = PFX##_iter_value(&iter); \ + V value = CMC_(PFX, _iter_value)(&iter); \ \ - if (PFX##_impl_get_node(_set2_, value) == NULL) \ - PFX##_insert(_set_r_, value); \ + if (CMC_(PFX, _impl_get_node)(_set2_, value) == NULL) \ + CMC_(PFX, _insert)(_set_r_, value); \ } \ \ return _set_r_; \ } \ \ - struct SNAME *PFX##_symmetric_difference(struct SNAME *_set1_, \ - struct SNAME *_set2_) \ + struct SNAME *CMC_(PFX, _symmetric_difference)(struct SNAME * _set1_, \ + struct SNAME * _set2_) \ { \ - struct SNAME *_set_r_ = \ - PFX##_new_custom(_set1_->f_val, _set1_->alloc, _set1_->callbacks); \ + struct SNAME *_set_r_ = CMC_(PFX, _new_custom)( \ + _set1_->f_val, _set1_->alloc, _set1_->callbacks); \ \ if (!_set_r_) \ return NULL; \ \ - struct SNAME##_iter iter1 = PFX##_iter_start(_set1_); \ - struct SNAME##_iter iter2 = PFX##_iter_start(_set2_); \ + struct CMC_DEF_ITER(SNAME) iter1 = CMC_(PFX, _iter_start)(_set1_); \ + struct CMC_DEF_ITER(SNAME) iter2 = CMC_(PFX, _iter_start)(_set2_); \ \ - for (; !PFX##_iter_at_end(&iter1); PFX##_iter_next(&iter1)) \ + for (; !CMC_(PFX, _iter_at_end)(&iter1); \ + CMC_(PFX, _iter_next)(&iter1)) \ { \ - V value = PFX##_iter_value(&iter1); \ + V value = CMC_(PFX, _iter_value)(&iter1); \ \ - if (PFX##_impl_get_node(_set2_, value) == NULL) \ - PFX##_insert(_set_r_, value); \ + if (CMC_(PFX, _impl_get_node)(_set2_, value) == NULL) \ + CMC_(PFX, _insert)(_set_r_, value); \ } \ \ - for (; !PFX##_iter_at_end(&iter2); PFX##_iter_next(&iter2)) \ + for (; !CMC_(PFX, _iter_at_end)(&iter2); \ + CMC_(PFX, _iter_next)(&iter2)) \ { \ - V value = PFX##_iter_value(&iter2); \ + V value = CMC_(PFX, _iter_value)(&iter2); \ \ - if (PFX##_impl_get_node(_set1_, value) == NULL) \ - PFX##_insert(_set_r_, value); \ + if (CMC_(PFX, _impl_get_node)(_set1_, value) == NULL) \ + CMC_(PFX, _insert)(_set_r_, value); \ } \ \ return _set_r_; \ @@ -845,7 +873,7 @@ static const char *cmc_string_fmt_treeset = "struct %s<%s> " /* Is _set1_ a subset of _set2_ ? */ \ /* A set X is a subset of a set Y when: X <= Y */ \ /* If X is a subset of Y, then Y is a superset of X */ \ - bool PFX##_is_subset(struct SNAME *_set1_, struct SNAME *_set2_) \ + bool CMC_(PFX, _is_subset)(struct SNAME * _set1_, struct SNAME * _set2_) \ { \ /* If the cardinality of _set1_ is greater than that of _set2_ */ \ /* then it is safe to say that _set1_ can't be a subset of _set2_ */ \ @@ -853,16 +881,16 @@ static const char *cmc_string_fmt_treeset = "struct %s<%s> " return false; \ \ /* The empty set is a subset of all sets */ \ - if (PFX##_empty(_set1_)) \ + if (CMC_(PFX, _empty)(_set1_)) \ return true; \ \ - struct SNAME##_iter iter = PFX##_iter_start(_set1_); \ + struct CMC_DEF_ITER(SNAME) iter = CMC_(PFX, _iter_start)(_set1_); \ \ - for (; !PFX##_iter_at_end(&iter); PFX##_iter_next(&iter)) \ + for (; !CMC_(PFX, _iter_at_end)(&iter); CMC_(PFX, _iter_next)(&iter)) \ { \ - V value = PFX##_iter_value(&iter); \ + V value = CMC_(PFX, _iter_value)(&iter); \ \ - if (PFX##_impl_get_node(_set2_, value) == NULL) \ + if (CMC_(PFX, _impl_get_node)(_set2_, value) == NULL) \ return false; \ } \ \ @@ -872,15 +900,16 @@ static const char *cmc_string_fmt_treeset = "struct %s<%s> " /* Is _set1_ a superset of _set2_ ? */ \ /* A set X is a superset of a set Y when: X >= Y */ \ /* If X is a superset of Y, then Y is a subset of X */ \ - bool PFX##_is_superset(struct SNAME *_set1_, struct SNAME *_set2_) \ + bool CMC_(PFX, _is_superset)(struct SNAME * _set1_, struct SNAME * _set2_) \ { \ - return PFX##_is_subset(_set2_, _set1_); \ + return CMC_(PFX, _is_subset)(_set2_, _set1_); \ } \ \ /* Is _set1_ a proper subset of _set2_ ? */ \ /* A set X is a proper subset of a set Y when: X < Y */ \ /* If X is a proper subset of Y, then Y is a proper superset of X */ \ - bool PFX##_is_proper_subset(struct SNAME *_set1_, struct SNAME *_set2_) \ + bool CMC_(PFX, _is_proper_subset)(struct SNAME * _set1_, \ + struct SNAME * _set2_) \ { \ /* If the cardinality of _set1_ is greater than or equal to that */ \ /* of _set2_, then it is safe to say that _set1_ can't be a proper */ \ @@ -888,10 +917,10 @@ static const char *cmc_string_fmt_treeset = "struct %s<%s> " if (_set1_->count >= _set2_->count) \ return false; \ \ - if (PFX##_empty(_set1_)) \ + if (CMC_(PFX, _empty)(_set1_)) \ { \ /* The empty set is a proper subset of all non-empty sets */ \ - if (!PFX##_empty(_set2_)) \ + if (!CMC_(PFX, _empty)(_set2_)) \ return true; \ /* The empty set is not a proper subset of itself (this is true */ \ /* for any set) */ \ @@ -899,13 +928,13 @@ static const char *cmc_string_fmt_treeset = "struct %s<%s> " return false; \ } \ \ - struct SNAME##_iter iter = PFX##_iter_start(_set1_); \ + struct CMC_DEF_ITER(SNAME) iter = CMC_(PFX, _iter_start)(_set1_); \ \ - for (; !PFX##_iter_at_end(&iter); PFX##_iter_next(&iter)) \ + for (; !CMC_(PFX, _iter_at_end)(&iter); CMC_(PFX, _iter_next)(&iter)) \ { \ - V value = PFX##_iter_value(&iter); \ + V value = CMC_(PFX, _iter_value)(&iter); \ \ - if (PFX##_impl_get_node(_set2_, value) == NULL) \ + if (CMC_(PFX, _impl_get_node)(_set2_, value) == NULL) \ return false; \ } \ \ @@ -915,37 +944,39 @@ static const char *cmc_string_fmt_treeset = "struct %s<%s> " /* Is _set1_ a proper superset of _set2_ ? */ \ /* A set X is a proper superset of a set Y when: X > Y */ \ /* If X is a proper superset of Y, then Y is a proper subset of X */ \ - bool PFX##_is_proper_superset(struct SNAME *_set1_, struct SNAME *_set2_) \ + bool CMC_(PFX, _is_proper_superset)(struct SNAME * _set1_, \ + struct SNAME * _set2_) \ { \ - return PFX##_is_proper_subset(_set2_, _set1_); \ + return CMC_(PFX, _is_proper_subset)(_set2_, _set1_); \ } \ \ /* Is _set1_ a disjointset of _set2_ ? */ \ /* A set X is a disjointset of a set Y if their intersection is empty, */ \ /* that is, if there are no elements in common between the two */ \ - bool PFX##_is_disjointset(struct SNAME *_set1_, struct SNAME *_set2_) \ + bool CMC_(PFX, _is_disjointset)(struct SNAME * _set1_, \ + struct SNAME * _set2_) \ { \ /* The intersection of an empty set with any other set will result */ \ /* in an empty set */ \ - if (PFX##_empty(_set1_)) \ + if (CMC_(PFX, _empty)(_set1_)) \ return true; \ \ - struct SNAME##_iter iter = PFX##_iter_start(_set1_); \ + struct CMC_DEF_ITER(SNAME) iter = CMC_(PFX, _iter_start)(_set1_); \ \ - for (; !PFX##_iter_at_end(&iter); PFX##_iter_next(&iter)) \ + for (; !CMC_(PFX, _iter_at_end)(&iter); CMC_(PFX, _iter_next)(&iter)) \ { \ - V value = PFX##_iter_value(&iter); \ + V value = CMC_(PFX, _iter_value)(&iter); \ \ - if (PFX##_impl_get_node(_set2_, value) != NULL) \ + if (CMC_(PFX, _impl_get_node)(_set2_, value) != NULL) \ return false; \ } \ \ return true; \ } \ \ - struct SNAME##_iter PFX##_iter_start(struct SNAME *target) \ + struct CMC_DEF_ITER(SNAME) CMC_(PFX, _iter_start)(struct SNAME * target) \ { \ - struct SNAME##_iter iter; \ + struct CMC_DEF_ITER(SNAME) iter; \ \ iter.target = target; \ iter.cursor = target->root; \ @@ -953,9 +984,9 @@ static const char *cmc_string_fmt_treeset = "struct %s<%s> " iter.last = NULL; \ iter.index = 0; \ iter.start = true; \ - iter.end = PFX##_empty(target); \ + iter.end = CMC_(PFX, _empty)(target); \ \ - if (!PFX##_empty(target)) \ + if (!CMC_(PFX, _empty)(target)) \ { \ while (iter.cursor->left != NULL) \ iter.cursor = iter.cursor->left; \ @@ -970,19 +1001,19 @@ static const char *cmc_string_fmt_treeset = "struct %s<%s> " return iter; \ } \ \ - struct SNAME##_iter PFX##_iter_end(struct SNAME *target) \ + struct CMC_DEF_ITER(SNAME) CMC_(PFX, _iter_end)(struct SNAME * target) \ { \ - struct SNAME##_iter iter; \ + struct CMC_DEF_ITER(SNAME) iter; \ \ iter.target = target; \ iter.cursor = target->root; \ iter.first = NULL; \ iter.last = NULL; \ iter.index = 0; \ - iter.start = PFX##_empty(target); \ + iter.start = CMC_(PFX, _empty)(target); \ iter.end = true; \ \ - if (!PFX##_empty(target)) \ + if (!CMC_(PFX, _empty)(target)) \ { \ while (iter.cursor->right != NULL) \ iter.cursor = iter.cursor->right; \ @@ -999,23 +1030,23 @@ static const char *cmc_string_fmt_treeset = "struct %s<%s> " return iter; \ } \ \ - bool PFX##_iter_at_start(struct SNAME##_iter *iter) \ + bool CMC_(PFX, _iter_at_start)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ - return PFX##_empty(iter->target) || iter->start; \ + return CMC_(PFX, _empty)(iter->target) || iter->start; \ } \ \ - bool PFX##_iter_at_end(struct SNAME##_iter *iter) \ + bool CMC_(PFX, _iter_at_end)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ - return PFX##_empty(iter->target) || iter->end; \ + return CMC_(PFX, _empty)(iter->target) || iter->end; \ } \ \ - bool PFX##_iter_to_start(struct SNAME##_iter *iter) \ + bool CMC_(PFX, _iter_to_start)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ - if (!PFX##_empty(iter->target)) \ + if (!CMC_(PFX, _empty)(iter->target)) \ { \ iter->index = 0; \ iter->start = true; \ - iter->end = PFX##_empty(iter->target); \ + iter->end = CMC_(PFX, _empty)(iter->target); \ iter->cursor = iter->first; \ \ return true; \ @@ -1024,12 +1055,12 @@ static const char *cmc_string_fmt_treeset = "struct %s<%s> " return false; \ } \ \ - bool PFX##_iter_to_end(struct SNAME##_iter *iter) \ + bool CMC_(PFX, _iter_to_end)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ - if (!PFX##_empty(iter->target)) \ + if (!CMC_(PFX, _empty)(iter->target)) \ { \ iter->index = iter->target->count - 1; \ - iter->start = PFX##_empty(iter->target); \ + iter->start = CMC_(PFX, _empty)(iter->target); \ iter->end = true; \ iter->cursor = iter->last; \ \ @@ -1039,7 +1070,7 @@ static const char *cmc_string_fmt_treeset = "struct %s<%s> " return false; \ } \ \ - bool PFX##_iter_next(struct SNAME##_iter *iter) \ + bool CMC_(PFX, _iter_next)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ if (iter->end) \ return false; \ @@ -1050,7 +1081,7 @@ static const char *cmc_string_fmt_treeset = "struct %s<%s> " return false; \ } \ \ - iter->start = PFX##_empty(iter->target); \ + iter->start = CMC_(PFX, _empty)(iter->target); \ \ if (iter->cursor->right != NULL) \ { \ @@ -1079,7 +1110,7 @@ static const char *cmc_string_fmt_treeset = "struct %s<%s> " } \ } \ \ - bool PFX##_iter_prev(struct SNAME##_iter *iter) \ + bool CMC_(PFX, _iter_prev)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ if (iter->start) \ return false; \ @@ -1090,7 +1121,7 @@ static const char *cmc_string_fmt_treeset = "struct %s<%s> " return false; \ } \ \ - iter->end = PFX##_empty(iter->target); \ + iter->end = CMC_(PFX, _empty)(iter->target); \ \ if (iter->cursor->left != NULL) \ { \ @@ -1120,7 +1151,8 @@ static const char *cmc_string_fmt_treeset = "struct %s<%s> " } \ \ /* Returns true only if the iterator moved */ \ - bool PFX##_iter_advance(struct SNAME##_iter *iter, size_t steps) \ + bool CMC_(PFX, _iter_advance)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t steps) \ { \ if (iter->end) \ return false; \ @@ -1135,13 +1167,14 @@ static const char *cmc_string_fmt_treeset = "struct %s<%s> " return false; \ \ for (size_t i = 0; i < steps; i++) \ - PFX##_iter_next(iter); \ + CMC_(PFX, _iter_next)(iter); \ \ return true; \ } \ \ /* Returns true only if the iterator moved */ \ - bool PFX##_iter_rewind(struct SNAME##_iter *iter, size_t steps) \ + bool CMC_(PFX, _iter_rewind)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t steps) \ { \ if (iter->start) \ return false; \ @@ -1156,44 +1189,45 @@ static const char *cmc_string_fmt_treeset = "struct %s<%s> " return false; \ \ for (size_t i = 0; i < steps; i++) \ - PFX##_iter_prev(iter); \ + CMC_(PFX, _iter_prev)(iter); \ \ return true; \ } \ \ /* Returns true only if the iterator was able to be positioned at the */ \ /* given index */ \ - bool PFX##_iter_go_to(struct SNAME##_iter *iter, size_t index) \ + bool CMC_(PFX, _iter_go_to)(struct CMC_DEF_ITER(SNAME) * iter, \ + size_t index) \ { \ if (index >= iter->target->count) \ return false; \ \ if (iter->index > index) \ - return PFX##_iter_rewind(iter, iter->index - index); \ + return CMC_(PFX, _iter_rewind)(iter, iter->index - index); \ else if (iter->index < index) \ - return PFX##_iter_advance(iter, index - iter->index); \ + return CMC_(PFX, _iter_advance)(iter, index - iter->index); \ \ return true; \ } \ \ - V PFX##_iter_value(struct SNAME##_iter *iter) \ + V CMC_(PFX, _iter_value)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ - if (PFX##_empty(iter->target)) \ + if (CMC_(PFX, _empty)(iter->target)) \ return (V){ 0 }; \ \ return iter->cursor->value; \ } \ \ - size_t PFX##_iter_index(struct SNAME##_iter *iter) \ + size_t CMC_(PFX, _iter_index)(struct CMC_DEF_ITER(SNAME) * iter) \ { \ return iter->index; \ } \ \ - static struct SNAME##_node *PFX##_impl_new_node(struct SNAME *_set_, \ - V value) \ + static struct CMC_DEF_NODE(SNAME) * \ + CMC_(PFX, _impl_new_node)(struct SNAME * _set_, V value) \ { \ - struct SNAME##_node *node = \ - _set_->alloc->malloc(sizeof(struct SNAME##_node)); \ + struct CMC_DEF_NODE(SNAME) *node = \ + _set_->alloc->malloc(sizeof(struct CMC_DEF_NODE(SNAME))); \ \ if (!node) \ return NULL; \ @@ -1207,10 +1241,10 @@ static const char *cmc_string_fmt_treeset = "struct %s<%s> " return node; \ } \ \ - static struct SNAME##_node *PFX##_impl_get_node(struct SNAME *_set_, \ - V value) \ + static struct CMC_DEF_NODE(SNAME) * \ + CMC_(PFX, _impl_get_node)(struct SNAME * _set_, V value) \ { \ - struct SNAME##_node *scan = _set_->root; \ + struct CMC_DEF_NODE(SNAME) *scan = _set_->root; \ \ while (scan != NULL) \ { \ @@ -1225,7 +1259,7 @@ static const char *cmc_string_fmt_treeset = "struct %s<%s> " return NULL; \ } \ \ - static unsigned char PFX##_impl_h(struct SNAME##_node *node) \ + static unsigned char CMC_(PFX, _impl_h)(struct CMC_DEF_NODE(SNAME) * node) \ { \ if (node == NULL) \ return 0; \ @@ -1233,21 +1267,22 @@ static const char *cmc_string_fmt_treeset = "struct %s<%s> " return node->height; \ } \ \ - static unsigned char PFX##_impl_hupdate(struct SNAME##_node *node) \ + static unsigned char CMC_(PFX, _impl_hupdate)(struct CMC_DEF_NODE(SNAME) * \ + node) \ { \ if (node == NULL) \ return 0; \ \ - unsigned char h_l = PFX##_impl_h(node->left); \ - unsigned char h_r = PFX##_impl_h(node->right); \ + unsigned char h_l = CMC_(PFX, _impl_h)(node->left); \ + unsigned char h_r = CMC_(PFX, _impl_h)(node->right); \ \ return 1 + (h_l > h_r ? h_l : h_r); \ } \ \ - static void PFX##_impl_rotate_right(struct SNAME##_node **Z) \ + static void CMC_(PFX, _impl_rotate_right)(struct CMC_DEF_NODE(SNAME) * *Z) \ { \ - struct SNAME##_node *root = *Z; \ - struct SNAME##_node *new_root = root->left; \ + struct CMC_DEF_NODE(SNAME) *root = *Z; \ + struct CMC_DEF_NODE(SNAME) *new_root = root->left; \ \ if (root->parent != NULL) \ { \ @@ -1267,16 +1302,16 @@ static const char *cmc_string_fmt_treeset = "struct %s<%s> " \ new_root->right = root; \ \ - root->height = PFX##_impl_hupdate(root); \ - new_root->height = PFX##_impl_hupdate(new_root); \ + root->height = CMC_(PFX, _impl_hupdate)(root); \ + new_root->height = CMC_(PFX, _impl_hupdate)(new_root); \ \ *Z = new_root; \ } \ \ - static void PFX##_impl_rotate_left(struct SNAME##_node **Z) \ + static void CMC_(PFX, _impl_rotate_left)(struct CMC_DEF_NODE(SNAME) * *Z) \ { \ - struct SNAME##_node *root = *Z; \ - struct SNAME##_node *new_root = root->right; \ + struct CMC_DEF_NODE(SNAME) *root = *Z; \ + struct CMC_DEF_NODE(SNAME) *new_root = root->right; \ \ if (root->parent != NULL) \ { \ @@ -1296,16 +1331,16 @@ static const char *cmc_string_fmt_treeset = "struct %s<%s> " \ new_root->left = root; \ \ - root->height = PFX##_impl_hupdate(root); \ - new_root->height = PFX##_impl_hupdate(new_root); \ + root->height = CMC_(PFX, _impl_hupdate)(root); \ + new_root->height = CMC_(PFX, _impl_hupdate)(new_root); \ \ *Z = new_root; \ } \ \ - static void PFX##_impl_rebalance(struct SNAME *_set_, \ - struct SNAME##_node *node) \ + static void CMC_(PFX, _impl_rebalance)(struct SNAME * _set_, \ + struct CMC_DEF_NODE(SNAME) * node) \ { \ - struct SNAME##_node *scan = node, *child = NULL; \ + struct CMC_DEF_NODE(SNAME) *scan = node, *child = NULL; \ \ int balance; \ bool is_root = false; \ @@ -1315,26 +1350,29 @@ static const char *cmc_string_fmt_treeset = "struct %s<%s> " if (scan->parent == NULL) \ is_root = true; \ \ - scan->height = PFX##_impl_hupdate(scan); \ - balance = PFX##_impl_h(scan->right) - PFX##_impl_h(scan->left); \ + scan->height = CMC_(PFX, _impl_hupdate)(scan); \ + balance = CMC_(PFX, _impl_h)(scan->right) - \ + CMC_(PFX, _impl_h)(scan->left); \ \ if (balance >= 2) \ { \ child = scan->right; \ \ - if (PFX##_impl_h(child->right) < PFX##_impl_h(child->left)) \ - PFX##_impl_rotate_right(&(scan->right)); \ + if (CMC_(PFX, _impl_h)(child->right) < \ + CMC_(PFX, _impl_h)(child->left)) \ + CMC_(PFX, _impl_rotate_right)(&(scan->right)); \ \ - PFX##_impl_rotate_left(&scan); \ + CMC_(PFX, _impl_rotate_left)(&scan); \ } \ else if (balance <= -2) \ { \ child = scan->left; \ \ - if (PFX##_impl_h(child->left) < PFX##_impl_h(child->right)) \ - PFX##_impl_rotate_left(&(scan->left)); \ + if (CMC_(PFX, _impl_h)(child->left) < \ + CMC_(PFX, _impl_h)(child->right)) \ + CMC_(PFX, _impl_rotate_left)(&(scan->left)); \ \ - PFX##_impl_rotate_right(&scan); \ + CMC_(PFX, _impl_rotate_right)(&scan); \ } \ \ if (is_root) \ @@ -1347,4 +1385,4 @@ static const char *cmc_string_fmt_treeset = "struct %s<%s> " } \ } -#endif /* CMC_TREESET_H */ +#endif /* CMC_CMC_TREESET_H */ diff --git a/src/cor/alloc.h b/src/cor/alloc.h index 734c34e..a8dc362 100644 --- a/src/cor/alloc.h +++ b/src/cor/alloc.h @@ -17,7 +17,8 @@ * struct cmc_alloc_node * * Custom allocation node. Allows collections to use custom allocation - * functions. + * functions. The cmc_alloc_node_default is the default heap allocator provided + * by the standard library. */ static struct cmc_alloc_node { diff --git a/src/cor/core.h b/src/cor/core.h index e63219b..36d0bd9 100644 --- a/src/cor/core.h +++ b/src/cor/core.h @@ -9,13 +9,7 @@ */ /** - * Core includes and structs used in the library. - * - * In here you will find: - * struct cmc_string - * struct cmc_alloc_node - * struct cmc_callbacks - * cmc_flags + * Core includes and macros for the entire library. */ #ifndef CMC_COR_CORE_H @@ -31,10 +25,34 @@ #include "alloc.h" #include "callbacks.h" #include "flags.h" +#include "params.h" + +#define CMC__(A, B) A##B +#define CMC_(A, B) CMC__(A, B) #define CMC_TO_STRING_(X) #X #define CMC_TO_STRING(X) CMC_TO_STRING_(X) +#if defined(CMC_CAMEL_CASE) +#define CMC_INTERNAL_PREFIX_ITER Iter +#define CMC_INTERNAL_PREFIX_NODE Node +#define CMC_INTERNAL_PREFIX_ENTRY Entry +#define CMC_INTERNAL_PREFIX_FVAL FVal +#define CMC_INTERNAL_PREFIX_FKEY FKey +#else +#define CMC_INTERNAL_PREFIX_ITER _iter +#define CMC_INTERNAL_PREFIX_NODE _node +#define CMC_INTERNAL_PREFIX_ENTRY _entry +#define CMC_INTERNAL_PREFIX_FVAL _fval +#define CMC_INTERNAL_PREFIX_FKEY _fkey +#endif + +#define CMC_DEF_ITER(SNAME) CMC_(SNAME, CMC_INTERNAL_PREFIX_ITER) +#define CMC_DEF_NODE(SNAME) CMC_(SNAME, CMC_INTERNAL_PREFIX_NODE) +#define CMC_DEF_ENTRY(SNAME) CMC_(SNAME, CMC_INTERNAL_PREFIX_ENTRY) +#define CMC_DEF_FVAL(SNAME) CMC_(SNAME, CMC_INTERNAL_PREFIX_FVAL) +#define CMC_DEF_FKEY(SNAME) CMC_(SNAME, CMC_INTERNAL_PREFIX_FKEY) + /** * struct cmc_string * diff --git a/src/cor/flags.h b/src/cor/flags.h index e007623..3f06034 100644 --- a/src/cor/flags.h +++ b/src/cor/flags.h @@ -12,23 +12,25 @@ #define CMC_COR_FLAGS_H /** - * cmc_flags + * enum cmc_flags * * Defines common error codes used by the entire library. */ -static struct +// clang-format off +enum cmc_flags { - int OK; // No errors - int ALLOC; // Allocation failed - int EMPTY; // The collection is empty when it should not - int NOT_FOUND; // Key or value not found - int INVALID; // Invalid argument or operation - int RANGE; // Index out of range - int DUPLICATE; // Duplicate key or value - int ERROR; // Generic error, usually caused by algorithm error - int THREAD; // Generic error regarding threads - int MUTEX; // Generic error regarding mutexes -} cmc_flags = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; + CMC_FLAG_OK = 0, // No errors + CMC_FLAG_ALLOC = 2, // Allocation failed + CMC_FLAG_EMPTY = 3, // The collection is empty when it should not + CMC_FLAG_NOT_FOUND = 4, // Key or value not found + CMC_FLAG_INVALID = 5, // Invalid argument or operation + CMC_FLAG_RANGE = 6, // Index out of range + CMC_FLAG_DUPLICATE = 7, // Duplicate key or value + CMC_FLAG_ERROR = 8, // Generic error, usually caused by algorithm error + CMC_FLAG_THREAD = 9, // Generic error regarding threads + CMC_FLAG_MUTEX = 10 // Generic error regarding mutexes +}; +// clang-format on /** * cmc_flags_to_str diff --git a/src/dev/deque.h b/src/dev/deque.h deleted file mode 100644 index 85841a3..0000000 --- a/src/dev/deque.h +++ /dev/null @@ -1,654 +0,0 @@ -/** - * deque.h - * - * Creation Date: 21/06/2019 - * - * Authors: - * Leonardo Vencovsky (https://github.com/LeoVen) - * - */ - -/*****************************************************************************/ -/********************************************************************* DEQUE */ -/*****************************************************************************/ - -#ifndef CMC_DEQUE_H -#define CMC_DEQUE_H - -#include -#include -#include -#include -#include -#include "utl/log.h" - -#define DEQUE_GENERATE(PFX, SNAME, FMOD, V) \ - DEQUE_GENERATE_HEADER(PFX, SNAME, FMOD, V) \ - DEQUE_GENERATE_SOURCE(PFX, SNAME, FMOD, V) - -#define DEQUE_WRAPGEN_HEADER(PFX, SNAME, FMOD, K, V) \ - DEQUE_GENERATE_HEADER(PFX, SNAME, FMOD, V) - -#define DEQUE_WRAPGEN_SOURCE(PFX, SNAME, FMOD, K, V) \ - DEQUE_GENERATE_SOURCE(PFX, SNAME, FMOD, V) - -/* HEADER ********************************************************************/ -#define DEQUE_GENERATE_HEADER(PFX, SNAME, FMOD, V) \ - \ - /* Deque Structure */ \ - typedef struct SNAME##_s \ - { \ - /* Dynamic circular array of elements */ \ - V *buffer; \ - \ - /* Current circular array capacity */ \ - size_t capacity; \ - \ - /* Current amount of elements */ \ - size_t count; \ - \ - /* Index representing the front of the deque */ \ - size_t front; \ - \ - /* Index representing the back of the deque */ \ - size_t back; \ - \ - /* Function that returns an iterator to the start of the deque */ \ - struct SNAME##_iter_s (*it_start)(struct SNAME##_s *); \ - \ - /* Function that returns an iterator to the end of the deque */ \ - struct SNAME##_iter_s (*it_end)(struct SNAME##_s *); \ - \ - } SNAME, *SNAME##_ptr; \ - \ - /* Deque Iterator */ \ - typedef struct SNAME##_iter_s \ - { \ - /* Target deque */ \ - struct SNAME##_s *target; \ - \ - /* Cursor's position (index) */ \ - size_t cursor; \ - \ - /* Keeps track of relative index to the iteration of elements */ \ - size_t index; \ - \ - /* If the iterator has reached the start of the iteration */ \ - bool start; \ - \ - /* If the iterator has reached the end of the iteration */ \ - bool end; \ - \ - } SNAME##_iter, *SNAME##_iter_ptr; \ - \ - /* Collection Functions */ \ - /* Collection Allocation and Deallocation */ \ - FMOD SNAME *PFX##_new(size_t capacity); \ - FMOD void PFX##_clear(SNAME *_deque_); \ - FMOD void PFX##_free(SNAME *_deque_); \ - /* Collection Input and Output */ \ - FMOD bool PFX##_push_front(SNAME *_deque_, V element); \ - FMOD bool PFX##_push_back(SNAME *_deque_, V element); \ - FMOD bool PFX##_pop_front(SNAME *_deque_); \ - FMOD bool PFX##_pop_back(SNAME *_deque_); \ - /* Conditional Input and Output */ \ - FMOD bool PFX##_push_front_if(SNAME *_deque_, V element, bool condition); \ - FMOD bool PFX##_push_back_if(SNAME *_deque_, V element, bool condition); \ - FMOD bool PFX##_pop_front_if(SNAME *_deque_, bool condition); \ - FMOD bool PFX##_pop_back_if(SNAME *_deque_, bool condition); \ - /* Element Access */ \ - FMOD V PFX##_front(SNAME *_deque_); \ - FMOD V PFX##_back(SNAME *_deque_); \ - /* Collection State */ \ - FMOD bool PFX##_contains(SNAME *_deque_, V element, int (*comparator)(V, V)); \ - FMOD bool PFX##_empty(SNAME *_deque_); \ - FMOD bool PFX##_full(SNAME *_deque_); \ - FMOD size_t PFX##_count(SNAME *_deque_); \ - FMOD size_t PFX##_capacity(SNAME *_deque_); \ - \ - /* Iterator Functions */ \ - /* Iterator Allocation and Deallocation */ \ - FMOD SNAME##_iter *PFX##_iter_new(SNAME *target); \ - FMOD void PFX##_iter_free(SNAME##_iter *iter); \ - /* Iterator Initialization */ \ - FMOD void PFX##_iter_init(SNAME##_iter *iter, SNAME *target); \ - /* Iterator State */ \ - FMOD bool PFX##_iter_start(SNAME##_iter *iter); \ - FMOD bool PFX##_iter_end(SNAME##_iter *iter); \ - /* Iterator Movement */ \ - FMOD void PFX##_iter_to_start(SNAME##_iter *iter); \ - FMOD void PFX##_iter_to_end(SNAME##_iter *iter); \ - FMOD bool PFX##_iter_next(SNAME##_iter *iter); \ - FMOD bool PFX##_iter_prev(SNAME##_iter *iter); \ - /* Iterator Access */ \ - FMOD V PFX##_iter_value(SNAME##_iter *iter); \ - FMOD V *PFX##_iter_rvalue(SNAME##_iter *iter); \ - FMOD size_t PFX##_iter_index(SNAME##_iter *iter); \ - \ - /* Default Value */ \ - static inline V PFX##_impl_default_value(void) \ - { \ - V _empty_value_; \ - \ - memset(&_empty_value_, 0, sizeof(V)); \ - \ - return _empty_value_; \ - } \ - \ -/* SOURCE ********************************************************************/ -#define DEQUE_GENERATE_SOURCE(PFX, SNAME, FMOD, V) \ - \ - /* Implementation Detail Functions */ \ - static bool PFX##_impl_grow(SNAME *_deque_); \ - static SNAME##_iter PFX##_impl_it_start(SNAME *_deque_); \ - static SNAME##_iter PFX##_impl_it_end(SNAME *_deque_); \ - \ - FMOD SNAME *PFX##_new(size_t capacity) \ - { \ - if (capacity < 1) \ - { \ - log_warn("Invalid capacity for %s given: %s", "Heap", capacity); \ - return NULL; \ - } \ - \ - SNAME *_deque_ = malloc(sizeof(SNAME)); \ - \ - if (!_deque_) \ - { \ - log_info("%s allocation failed", "Deque"); \ - return NULL; \ - } \ - \ - _deque_->buffer = malloc(sizeof(V) * capacity); \ - \ - if (!_deque_->buffer) \ - { \ - log_info("%s allocation failed", "Deque buffer"); \ - free(_deque_); \ - return NULL; \ - } \ - \ - memset(_deque_->buffer, 0, sizeof(V) * capacity); \ - \ - _deque_->capacity = capacity; \ - _deque_->count = 0; \ - _deque_->front = 0; \ - _deque_->back = 0; \ - \ - _deque_->it_start = PFX##_impl_it_start; \ - _deque_->it_end = PFX##_impl_it_end; \ - \ - log_info("Deque at %p successfully allocated", _deque_); \ - \ - return _deque_; \ - } \ - \ - FMOD void PFX##_clear(SNAME *_deque_) \ - { \ - if (_deque_ == NULL) \ - log_fatal("Invalid null pointer parameter: %s", "_deque_"); \ - \ - memset(_deque_->buffer, 0, sizeof(V) * _deque_->capacity); \ - \ - _deque_->count = 0; \ - _deque_->front = 0; \ - _deque_->back = 0; \ - \ - log_trace("Deque at %p cleared", _deque_); \ - } \ - \ - FMOD void PFX##_free(SNAME *_deque_) \ - { \ - if (_deque_ == NULL) \ - log_fatal("Invalid null pointer parameter: %s", "_deque_"); \ - \ - free(_deque_->buffer); \ - \ - uintptr_t address = (uintptr_t)(void *)_deque_; \ - \ - free(_deque_); \ - \ - log_info("Heap at %p successfully deallocated", address); \ - } \ - \ - FMOD bool PFX##_push_front(SNAME *_deque_, V element) \ - { \ - if (_deque_ == NULL) \ - log_fatal("Invalid null pointer parameter: %s", "_deque_"); \ - \ - if (PFX##_full(_deque_)) \ - { \ - if (!PFX##_impl_grow(_deque_)) \ - { \ - log_info("Deque at %p failed to be reallocated", _deque_); \ - return false; \ - } \ - } \ - \ - _deque_->front = (_deque_->front == 0) ? _deque_->capacity - 1 : _deque_->front - 1; \ - \ - _deque_->buffer[_deque_->front] = element; \ - \ - log_trace("Element added at %" PRIuMAX " to Deque at %p", _deque_->front, _deque_); \ - \ - _deque_->count++; \ - \ - return true; \ - } \ - \ - FMOD bool PFX##_push_back(SNAME *_deque_, V element) \ - { \ - if (_deque_ == NULL) \ - log_fatal("Invalid null pointer parameter: %s", "_deque_"); \ - \ - if (PFX##_full(_deque_)) \ - { \ - if (!PFX##_impl_grow(_deque_)) \ - { \ - log_info("Deque at %p failed to be reallocated", _deque_); \ - return false; \ - } \ - } \ - \ - _deque_->buffer[_deque_->back] = element; \ - \ - log_trace("Element added at %" PRIuMAX " to Deque at %p", _deque_->back, _deque_); \ - \ - _deque_->back = (_deque_->back == _deque_->capacity - 1) ? 0 : _deque_->back + 1; \ - \ - _deque_->count++; \ - \ - return true; \ - } \ - \ - FMOD bool PFX##_pop_front(SNAME *_deque_) \ - { \ - if (_deque_ == NULL) \ - log_fatal("Invalid null pointer parameter: %s", "_deque_"); \ - \ - if (PFX##_empty(_deque_)) \ - { \ - log_debug("Attempt of removing an element from empty Deque at %p", _deque_); \ - \ - return false; \ - } \ - \ - _deque_->buffer[_deque_->front] = PFX##_impl_default_value(); \ - \ - log_trace("Element removed from %" PRIuMAX " to Deque at %p", _deque_->front, _deque_); \ - \ - _deque_->front = (_deque_->front == _deque_->capacity - 1) ? 0 : _deque_->front + 1; \ - \ - _deque_->count--; \ - \ - return true; \ - } \ - \ - FMOD bool PFX##_pop_back(SNAME *_deque_) \ - { \ - if (_deque_ == NULL) \ - { \ - log_fatal("Invalid null pointer parameter: %s", "_deque_"); \ - } \ - \ - if (PFX##_empty(_deque_)) \ - { \ - log_debug("Attempt of removing an element from empty Deque at %p", _deque_); \ - \ - return false; \ - } \ - \ - _deque_->back = (_deque_->back == 0) ? _deque_->capacity - 1 : _deque_->back - 1; \ - \ - _deque_->buffer[_deque_->back] = PFX##_impl_default_value(); \ - \ - log_trace("Element removed from %" PRIuMAX " to Deque at %p", _deque_->back, _deque_); \ - \ - _deque_->count--; \ - \ - return true; \ - } \ - \ - FMOD bool PFX##_push_front_if(SNAME *_deque_, V element, bool condition) \ - { \ - if (condition) \ - return PFX##_push_front(_deque_, element); \ - \ - return false; \ - } \ - \ - FMOD bool PFX##_push_back_if(SNAME *_deque_, V element, bool condition) \ - { \ - if (condition) \ - return PFX##_push_back(_deque_, element); \ - \ - return false; \ - } \ - \ - FMOD bool PFX##_pop_front_if(SNAME *_deque_, bool condition) \ - { \ - if (condition) \ - return PFX##_pop_front(_deque_); \ - \ - return false; \ - } \ - \ - FMOD bool PFX##_pop_back_if(SNAME *_deque_, bool condition) \ - { \ - if (condition) \ - return PFX##_pop_back(_deque_); \ - \ - return false; \ - } \ - \ - FMOD V PFX##_front(SNAME *_deque_) \ - { \ - if (_deque_ == NULL) \ - log_fatal("Invalid null pointer parameter: %s", "_deque_"); \ - \ - if (PFX##_empty(_deque_)) \ - { \ - log_debug("Attempt to access element from empty Deque at %p", _deque_); \ - \ - PFX##_impl_default_value(); \ - } \ - \ - log_trace("Element access at %" PRIuMAX "", _deque_->front); \ - \ - return _deque_->buffer[_deque_->front]; \ - } \ - \ - FMOD V PFX##_back(SNAME *_deque_) \ - { \ - if (_deque_ == NULL) \ - log_fatal("Invalid null pointer parameter: %s", "_deque_"); \ - \ - if (PFX##_empty(_deque_)) \ - { \ - log_debug("Attempt to access element from empty Deque at %p", _deque_); \ - \ - PFX##_impl_default_value(); \ - } \ - \ - size_t index = (_deque_->back == 0) ? _deque_->capacity - 1 : _deque_->back - 1; \ - \ - log_trace("Element access at %" PRIuMAX "", index); \ - \ - return _deque_->buffer[index]; \ - } \ - \ - FMOD bool PFX##_contains(SNAME *_deque_, V element, int (*comparator)(V, V)) \ - { \ - if (_deque_ == NULL) \ - log_fatal("Invalid null pointer parameter: %s", "_deque_"); \ - \ - if (comparator == NULL) \ - log_fatal("Invalid null pointer parameter: %s", "comparator"); \ - \ - for (size_t i = _deque_->front, j = 0; j < _deque_->count; i = (i + 1) % _deque_->count, j++) \ - { \ - if (comparator(_deque_->buffer[i], element) == 0) \ - return true; \ - } \ - \ - return false; \ - } \ - \ - FMOD bool PFX##_empty(SNAME *_deque_) \ - { \ - if (_deque_ == NULL) \ - log_fatal("Invalid null pointer parameter: %s", "_deque_"); \ - \ - return _deque_->count == 0; \ - } \ - \ - FMOD bool PFX##_full(SNAME *_deque_) \ - { \ - if (_deque_ == NULL) \ - log_fatal("Invalid null pointer parameter: %s", "_deque_"); \ - \ - return _deque_->count >= _deque_->capacity; \ - } \ - \ - FMOD size_t PFX##_count(SNAME *_deque_) \ - { \ - if (_deque_ == NULL) \ - log_fatal("Invalid null pointer parameter: %s", "_deque_"); \ - \ - return _deque_->count; \ - } \ - \ - FMOD size_t PFX##_capacity(SNAME *_deque_) \ - { \ - if (_deque_ == NULL) \ - log_fatal("Invalid null pointer parameter: %s", "_deque_"); \ - \ - return _deque_->capacity; \ - } \ - \ - FMOD SNAME##_iter *PFX##_iter_new(SNAME *target) \ - { \ - SNAME##_iter *iter = malloc(sizeof(SNAME##_iter)); \ - \ - if (!iter) \ - { \ - log_info("%s allocation failed", "Deque Iterator"); \ - return NULL; \ - } \ - \ - PFX##_iter_init(iter, target); \ - \ - log_info("Deque Iterator allocated at %p referencing Heap at %p", iter, target); \ - \ - return iter; \ - } \ - \ - FMOD void PFX##_iter_free(SNAME##_iter *iter) \ - { \ - uintptr_t address = (uintptr_t)(void *)iter; \ - \ - free(iter); \ - \ - log_info("Deque Iterator deallocated at %" PRIxPTR "", address); \ - } \ - \ - FMOD void PFX##_iter_init(SNAME##_iter *iter, SNAME *target) \ - { \ - if (target == NULL) \ - log_fatal("Heap Iterator at %p initialized with null pointer target", iter); \ - \ - if (PFX##_empty(target)) \ - log_warn("Deque Iterator at %p initialized with empty target", iter); \ - \ - iter->target = target; \ - iter->cursor = target->front; \ - iter->index = 0; \ - iter->start = true; \ - iter->end = PFX##_empty(target); \ - } \ - \ - FMOD bool PFX##_iter_start(SNAME##_iter *iter) \ - { \ - if (iter == NULL) \ - log_fatal("Invalid null pointer parameter: %s", "iter"); \ - \ - return PFX##_empty(iter->target) || iter->start; \ - } \ - \ - FMOD bool PFX##_iter_end(SNAME##_iter *iter) \ - { \ - if (iter == NULL) \ - log_fatal("Invalid null pointer parameter: %s", "iter"); \ - \ - return PFX##_empty(iter->target) || iter->end; \ - } \ - \ - FMOD void PFX##_iter_to_start(SNAME##_iter *iter) \ - { \ - if (iter == NULL) \ - log_fatal("Invalid null pointer parameter: %s", "iter"); \ - \ - iter->cursor = iter->target->front; \ - iter->index = 0; \ - iter->start = true; \ - iter->end = PFX##_empty(iter->target); \ - \ - log_trace("Deque Iterator at %p with cursor at %" PRIuMAX "", iter, iter->cursor); \ - } \ - \ - FMOD void PFX##_iter_to_end(SNAME##_iter *iter) \ - { \ - if (iter == NULL) \ - log_fatal("Invalid null pointer parameter: %s", "iter"); \ - \ - if (PFX##_empty(iter->target)) \ - iter->cursor = 0; \ - else \ - iter->cursor = (iter->target->back == 0) ? iter->target->capacity - 1 : iter->target->back - 1; \ - \ - iter->index = iter->target->count - 1; \ - iter->start = PFX##_empty(iter->target); \ - iter->end = true; \ - \ - log_trace("Deque Iterator at %p with cursor at %" PRIuMAX "", iter, iter->cursor); \ - } \ - \ - FMOD bool PFX##_iter_next(SNAME##_iter *iter) \ - { \ - if (iter == NULL) \ - log_fatal("Invalid null pointer parameter: %s", "iter"); \ - \ - if (iter->end) \ - return false; \ - \ - iter->start = PFX##_empty(iter->target); \ - \ - if (iter->index == iter->target->count - 1) \ - { \ - log_trace("Deque Iterator at %p reached the end of Deque %p", iter, iter->target); \ - iter->end = true; \ - } \ - else \ - { \ - iter->cursor = (iter->cursor + 1) % (iter->target->capacity); \ - iter->index++; \ - \ - log_trace("Deque Iterator at %p moved to %" PRIuMAX "", iter, iter->cursor); \ - } \ - \ - return true; \ - } \ - \ - FMOD bool PFX##_iter_prev(SNAME##_iter *iter) \ - { \ - if (iter == NULL) \ - log_fatal("Invalid null pointer parameter: %s", "iter"); \ - \ - if (iter->start) \ - return false; \ - \ - iter->end = PFX##_empty(iter->target); \ - \ - if (iter->index == 0) \ - { \ - log_trace("Deque Iterator at %p reached the start of Deque %p", iter, iter->target); \ - iter->start = true; \ - } \ - else \ - { \ - iter->cursor = (iter->cursor == 0) ? iter->target->capacity - 1 : iter->cursor - 1; \ - iter->index--; \ - \ - log_trace("Deque Iterator at %p moved to %" PRIuMAX "", iter, iter->cursor); \ - } \ - \ - return true; \ - } \ - \ - FMOD V PFX##_iter_value(SNAME##_iter *iter) \ - { \ - if (iter == NULL) \ - log_fatal("Invalid null pointer parameter: %s", "iter"); \ - \ - if (PFX##_empty(iter->target)) \ - { \ - log_debug("Attempt to access element from iterator %p with empty target %p", iter, iter->target); \ - PFX##_impl_default_value(); \ - } \ - \ - log_trace("Element access at %" PRIuMAX "", iter->cursor); \ - \ - return iter->target->buffer[iter->cursor]; \ - } \ - \ - FMOD V *PFX##_iter_rvalue(SNAME##_iter *iter) \ - { \ - if (iter == NULL) \ - log_fatal("Invalid null pointer parameter: %s", "iter"); \ - \ - if (PFX##_empty(iter->target)) \ - { \ - log_debug("Attempt to access element from iterator %p with empty target %p", iter, iter->target); \ - return NULL; \ - } \ - \ - log_trace("Element access at %" PRIuMAX "", iter->cursor); \ - \ - return &(iter->target->buffer[iter->cursor]); \ - } \ - \ - FMOD size_t PFX##_iter_index(SNAME##_iter *iter) \ - { \ - if (iter == NULL) \ - log_fatal("Invalid null pointer parameter: %s", "iter"); \ - \ - return iter->index; \ - } \ - \ - static bool PFX##_impl_grow(SNAME *_deque_) \ - { \ - size_t new_capacity = _deque_->capacity * 2; \ - \ - V *new_buffer = malloc(sizeof(V) * new_capacity); \ - \ - if (!new_buffer) \ - { \ - log_info("%s reallocation failed", "Deque buffer"); \ - return false; \ - } \ - \ - for (size_t i = _deque_->front, j = 0; j < _deque_->count; i = (i + 1) % _deque_->capacity, j++) \ - { \ - new_buffer[j] = _deque_->buffer[i]; \ - } \ - \ - free(_deque_->buffer); \ - \ - _deque_->buffer = new_buffer; \ - _deque_->capacity = new_capacity; \ - _deque_->front = 0; \ - _deque_->back = _deque_->count; \ - \ - return true; \ - } \ - \ - static SNAME##_iter PFX##_impl_it_start(SNAME *_deque_) \ - { \ - SNAME##_iter iter; \ - \ - PFX##_iter_init(&iter, _deque_); \ - \ - return iter; \ - } \ - \ - static SNAME##_iter PFX##_impl_it_end(SNAME *_deque_) \ - { \ - SNAME##_iter iter; \ - \ - PFX##_iter_init(&iter, _deque_); \ - PFX##_iter_to_end(&iter); \ - \ - return iter; \ - } - -#endif /* CMC_DEQUE_H */ diff --git a/src/ext/cmc/deque.h b/src/ext/cmc/deque.h index cf01c47..72fdeac 100644 --- a/src/ext/cmc/deque.h +++ b/src/ext/cmc/deque.h @@ -37,23 +37,25 @@ CMC_EXT_CMC_DEQUE_INIT_SOURCE_(CMC_PARAM_PFX(BODY), CMC_PARAM_SNAME(BODY), \ CMC_PARAM_V(BODY)) -#define CMC_EXT_CMC_DEQUE_INIT_HEADER_(PFX, SNAME, V) \ - \ - struct SNAME PFX##_init(size_t capacity, struct SNAME##_fval *f_val); \ - struct SNAME PFX##_init_custom( \ - size_t capacity, struct SNAME##_fval *f_val, \ - struct cmc_alloc_node *alloc, struct cmc_callbacks *callbacks); +#define CMC_EXT_CMC_DEQUE_INIT_HEADER_(PFX, SNAME, V) \ + \ + struct SNAME CMC_(PFX, _init)(size_t capacity, \ + struct CMC_DEF_FVAL(SNAME) * f_val); \ + struct SNAME CMC_(PFX, _init_custom)( \ + size_t capacity, struct CMC_DEF_FVAL(SNAME) * f_val, \ + struct cmc_alloc_node * alloc, struct cmc_callbacks * callbacks); #define CMC_EXT_CMC_DEQUE_INIT_SOURCE_(PFX, SNAME, V) \ \ - struct SNAME PFX##_init(size_t capacity, struct SNAME##_fval *f_val) \ + struct SNAME CMC_(PFX, _init)(size_t capacity, \ + struct CMC_DEF_FVAL(SNAME) * f_val) \ { \ - return PFX##_init_custom(capacity, f_val, NULL, NULL); \ + return CMC_(PFX, _init_custom)(capacity, f_val, NULL, NULL); \ } \ \ - struct SNAME PFX##_init_custom( \ - size_t capacity, struct SNAME##_fval *f_val, \ - struct cmc_alloc_node *alloc, struct cmc_callbacks *callbacks) \ + struct SNAME CMC_(PFX, _init_custom)( \ + size_t capacity, struct CMC_DEF_FVAL(SNAME) * f_val, \ + struct cmc_alloc_node * alloc, struct cmc_callbacks * callbacks) \ { \ struct SNAME _deque_ = { 0 }; \ \ diff --git a/src/ext/cmc/hashbidimap.h b/src/ext/cmc/hashbidimap.h new file mode 100644 index 0000000..e69de29 diff --git a/src/ext/cmc/hashmap.h b/src/ext/cmc/hashmap.h index fde1147..26837d5 100644 --- a/src/ext/cmc/hashmap.h +++ b/src/ext/cmc/hashmap.h @@ -37,63 +37,65 @@ CMC_EXT_CMC_HASHMAP_INIT_SOURCE_(CMC_PARAM_PFX(BODY), \ CMC_PARAM_SNAME(BODY), CMC_PARAM_V(BODY)) -#define CMC_EXT_CMC_HASHMAP_INIT_HEADER_(PFX, SNAME, V) \ - \ - struct SNAME PFX##_init(size_t capacity, double load, \ - struct SNAME##_fkey *f_key, \ - struct SNAME##_fval *f_val); \ - struct SNAME PFX##_init_custom( \ - size_t capacity, double load, struct SNAME##_fkey *f_key, \ - struct SNAME##_fval *f_val, struct cmc_alloc_node *alloc, \ - struct cmc_callbacks *callbacks); +#define CMC_EXT_CMC_HASHMAP_INIT_HEADER_(PFX, SNAME, V) \ + \ + struct SNAME CMC_(PFX, _init)(size_t capacity, double load, \ + struct CMC_DEF_FKEY(SNAME) * f_key, \ + struct CMC_DEF_FVAL(SNAME) * f_val); \ + struct SNAME CMC_(PFX, _init_custom)( \ + size_t capacity, double load, struct CMC_DEF_FKEY(SNAME) * f_key, \ + struct CMC_DEF_FVAL(SNAME) * f_val, struct cmc_alloc_node * alloc, \ + struct cmc_callbacks * callbacks); -#define CMC_EXT_CMC_HASHMAP_INIT_SOURCE_(PFX, SNAME, V) \ - \ - struct SNAME PFX##_init(size_t capacity, double load, \ - struct SNAME##_fkey *f_key, \ - struct SNAME##_fval *f_val) \ - { \ - return PFX##_init_custom(capacity, load, f_key, f_val, NULL, NULL); \ - } \ - \ - struct SNAME PFX##_init_custom( \ - size_t capacity, double load, struct SNAME##_fkey *f_key, \ - struct SNAME##_fval *f_val, struct cmc_alloc_node *alloc, \ - struct cmc_callbacks *callbacks) \ - { \ - struct SNAME _map_ = { 0 }; \ - \ - if (capacity == 0 || load <= 0 || load >= 1) \ - return _map_; \ - \ - /* Prevent integer overflow */ \ - if (capacity >= UINTMAX_MAX * load) \ - return _map_; \ - \ - if (!f_key || !f_val) \ - return _map_; \ - \ - size_t real_capacity = PFX##_impl_calculate_size(capacity / load); \ - \ - if (!alloc) \ - alloc = &cmc_alloc_node_default; \ - \ - _map_.buffer = \ - alloc->calloc(real_capacity, sizeof(struct SNAME##_entry)); \ - \ - if (!_map_.buffer) \ - return _map_; \ - \ - _map_.count = 0; \ - _map_.capacity = real_capacity; \ - _map_.load = load; \ - _map_.flag = cmc_flags.OK; \ - _map_.f_key = f_key; \ - _map_.f_val = f_val; \ - _map_.alloc = alloc; \ - _map_.callbacks = callbacks; \ - \ - return _map_; \ +#define CMC_EXT_CMC_HASHMAP_INIT_SOURCE_(PFX, SNAME, V) \ + \ + struct SNAME CMC_(PFX, _init)(size_t capacity, double load, \ + struct CMC_DEF_FKEY(SNAME) * f_key, \ + struct CMC_DEF_FVAL(SNAME) * f_val) \ + { \ + return CMC_(PFX, _init_custom)(capacity, load, f_key, f_val, NULL, \ + NULL); \ + } \ + \ + struct SNAME CMC_(PFX, _init_custom)( \ + size_t capacity, double load, struct CMC_DEF_FKEY(SNAME) * f_key, \ + struct CMC_DEF_FVAL(SNAME) * f_val, struct cmc_alloc_node * alloc, \ + struct cmc_callbacks * callbacks) \ + { \ + struct SNAME _map_ = { 0 }; \ + \ + if (capacity == 0 || load <= 0 || load >= 1) \ + return _map_; \ + \ + /* Prevent integer overflow */ \ + if (capacity >= UINTMAX_MAX * load) \ + return _map_; \ + \ + if (!f_key || !f_val) \ + return _map_; \ + \ + size_t real_capacity = \ + CMC_(PFX, _impl_calculate_size)(capacity / load); \ + \ + if (!alloc) \ + alloc = &cmc_alloc_node_default; \ + \ + _map_.buffer = \ + alloc->calloc(real_capacity, sizeof(struct SNAME##_entry)); \ + \ + if (!_map_.buffer) \ + return _map_; \ + \ + _map_.count = 0; \ + _map_.capacity = real_capacity; \ + _map_.load = load; \ + _map_.flag = cmc_flags.OK; \ + _map_.f_key = f_key; \ + _map_.f_val = f_val; \ + _map_.alloc = alloc; \ + _map_.callbacks = callbacks; \ + \ + return _map_; \ } #endif /* CMC_EXT_CMC_HASHMAP_H */ diff --git a/src/sac/queue.h b/src/sac/queue.h deleted file mode 100644 index 7567cb7..0000000 --- a/src/sac/queue.h +++ /dev/null @@ -1,357 +0,0 @@ -/** - * queue.h - * - * Creation Date: 24/06/2019 - * - * Authors: - * Leonardo Vencovsky (https://github.com/LeoVen) - * - */ - -/** - * A Purely Stack Allocated Queue - * - * This means that the Queue has a fixed size, but it also has the advantage of - * not requiring for manually allocating and deallocating the struct. - * - * Generating a collection with too big of a storage can be dangerous and might - * quickly cause a stack overflow. - * - * It is recommended to not generate any Stack Allocated Collection with less - * than 1000 internal storage. - */ - -#ifndef CMC_SAC_QUEUE_H -#define CMC_SAC_QUEUE_H - -#include -#include -#include - -#define SAC_QUEUE_GENERATE(PFX, SNAME, FMOD, V, SIZE) \ - SAC_QUEUE_GENERATE_HEADER(PFX, SNAME, FMOD, V, SIZE) \ - SAC_QUEUE_GENERATE_SOURCE(PFX, SNAME, FMOD, V, SIZE) - -#define SAC_QUEUE_WRAPGEN_HEADER(PFX, SNAME, FMOD, K, V, SIZE) \ - SAC_QUEUE_GENERATE_HEADER(PFX, SNAME, FMOD, V, SIZE) - -#define SAC_QUEUE_WRAPGEN_SOURCE(PFX, SNAME, FMOD, K, V, SIZE) \ - SAC_QUEUE_GENERATE_SOURCE(PFX, SNAME, FMOD, V, SIZE) - -/* HEADER ********************************************************************/ -#define SAC_QUEUE_GENERATE_HEADER(PFX, SNAME, FMOD, V, SIZE) \ - \ - /* Queue Structure */ \ - typedef struct SNAME##_s \ - { \ - /* Internal Storage */ \ - V buffer[SIZE]; \ - \ - /* Current amount of elements */ \ - size_t count; \ - \ - /* Index representing the front of the queue */ \ - size_t front; \ - \ - /* Index representing the back of the queue */ \ - size_t rear; \ - \ - /* Function that returns an iterator to the start of the queue */ \ - struct SNAME##_iter_s (*it_start)(struct SNAME##_s *); \ - \ - /* Function that returns an iterator to the end of the queue */ \ - struct SNAME##_iter_s (*it_end)(struct SNAME##_s *); \ - \ - } SNAME, *SNAME##_ptr; \ - \ - /* Queue Iterator */ \ - typedef struct SNAME##_iter_s \ - { \ - /* Target queue */ \ - struct SNAME##_s *target; \ - \ - /* Cursor's position (index) */ \ - size_t cursor; \ - \ - /* Keeps track of relative index to the iteration of elements */ \ - size_t index; \ - \ - /* If the iterator has reached the start of the iteration */ \ - bool start; \ - \ - /* If the iterator has reached the end of the iteration */ \ - bool end; \ - \ - } SNAME##_iter, *SNAME##_iter_ptr; \ - \ - /* Collection Functions */ \ - /* Collection Allocation and Deallocation */ \ - FMOD SNAME PFX##_new(void); \ - FMOD void PFX##_clear(SNAME *_queue_); \ - /* Collection Input and Output */ \ - FMOD bool PFX##_enqueue(SNAME *_queue_, V element); \ - FMOD bool PFX##_dequeue(SNAME *_queue_); \ - /* Conditional Input and Output */ \ - FMOD bool PFX##_enqueue_if(SNAME *_queue_, V element, bool condition); \ - FMOD bool PFX##_dequeue_if(SNAME *_queue_, bool condition); \ - /* Element Access */ \ - FMOD V PFX##_peek(SNAME *_queue_); \ - /* Collection State */ \ - FMOD bool PFX##_contains(SNAME *_queue_, V element, int (*comparator)(V, V)); \ - FMOD bool PFX##_empty(SNAME *_queue_); \ - FMOD bool PFX##_full(SNAME *_queue_); \ - FMOD size_t PFX##_count(SNAME *_queue_); \ - FMOD size_t PFX##_capacity(void); \ - \ - /* Iterator Functions */ \ - /* Iterator Initialization */ \ - FMOD void PFX##_iter_init(SNAME##_iter *iter, SNAME *target); \ - /* Iterator State */ \ - FMOD bool PFX##_iter_start(SNAME##_iter *iter); \ - FMOD bool PFX##_iter_end(SNAME##_iter *iter); \ - /* Iterator Movement */ \ - FMOD void PFX##_iter_to_start(SNAME##_iter *iter); \ - FMOD void PFX##_iter_to_end(SNAME##_iter *iter); \ - FMOD bool PFX##_iter_next(SNAME##_iter *iter); \ - FMOD bool PFX##_iter_prev(SNAME##_iter *iter); \ - /* Iterator Access */ \ - FMOD V PFX##_iter_value(SNAME##_iter *iter); \ - FMOD V *PFX##_iter_rvalue(SNAME##_iter *iter); \ - FMOD size_t PFX##_iter_index(SNAME##_iter *iter); \ - \ - /* Default Value */ \ - static inline V PFX##_impl_default_value(void) \ - { \ - V _empty_value_; \ - \ - memset(&_empty_value_, 0, sizeof(V)); \ - \ - return _empty_value_; \ - } \ - \ -/* SOURCE ********************************************************************/ -#define SAC_QUEUE_GENERATE_SOURCE(PFX, SNAME, FMOD, V, SIZE) \ - \ - /* Implementation Detail Functions */ \ - static SNAME##_iter PFX##_impl_it_start(SNAME *_queue_); \ - static SNAME##_iter PFX##_impl_it_end(SNAME *_queue_); \ - \ - FMOD SNAME PFX##_new(void) \ - { \ - SNAME result; \ - \ - memset(&result, 0, sizeof(SNAME)); \ - \ - result.it_start = PFX##_impl_it_start; \ - result.it_end = PFX##_impl_it_end; \ - \ - return result; \ - } \ - \ - FMOD void PFX##_clear(SNAME *_queue_) \ - { \ - memset(_queue_->buffer, 0, sizeof(_queue_->buffer)); \ - \ - _queue_->count = 0; \ - _queue_->front = 0; \ - _queue_->rear = 0; \ - } \ - \ - FMOD bool PFX##_enqueue(SNAME *_queue_, V element) \ - { \ - if (PFX##_full(_queue_)) \ - return false; \ - \ - _queue_->buffer[_queue_->rear] = element; \ - \ - _queue_->rear = (_queue_->rear == SIZE - 1) ? 0 : _queue_->rear + 1; \ - _queue_->count++; \ - \ - return true; \ - } \ - \ - FMOD bool PFX##_dequeue(SNAME *_queue_) \ - { \ - if (PFX##_empty(_queue_)) \ - return false; \ - \ - _queue_->buffer[_queue_->front] = PFX##_impl_default_value(); \ - \ - _queue_->front = (_queue_->front == SIZE - 1) ? 0 : _queue_->front + 1; \ - _queue_->count--; \ - \ - return true; \ - } \ - \ - FMOD bool PFX##_enqueue_if(SNAME *_queue_, V element, bool condition) \ - { \ - if (condition) \ - return PFX##_enqueue(_queue_, element); \ - \ - return false; \ - } \ - \ - FMOD bool PFX##_dequeue_if(SNAME *_queue_, bool condition) \ - { \ - if (condition) \ - return PFX##_dequeue(_queue_); \ - \ - return false; \ - } \ - \ - FMOD V PFX##_peek(SNAME *_queue_) \ - { \ - if (PFX##_empty(_queue_)) \ - return PFX##_impl_default_value(); \ - \ - return _queue_->buffer[_queue_->front]; \ - } \ - \ - FMOD bool PFX##_contains(SNAME *_queue_, V element, int (*comparator)(V, V)) \ - { \ - for (size_t i = _queue_->front, j = 0; j < _queue_->count; i = (i + 1) % _queue_->count, j++) \ - { \ - if (comparator(_queue_->buffer[i], element) == 0) \ - return true; \ - } \ - \ - return false; \ - } \ - \ - FMOD bool PFX##_empty(SNAME *_queue_) \ - { \ - return _queue_->count == 0; \ - } \ - \ - FMOD bool PFX##_full(SNAME *_queue_) \ - { \ - return _queue_->count >= SIZE; \ - } \ - \ - FMOD size_t PFX##_count(SNAME *_queue_) \ - { \ - return _queue_->count; \ - } \ - \ - FMOD size_t PFX##_capacity(void) \ - { \ - return SIZE; \ - } \ - \ - FMOD void PFX##_iter_init(SNAME##_iter *iter, SNAME *target) \ - { \ - iter->target = target; \ - iter->cursor = target->front; \ - iter->index = 0; \ - iter->start = true; \ - iter->end = PFX##_empty(target); \ - } \ - \ - FMOD bool PFX##_iter_start(SNAME##_iter *iter) \ - { \ - return PFX##_empty(iter->target) || iter->start; \ - } \ - \ - FMOD bool PFX##_iter_end(SNAME##_iter *iter) \ - { \ - return PFX##_empty(iter->target) || iter->end; \ - } \ - \ - FMOD void PFX##_iter_to_start(SNAME##_iter *iter) \ - { \ - iter->cursor = iter->target->front; \ - iter->index = 0; \ - iter->start = true; \ - iter->end = PFX##_empty(iter->target); \ - } \ - \ - FMOD void PFX##_iter_to_end(SNAME##_iter *iter) \ - { \ - if (PFX##_empty(iter->target)) \ - iter->cursor = 0; \ - else \ - iter->cursor = (iter->target->rear == 0) ? SIZE - 1 : iter->target->rear - 1; \ - \ - iter->index = iter->target->count - 1; \ - iter->start = PFX##_empty(iter->target); \ - iter->end = true; \ - } \ - \ - FMOD bool PFX##_iter_next(SNAME##_iter *iter) \ - { \ - if (iter->end) \ - return false; \ - \ - iter->start = PFX##_empty(iter->target); \ - \ - if (iter->index == iter->target->count - 1) \ - iter->end = true; \ - else \ - { \ - iter->cursor = (iter->cursor + 1) % (SIZE); \ - iter->index++; \ - } \ - \ - return true; \ - } \ - \ - FMOD bool PFX##_iter_prev(SNAME##_iter *iter) \ - { \ - if (iter->start) \ - return false; \ - \ - iter->end = PFX##_empty(iter->target); \ - \ - if (iter->index == 0) \ - iter->start = true; \ - else \ - { \ - iter->cursor = (iter->cursor == 0) ? SIZE - 1 : iter->cursor - 1; \ - iter->index--; \ - } \ - \ - return true; \ - } \ - \ - FMOD V PFX##_iter_value(SNAME##_iter *iter) \ - { \ - if (PFX##_empty(iter->target)) \ - return PFX##_impl_default_value(); \ - \ - return iter->target->buffer[iter->cursor]; \ - } \ - \ - FMOD V *PFX##_iter_rvalue(SNAME##_iter *iter) \ - { \ - if (PFX##_empty(iter->target)) \ - return NULL; \ - \ - return &(iter->target->buffer[iter->cursor]); \ - } \ - \ - FMOD size_t PFX##_iter_index(SNAME##_iter *iter) \ - { \ - return iter->index; \ - } \ - \ - static SNAME##_iter PFX##_impl_it_start(SNAME *_queue_) \ - { \ - SNAME##_iter iter; \ - \ - PFX##_iter_init(&iter, _queue_); \ - PFX##_iter_to_start(&iter); \ - \ - return iter; \ - } \ - \ - static SNAME##_iter PFX##_impl_it_end(SNAME *_queue_) \ - { \ - SNAME##_iter iter; \ - \ - PFX##_iter_init(&iter, _queue_); \ - PFX##_iter_to_end(&iter); \ - \ - return iter; \ - } - -#endif /* CMC_SAC_QUEUE_H */ diff --git a/src/sac/stack.h b/src/sac/stack.h deleted file mode 100644 index 5567e6c..0000000 --- a/src/sac/stack.h +++ /dev/null @@ -1,327 +0,0 @@ -/** - * stack.h - * - * Creation Date: 21/06/2019 - * - * Authors: - * Leonardo Vencovsky (https://github.com/LeoVen) - * - */ - -/** - * A Purely Stack Allocated Stack - * - * This means that the Stack has a fixed size, but it also has the advantage of - * not requiring for manually allocating and deallocating the struct. - * - * Generating a collection with too big of a storage can be dangerous and might - * quickly cause a stack overflow. - * - * It is recommended to not generate any Stack Allocated Collection with less - * than 1000 internal storage. - */ - -#ifndef CMC_SAC_STACK_H -#define CMC_SAC_STACK_H - -#include -#include -#include - -#define SAC_STACK_GENERATE(PFX, SNAME, FMOD, V, SIZE) \ - SAC_STACK_GENERATE_HEADER(PFX, SNAME, FMOD, V, SIZE) \ - SAC_STACK_GENERATE_SOURCE(PFX, SNAME, FMOD, V, SIZE) - -#define SAC_STACK_WRAPGEN_HEADER(PFX, SNAME, FMOD, K, V, SIZE) \ - SAC_STACK_GENERATE_HEADER(PFX, SNAME, FMOD, V, SIZE) - -#define SAC_STACK_WRAPGEN_SOURCE(PFX, SNAME, FMOD, K, V, SIZE) \ - SAC_STACK_GENERATE_SOURCE(PFX, SNAME, FMOD, V, SIZE) - -/* HEADER ********************************************************************/ -#define SAC_STACK_GENERATE_HEADER(PFX, SNAME, FMOD, V, SIZE) \ - \ - /* Stack Structure */ \ - typedef struct SNAME##_s \ - { \ - /* Internal Storage */ \ - V buffer[SIZE]; \ - \ - /* Current amount of elements */ \ - size_t count; \ - \ - /* Function that returns an iterator to the start of the stack */ \ - struct SNAME##_iter_s (*it_start)(struct SNAME##_s *); \ - \ - /* Function that returns an iterator to the end of the stack */ \ - struct SNAME##_iter_s (*it_end)(struct SNAME##_s *); \ - \ - } SNAME, *SNAME##_ptr; \ - \ - /* Stack Iterator */ \ - typedef struct SNAME##_iter_s \ - { \ - /* Target stack */ \ - struct SNAME##_s *target; \ - \ - /* Cursor's position (index) */ \ - size_t cursor; \ - \ - /* If the iterator has reached the start of the iteration */ \ - bool start; \ - \ - /* If the iterator has reached the end of the iteration */ \ - bool end; \ - \ - } SNAME##_iter, *SNAME##_iter_ptr; \ - \ - /* Collection Functions */ \ - /* Collection Allocation and Deallocation */ \ - FMOD SNAME PFX##_new(void); \ - FMOD void PFX##_clear(SNAME *_stack_); \ - /* Collection Input and Output */ \ - FMOD bool PFX##_push(SNAME *_stack_, V element); \ - FMOD bool PFX##_pop(SNAME *_stack_); \ - /* Conditional Input and Output */ \ - FMOD bool PFX##_push_if(SNAME *_stack_, V element, bool condition); \ - FMOD bool PFX##_pop_if(SNAME *_stack_, bool condition); \ - /* Element Access */ \ - FMOD V PFX##_top(SNAME *_stack_); \ - /* Collection State */ \ - FMOD bool PFX##_contains(SNAME *_stack_, V element, int (*comparator)(V, V)); \ - FMOD bool PFX##_empty(SNAME *_stack_); \ - FMOD bool PFX##_full(SNAME *_stack_); \ - FMOD size_t PFX##_count(SNAME *_stack_); \ - FMOD size_t PFX##_capacity(void); \ - \ - /* Iterator Functions */ \ - /* Iterator Initialization */ \ - FMOD void PFX##_iter_init(SNAME##_iter *iter, SNAME *target); \ - /* Iterator State */ \ - FMOD bool PFX##_iter_start(SNAME##_iter *iter); \ - FMOD bool PFX##_iter_end(SNAME##_iter *iter); \ - /* Iterator Movement */ \ - FMOD void PFX##_iter_to_start(SNAME##_iter *iter); \ - FMOD void PFX##_iter_to_end(SNAME##_iter *iter); \ - FMOD bool PFX##_iter_next(SNAME##_iter *iter); \ - FMOD bool PFX##_iter_prev(SNAME##_iter *iter); \ - /* Iterator Access */ \ - FMOD V PFX##_iter_value(SNAME##_iter *iter); \ - FMOD V *PFX##_iter_rvalue(SNAME##_iter *iter); \ - FMOD size_t PFX##_iter_index(SNAME##_iter *iter); \ - \ - /* Default Value */ \ - static inline V PFX##_impl_default_value(void) \ - { \ - V _empty_value_; \ - \ - memset(&_empty_value_, 0, sizeof(V)); \ - \ - return _empty_value_; \ - } \ - \ -/* SOURCE ********************************************************************/ -#define SAC_STACK_GENERATE_SOURCE(PFX, SNAME, FMOD, V, SIZE) \ - \ - /* Implementation Detail Functions */ \ - static SNAME##_iter PFX##_impl_it_start(SNAME *_stack_); \ - static SNAME##_iter PFX##_impl_it_end(SNAME *_stack_); \ - \ - FMOD SNAME PFX##_new(void) \ - { \ - SNAME result; \ - \ - memset(&result, 0, sizeof(SNAME)); \ - \ - result.it_start = PFX##_impl_it_start; \ - result.it_end = PFX##_impl_it_end; \ - \ - return result; \ - } \ - \ - FMOD void PFX##_clear(SNAME *_stack_) \ - { \ - memset(_stack_->buffer, 0, sizeof(_stack_->buffer)); \ - \ - _stack_->count = 0; \ - } \ - \ - FMOD bool PFX##_push(SNAME *_stack_, V element) \ - { \ - if (PFX##_full(_stack_)) \ - return false; \ - \ - _stack_->buffer[_stack_->count++] = element; \ - \ - return true; \ - } \ - \ - FMOD bool PFX##_pop(SNAME *_stack_) \ - { \ - if (PFX##_empty(_stack_)) \ - return false; \ - \ - _stack_->buffer[--_stack_->count] = PFX##_impl_default_value(); \ - \ - return true; \ - } \ - \ - FMOD bool PFX##_push_if(SNAME *_stack_, V element, bool condition) \ - { \ - if (condition) \ - return PFX##_push(_stack_, element); \ - \ - return false; \ - } \ - \ - FMOD bool PFX##_pop_if(SNAME *_stack_, bool condition) \ - { \ - if (condition) \ - return PFX##_pop(_stack_); \ - \ - return false; \ - } \ - \ - FMOD V PFX##_top(SNAME *_stack_) \ - { \ - if (PFX##_empty(_stack_)) \ - return PFX##_impl_default_value(); \ - \ - return _stack_->buffer[_stack_->count - 1]; \ - } \ - \ - FMOD bool PFX##_contains(SNAME *_stack_, V element, int (*comparator)(V, V)) \ - { \ - for (size_t i = 0; i < _stack_->count; i++) \ - { \ - if (comparator(_stack_->buffer[i], element) == 0) \ - return true; \ - } \ - \ - return false; \ - } \ - \ - FMOD bool PFX##_empty(SNAME *_stack_) \ - { \ - return _stack_->count == 0; \ - } \ - \ - FMOD bool PFX##_full(SNAME *_stack_) \ - { \ - return _stack_->count >= SIZE; \ - } \ - \ - FMOD size_t PFX##_count(SNAME *_stack_) \ - { \ - return _stack_->count; \ - } \ - \ - FMOD size_t PFX##_capacity(void) \ - { \ - return SIZE; \ - } \ - \ - FMOD void PFX##_iter_init(SNAME##_iter *iter, SNAME *target) \ - { \ - iter->target = target; \ - iter->cursor = iter->target->count - 1; \ - iter->start = true; \ - iter->end = PFX##_empty(target); \ - } \ - \ - FMOD bool PFX##_iter_start(SNAME##_iter *iter) \ - { \ - return PFX##_empty(iter->target) || iter->start; \ - } \ - \ - FMOD bool PFX##_iter_end(SNAME##_iter *iter) \ - { \ - return PFX##_empty(iter->target) || iter->end; \ - } \ - \ - FMOD void PFX##_iter_to_start(SNAME##_iter *iter) \ - { \ - iter->cursor = iter->target->count - 1; \ - iter->start = true; \ - iter->end = PFX##_empty(iter->target); \ - } \ - \ - FMOD void PFX##_iter_to_end(SNAME##_iter *iter) \ - { \ - iter->cursor = 0; \ - iter->start = PFX##_empty(iter->target); \ - iter->end = true; \ - } \ - \ - FMOD bool PFX##_iter_next(SNAME##_iter *iter) \ - { \ - if (iter->end) \ - return false; \ - \ - iter->start = PFX##_empty(iter->target); \ - \ - if (iter->cursor == 0) \ - iter->end = true; \ - else \ - iter->cursor--; \ - \ - return true; \ - } \ - \ - FMOD bool PFX##_iter_prev(SNAME##_iter *iter) \ - { \ - if (iter->start) \ - return false; \ - \ - iter->end = PFX##_empty(iter->target); \ - \ - if (iter->cursor == iter->target->count - 1) \ - iter->start = true; \ - else \ - iter->cursor++; \ - \ - return true; \ - } \ - \ - FMOD V PFX##_iter_value(SNAME##_iter *iter) \ - { \ - if (PFX##_empty(iter->target)) \ - return PFX##_impl_default_value(); \ - \ - return iter->target->buffer[iter->cursor]; \ - } \ - \ - FMOD V *PFX##_iter_rvalue(SNAME##_iter *iter) \ - { \ - if (PFX##_empty(iter->target)) \ - return NULL; \ - \ - return &(iter->target->buffer[iter->cursor]); \ - } \ - \ - FMOD size_t PFX##_iter_index(SNAME##_iter *iter) \ - { \ - return iter->target->count - 1 - iter->cursor; \ - } \ - \ - static SNAME##_iter PFX##_impl_it_start(SNAME *_stack_) \ - { \ - SNAME##_iter iter; \ - \ - PFX##_iter_init(&iter, _stack_); \ - PFX##_iter_to_start(&iter); \ - \ - return iter; \ - } \ - \ - static SNAME##_iter PFX##_impl_it_end(SNAME *_stack_) \ - { \ - SNAME##_iter iter; \ - \ - PFX##_iter_init(&iter, _stack_); \ - PFX##_iter_to_end(&iter); \ - \ - return iter; \ - } - -#endif /* CMC_SAC_STACK_H */ diff --git a/src/utl/assert.h b/src/utl/assert.h index 9b0f001..11a8800 100644 --- a/src/utl/assert.h +++ b/src/utl/assert.h @@ -48,8 +48,8 @@ * - cmc_assert_array_sorted_any */ -#ifndef CMC_ASSERT_H -#define CMC_ASSERT_H +#ifndef CMC_UTL_ASSERT_H +#define CMC_UTL_ASSERT_H #include #include @@ -2830,4 +2830,4 @@ static uintmax_t cmc_assert_failed = 0; \ } while (0) -#endif /* CMC_ASSERT_H */ +#endif /* CMC_UTL_ASSERT_H */ diff --git a/src/utl/foreach.h b/src/utl/foreach.h index 207758e..fb6be06 100644 --- a/src/utl/foreach.h +++ b/src/utl/foreach.h @@ -17,15 +17,19 @@ * TARGET - Target variable */ -#ifndef CMC_FOREACH_H -#define CMC_FOREACH_H +#ifndef CMC_UTL_FOREACH_H +#define CMC_UTL_FOREACH_H -#define CMC_FOREACH(PFX, SNAME, ITERNAME, TARGET) \ - for (struct SNAME##_iter ITERNAME = PFX##_iter_start(TARGET); \ - !PFX##_iter_at_end(&ITERNAME); PFX##_iter_next(&ITERNAME)) +#include "../cor/core.h" -#define CMC_FOREACH_REV(PFX, SNAME, ITERNAME, TARGET) \ - for (struct SNAME##_iter ITERNAME = PFX##_iter_end(TARGET); \ - !PFX##_iter_at_start(&ITERNAME); PFX##_iter_prev(&ITERNAME)) +#define CMC_FOREACH(PFX, SNAME, ITERNAME, TARGET) \ + for (struct CMC_DEF_ITER(SNAME) ITERNAME = CMC_(PFX, _iter_start)(TARGET); \ + !CMC_(PFX, _iter_at_end)(&ITERNAME); \ + CMC_(PFX, _iter_next)(&ITERNAME)) -#endif /* CMC_FOREACH_H */ +#define CMC_FOREACH_REV(PFX, SNAME, ITERNAME, TARGET) \ + for (struct CMC_DEF_ITER(SNAME) ITERNAME = CMC_(PFX, _iter_end)(TARGET); \ + !CMC_(PFX, _iter_at_start)(&ITERNAME); \ + CMC_(PFX, _iter_prev)(&ITERNAME)) + +#endif /* CMC_UTL_FOREACH_H */ diff --git a/src/utl/futils.h b/src/utl/futils.h index e9516b1..60f5f6a 100644 --- a/src/utl/futils.h +++ b/src/utl/futils.h @@ -13,8 +13,8 @@ * another one every time. */ -#ifndef CMC_FUTILS_H -#define CMC_FUTILS_H +#ifndef CMC_UTL_FUTILS_H +#define CMC_UTL_FUTILS_H #include #include @@ -461,4 +461,4 @@ static inline size_t cmc_u64_hash_mix(uint64_t element) /* Can simply use cmp for basic data types */ -#endif /* CMC_FUTILS_H */ +#endif /* CMC_UTL_FUTILS_H */ diff --git a/src/utl/log.h b/src/utl/log.h index abcf609..7566190 100644 --- a/src/utl/log.h +++ b/src/utl/log.h @@ -56,8 +56,8 @@ * - If X is less than the level of FATAL, all logs are enabled */ -#ifndef CMC_LOG_H -#define CMC_LOG_H +#ifndef CMC_UTL_LOG_H +#define CMC_UTL_LOG_H #include #include @@ -178,4 +178,4 @@ skip: } } -#endif /* CMC_LOG_H */ +#endif /* CMC_UTL_LOG_H */ diff --git a/src/utl/mutex.h b/src/utl/mutex.h index ef5be43..81f9b76 100644 --- a/src/utl/mutex.h +++ b/src/utl/mutex.h @@ -22,8 +22,8 @@ * - cmc_mtx_trylock */ -#ifndef CMC_MUTEX_H -#define CMC_MUTEX_H +#ifndef CMC_UTL_MUTEX_H +#define CMC_UTL_MUTEX_H #include @@ -72,9 +72,9 @@ static inline bool cmc_mtx_init(struct cmc_mutex *mtx) mtx->mutex = CreateMutex(NULL, FALSE, NULL); if (mtx->mutex == NULL) - mtx->flag = cmc_flags.MUTEX; + mtx->flag = CMC_FLAG_MUTEX; else - mtx->flag = cmc_flags.OK; + mtx->flag = CMC_FLAG_OK; return mtx->mutex != NULL; @@ -82,9 +82,9 @@ static inline bool cmc_mtx_init(struct cmc_mutex *mtx) int err = pthread_mutex_init(&(mtx->mutex), NULL); if (err != 0) - mtx->flag = cmc_flags.MUTEX; + mtx->flag = CMC_FLAG_MUTEX; else - mtx->flag = cmc_flags.OK; + mtx->flag = CMC_FLAG_OK; return err == 0; #endif @@ -102,21 +102,21 @@ static inline bool cmc_mtx_destroy(struct cmc_mutex *mtx) #if defined(CMC_MUTEX_WINDOWS) if (!CloseHandle(mtx->mutex)) { - mtx->flag = cmc_flags.MUTEX; + mtx->flag = CMC_FLAG_MUTEX; return false; } - mtx->flag = cmc_flags.OK; + mtx->flag = CMC_FLAG_OK; return true; #elif defined(CMC_MUTEX_UNIX) if (pthread_mutex_destroy(&(mtx->mutex)) != 0) { - mtx->flag = cmc_flags.MUTEX; + mtx->flag = CMC_FLAG_MUTEX; return false; } - mtx->flag = cmc_flags.OK; + mtx->flag = CMC_FLAG_OK; return true; #endif } @@ -135,21 +135,21 @@ static inline bool cmc_mtx_lock(struct cmc_mutex *mtx) if (result == WAIT_FAILED || result == WAIT_ABANDONED) { - mtx->flag = cmc_flags.MUTEX; + mtx->flag = CMC_FLAG_MUTEX; return false; } - mtx->flag = cmc_flags.OK; + mtx->flag = CMC_FLAG_OK; return true; #elif defined(CMC_MUTEX_UNIX) if (pthread_mutex_lock(&mtx->mutex) != 0) { - mtx->flag = cmc_flags.MUTEX; + mtx->flag = CMC_FLAG_MUTEX; return false; } - mtx->flag = cmc_flags.OK; + mtx->flag = CMC_FLAG_OK; return true; #endif } @@ -165,19 +165,19 @@ static inline bool cmc_mtx_unlock(struct cmc_mutex *mtx) { #if defined(CMC_MUTEX_WINDOWS) if (!ReleaseMutex(mtx->mutex)) - mtx->flag = cmc_flags.MUTEX; + mtx->flag = CMC_FLAG_MUTEX; else - mtx->flag = cmc_flags.OK; + mtx->flag = CMC_FLAG_OK; - return mtx->flag == cmc_flags.OK; + return mtx->flag == CMC_FLAG_OK; #elif defined(CMC_MUTEX_UNIX) if (pthread_mutex_unlock(&mtx->mutex) != 0) - mtx->flag = cmc_flags.MUTEX; + mtx->flag = CMC_FLAG_MUTEX; else - mtx->flag = cmc_flags.OK; + mtx->flag = CMC_FLAG_OK; - return mtx->flag == cmc_flags.OK; + return mtx->flag == CMC_FLAG_OK; #endif } @@ -195,23 +195,23 @@ static inline bool cmc_mtx_trylock(struct cmc_mutex *mtx) if (result == WAIT_FAILED || result == WAIT_ABANDONED) { - mtx->flag = cmc_flags.MUTEX; + mtx->flag = CMC_FLAG_MUTEX; return false; } - mtx->flag = cmc_flags.OK; + mtx->flag = CMC_FLAG_OK; return result != WAIT_TIMEOUT; #elif defined(CMC_MUTEX_UNIX) int err = pthread_mutex_trylock(&mtx->mutex); if (err == EINVAL || err == EFAULT) - mtx->flag = cmc_flags.MUTEX; + mtx->flag = CMC_FLAG_MUTEX; else - mtx->flag = cmc_flags.OK; + mtx->flag = CMC_FLAG_OK; return err == 0; #endif } -#endif /* CMC_MUTEX_H */ +#endif /* CMC_UTL_MUTEX_H */ diff --git a/src/utl/test.h b/src/utl/test.h index d0badb9..a127607 100644 --- a/src/utl/test.h +++ b/src/utl/test.h @@ -34,8 +34,8 @@ * Define this macro to allow colored output. */ -#ifndef CMC_TEST_H -#define CMC_TEST_H +#ifndef CMC_UTL_TEST_H +#define CMC_UTL_TEST_H #include #include @@ -240,4 +240,4 @@ static void cmc_test_log(const char *unit_name, const char *current_test, \ } while (0) -#endif /* CMC_TEST_H */ +#endif /* CMC_UTL_TEST_H */ diff --git a/src/utl/thread.h b/src/utl/thread.h index bf309fb..c46950b 100644 --- a/src/utl/thread.h +++ b/src/utl/thread.h @@ -20,8 +20,8 @@ * - cmc_thrd_join */ -#ifndef CMC_THREAD_H -#define CMC_THREAD_H +#ifndef CMC_UTL_THREAD_H +#define CMC_UTL_THREAD_H #include #include @@ -97,21 +97,21 @@ static inline bool cmc_thrd_create(struct cmc_thread *thr, cmc_thread_proc proc, thr->thread = CreateThread(NULL, 0, cmc_thread_wrapper, thr, 0, NULL); if (!thr->thread) - thr->flag = cmc_flags.THREAD; + thr->flag = CMC_FLAG_THREAD; else - thr->flag = cmc_flags.OK; + thr->flag = CMC_FLAG_OK; - return thr->flag == cmc_flags.OK; + return thr->flag == CMC_FLAG_OK; #elif defined(CMC_THREAD_UNIX) thr->args = args; thr->process = proc; if (pthread_create(&(thr->thread), NULL, cmc_thread_wrapper, thr) != 0) - thr->flag = cmc_flags.THREAD; + thr->flag = CMC_FLAG_THREAD; else - thr->flag = cmc_flags.OK; + thr->flag = CMC_FLAG_OK; - return thr->flag == cmc_flags.OK; + return thr->flag == CMC_FLAG_OK; #endif } @@ -127,7 +127,7 @@ static inline bool cmc_thrd_join(struct cmc_thread *thr, int *result) #if defined(CMC_THREAD_WINDOWS) if (WaitForSingleObject(thr->thread, INFINITE) == WAIT_FAILED) { - thr->flag = cmc_flags.THREAD; + thr->flag = CMC_FLAG_THREAD; return false; } @@ -137,22 +137,22 @@ static inline bool cmc_thrd_join(struct cmc_thread *thr, int *result) { if (GetExitCodeThread(thr->thread, &exit_code) == 0) { - thr->flag = cmc_flags.THREAD; + thr->flag = CMC_FLAG_THREAD; return false; } else *result = (int)exit_code; } - thr->flag = cmc_flags.OK; + thr->flag = CMC_FLAG_OK; if (CloseHandle(thr->thread) == 0) { - thr->flag = cmc_flags.THREAD; + thr->flag = CMC_FLAG_THREAD; return false; } - thr->flag = cmc_flags.OK; + thr->flag = CMC_FLAG_OK; return true; #elif defined(CMC_THREAD_UNIX) @@ -160,7 +160,7 @@ static inline bool cmc_thrd_join(struct cmc_thread *thr, int *result) if (pthread_join(thr->thread, &exit_value) != 0) { - thr->flag = cmc_flags.THREAD; + thr->flag = CMC_FLAG_THREAD; return false; } @@ -169,10 +169,10 @@ static inline bool cmc_thrd_join(struct cmc_thread *thr, int *result) *result = (int)(intptr_t)exit_value; } - thr->flag = cmc_flags.OK; + thr->flag = CMC_FLAG_OK; return true; #endif } -#endif /* CMC_THREAD_H */ +#endif /* CMC_UTL_THREAD_H */ diff --git a/src/utl/timer.h b/src/utl/timer.h index 45b9990..cfa4357 100644 --- a/src/utl/timer.h +++ b/src/utl/timer.h @@ -12,8 +12,8 @@ * Simple timer macros utility for timing code execution. */ -#ifndef CMC_TIMER_H -#define CMC_TIMER_H +#ifndef CMC_UTL_TIMER_H +#define CMC_UTL_TIMER_H #include @@ -40,4 +40,4 @@ struct cmc_timer (double)(t__->stop - t__->start) * 1000.0 / CLOCKS_PER_SEC; \ } while (0) -#endif /* CMC_TIMER_H */ +#endif /* CMC_UTL_TIMER_H */ diff --git a/tests/contains.c b/tests/contains.c deleted file mode 100644 index 730bfba..0000000 --- a/tests/contains.c +++ /dev/null @@ -1,260 +0,0 @@ -#include "../src/macro_collections.h" -#include -#include -#include - -int intcmp(int a, int b) -{ - return (a > b) - (a < b); -} - -size_t inthash(int t) -{ - size_t a = t; - a += ~(a << 15); - a ^= (a >> 10); - a += (a << 3); - a ^= (a >> 6); - a += ~(a << 11); - a ^= (a >> 16); - return a; -} - -CMC_COLLECTION_GENERATE(LIST, l, list, /* K */, int) -CMC_COLLECTION_GENERATE(STACK, s, stack, /* K */, int) -CMC_COLLECTION_GENERATE(QUEUE, q, queue, /* K */, int) -CMC_COLLECTION_GENERATE(DEQUE, d, deque, /* K */, int) -CMC_COLLECTION_GENERATE(LINKEDLIST, ll, linked, /* K */, int) -CMC_COLLECTION_GENERATE(HEAP, h, heap, /* K */, int) -CMC_COLLECTION_GENERATE(TREESET, ts, tset, /* K */, int) -CMC_COLLECTION_GENERATE(TREEMAP, tm, tmap, int, int) -CMC_COLLECTION_GENERATE(HASHSET, hs, hset, /* K */, int) -CMC_COLLECTION_GENERATE(HASHMAP, hm, hmap, int, int) - -CMC_COLLECTION_GENERATE(INTERVALHEAP, ih, iheap, , int) -CMC_COLLECTION_GENERATE(MULTIMAP, mm, mmap, int, int) -CMC_COLLECTION_GENERATE(MULTISET, ms, mset, , int) - -int main(void) -{ - struct list *l = l_new(1000); - struct stack *s = s_new(1000); - struct queue *q = q_new(1000); - struct deque *d = d_new(1000); - struct linked *ll = ll_new(); - struct heap *h = h_new(1000, cmc_max_heap, intcmp); - struct tset *ts = ts_new(intcmp); - struct tmap *tm = tm_new(intcmp); - struct hset *hs = hs_new(1000, 0.6, intcmp, inthash); - struct hmap *hm = hm_new(1000, 0.6, intcmp, inthash); - struct iheap *ih = ih_new(1000, intcmp); - struct mmap *mm = mm_new(1000, 0.8, intcmp, inthash); - struct mset *ms = ms_new(1000, 0.6, intcmp, inthash); - - bool a[13] = { false, false, false, false, false, false, false, - false, false, false, false, false, false }, - b[13] = { false, false, false, false, false, false, false, - false, false, false, false, false, false }, - c[13] = { true, true, true, true, true, true, true, - true, true, true, true, true, true }; - - b[0] = d_contains(d, 1, intcmp); - b[1] = hm_contains(hm, 1); - b[2] = hs_contains(hs, 1); - b[3] = h_contains(h, 1); - b[4] = ll_contains(ll, 1, intcmp); - b[5] = l_contains(l, 1, intcmp); - b[6] = q_contains(q, 1, intcmp); - b[7] = s_contains(s, 1, intcmp); - b[8] = tm_contains(tm, 1); - b[9] = ts_contains(ts, 1); - - b[10] = ih_contains(ih, 1); - b[11] = mm_contains(mm, 1); - b[12] = ms_contains(ms, 1); - - for (int i = 1; i < 1001; i++) - { - if (i % 2 == 0) - { - d_push_front(d, i); - l_push_front(l, i); - ll_push_front(ll, i); - } - else - { - d_push_back(d, i); - l_push_back(l, i); - ll_push_back(ll, i); - } - - s_push(s, i); - q_enqueue(q, i); - h_insert(h, i); - ts_insert(ts, i); - tm_insert(tm, i, i); - hs_insert(hs, i); - hm_insert(hm, i, i); - - ih_insert(ih, i); - mm_insert(mm, i, i); - ms_insert(ms, i); - } - - for (int i = 1; i < 1001; i++) - { - c[0] = c[0] && d_contains(d, i, intcmp); - c[1] = c[1] && hm_contains(hm, i); - c[2] = c[2] && hs_contains(hs, i); - c[3] = c[3] && h_contains(h, i); - c[4] = c[4] && ll_contains(ll, i, intcmp); - c[5] = c[5] && l_contains(l, i, intcmp); - c[6] = c[6] && q_contains(q, i, intcmp); - c[7] = c[7] && s_contains(s, i, intcmp); - c[8] = c[8] && tm_contains(tm, i); - c[9] = c[9] && ts_contains(ts, i); - - c[10] = c[10] && ih_contains(ih, i); - c[11] = c[11] && mm_contains(mm, i); - c[12] = c[12] && ms_contains(ms, i); - } - - for (int i = -500; i < 1; i++) - { - a[0] = a[0] || d_contains(d, i, intcmp); - a[1] = a[1] || hm_contains(hm, i); - a[2] = a[2] || hs_contains(hs, i); - a[3] = a[3] || h_contains(h, i); - a[4] = a[4] || ll_contains(ll, i, intcmp); - a[5] = a[5] || l_contains(l, i, intcmp); - a[6] = a[6] || q_contains(q, i, intcmp); - a[7] = a[7] || s_contains(s, i, intcmp); - a[8] = a[8] || tm_contains(tm, i); - a[9] = a[9] || ts_contains(ts, i); - - a[10] = a[10] || ih_contains(ih, i); - a[11] = a[11] || mm_contains(mm, i); - a[12] = a[12] || ms_contains(ms, i); - } - - for (int i = 1001; i < 1500; i++) - { - a[0] = a[0] || d_contains(d, i, intcmp); - a[1] = a[1] || hm_contains(hm, i); - a[2] = a[2] || hs_contains(hs, i); - a[3] = a[3] || h_contains(h, i); - a[4] = a[4] || ll_contains(ll, i, intcmp); - a[5] = a[5] || l_contains(l, i, intcmp); - a[6] = a[6] || q_contains(q, i, intcmp); - a[7] = a[7] || s_contains(s, i, intcmp); - a[8] = a[8] || tm_contains(tm, i); - a[9] = a[9] || ts_contains(ts, i); - - a[10] = a[10] || ih_contains(ih, i); - a[11] = a[11] || mm_contains(mm, i); - a[12] = a[12] || ms_contains(ms, i); - } - - d_clear(d, NULL); - hm_clear(hm, NULL); - hs_clear(hs, NULL); - h_clear(h, NULL); - ll_clear(ll, NULL); - l_clear(l, NULL); - q_clear(q, NULL); - s_clear(s, NULL); - tm_clear(tm, NULL); - ts_clear(ts, NULL); - - ih_clear(ih, NULL); - mm_clear(mm, NULL); - ms_clear(ms, NULL); - - b[0] = b[0] || d_contains(d, 1, intcmp); - b[1] = b[1] || hm_contains(hm, 1); - b[2] = b[2] || hs_contains(hs, 1); - b[3] = b[3] || h_contains(h, 1); - b[4] = b[4] || ll_contains(ll, 1, intcmp); - b[5] = b[5] || l_contains(l, 1, intcmp); - b[6] = b[6] || q_contains(q, 1, intcmp); - b[7] = b[7] || s_contains(s, 1, intcmp); - b[8] = b[8] || tm_contains(tm, 1); - b[9] = b[9] || ts_contains(ts, 1); - - b[10] = b[10] || ih_contains(ih, 1); - b[11] = b[11] || mm_contains(mm, 1); - b[12] = b[12] || ms_contains(ms, 1); - - printf("-------------------- CONTAINS --------------------\n"); - if (c[0] && !a[0] && !b[0]) - printf("%12s PASSED\n", "DEQUE"); - else - printf("%12s FAILED\n", "DEQUE"); - if (c[1] && !a[1] && !b[1]) - printf("%12s PASSED\n", "HASHMAP"); - else - printf("%12s FAILED\n", "HASHMAP"); - if (c[2] && !a[2] && !b[2]) - printf("%12s PASSED\n", "HASHSET"); - else - printf("%12s FAILED\n", "HASHSET"); - if (c[3] && !a[3] && !b[3]) - printf("%12s PASSED\n", "HEAP"); - else - printf("%12s FAILED\n", "HEAP"); - if (c[4] && !a[4] && !b[4]) - printf("%12s PASSED\n", "LINKEDLIST"); - else - printf("%12s FAILED\n", "LINKEDLIST"); - if (c[5] && !a[5] && !b[5]) - printf("%12s PASSED\n", "LIST"); - else - printf("%12s FAILED\n", "LIST"); - if (c[6] && !a[6] && !b[6]) - printf("%12s PASSED\n", "QUEUE"); - else - printf("%12s FAILED\n", "QUEUE"); - if (c[7] && !a[7] && !b[7]) - printf("%12s PASSED\n", "STACK"); - else - printf("%12s FAILED\n", "STACK"); - if (c[8] && !a[8] && !b[8]) - printf("%12s PASSED\n", "TREEMAP"); - else - printf("%12s FAILED\n", "TREEMAP"); - if (c[9] && !a[9] && !b[9]) - printf("%12s PASSED\n", "TREESET"); - else - printf("%12s FAILED\n", "TREESET"); - if (c[10] && !a[10] && !b[10]) - printf("%12s PASSED\n", "INTERVALHEAP"); - else - printf("%12s FAILED\n", "INTERVALHEAP"); - if (c[11] && !a[11] && !b[11]) - printf("%12s PASSED\n", "MULTIMAP"); - else - printf("%12s FAILED\n", "MULTIMAP"); - if (c[12] && !a[12] && !b[12]) - printf("%12s PASSED\n", "MULTISET"); - else - printf("%12s FAILED\n", "MULTISET"); - - printf("\n\n"); - - l_free(l, NULL); - ll_free(ll, NULL); - s_free(s, NULL); - q_free(q, NULL); - d_free(d, NULL); - h_free(h, NULL); - ts_free(ts, NULL); - tm_free(tm, NULL); - hs_free(hs, NULL); - hm_free(hm, NULL); - - ih_free(ih, NULL); - mm_free(mm, NULL); - ms_free(ms, NULL); - - return 0; -} diff --git a/tests/foreach.c b/tests/foreach.c deleted file mode 100644 index 120d249..0000000 --- a/tests/foreach.c +++ /dev/null @@ -1,286 +0,0 @@ -#include "../src/macro_collections.h" -#include -#include -#include - -int intcmp(int a, int b) -{ - return (a > b) - (a < b); -} - -size_t inthash(int t) -{ - size_t a = t; - a += ~(a << 15); - a ^= (a >> 10); - a += (a << 3); - a ^= (a >> 6); - a += ~(a << 11); - a ^= (a >> 16); - return a; -} - -CMC_COLLECTION_GENERATE(LIST, l, list, /* K */, int) -CMC_COLLECTION_GENERATE(STACK, s, stack, /* K */, int) -CMC_COLLECTION_GENERATE(QUEUE, q, queue, /* K */, int) -CMC_COLLECTION_GENERATE(DEQUE, d, deque, /* K */, int) -CMC_COLLECTION_GENERATE(LINKEDLIST, ll, linked, /* K */, int) -CMC_COLLECTION_GENERATE(HEAP, h, heap, /* K */, int) -CMC_COLLECTION_GENERATE(TREESET, ts, tset, /* K */, int) -CMC_COLLECTION_GENERATE(TREEMAP, tm, tmap, int, int) -CMC_COLLECTION_GENERATE(HASHSET, hs, hset, /* K */, int) -CMC_COLLECTION_GENERATE(HASHMAP, hm, hmap, int, int) - -CMC_COLLECTION_GENERATE(INTERVALHEAP, ih, iheap, , int) -CMC_COLLECTION_GENERATE(MULTIMAP, mm, mmap, int, int) -CMC_COLLECTION_GENERATE(MULTISET, ms, mset, , int) - -int main(void) -{ - struct list *l = l_new(1000); - struct stack *s = s_new(1000); - struct queue *q = q_new(1000); - struct deque *d = d_new(1000); - struct linked *ll = ll_new(); - struct heap *h = h_new(1000, cmc_max_heap, intcmp); - struct tset *ts = ts_new(intcmp); - struct tmap *tm = tm_new(intcmp); - struct hset *hs = hs_new(1000, 0.6, intcmp, inthash); - struct hmap *hm = hm_new(1000, 0.6, intcmp, inthash); - struct iheap *ih = ih_new(1000, intcmp); - struct mmap *mm = mm_new(1000, 0.8, intcmp, inthash); - struct mset *ms = ms_new(1000, 0.6, intcmp, inthash); - - bool p = true; - - for (int i = 1; i < 10001; i++) - { - if (i % 2 == 0) - { - assert(d_push_front(d, i)); - assert(l_push_front(l, i)); - assert(ll_push_front(ll, i)); - } - else - { - assert(d_push_back(d, i)); - assert(l_push_back(l, i)); - assert(ll_push_back(ll, i)); - } - - assert(s_push(s, i)); - assert(q_enqueue(q, i)); - assert(h_insert(h, i)); - assert(ts_insert(ts, i)); - assert(tm_insert(tm, i, i)); - assert(hs_insert(hs, i)); - assert(hm_insert(hm, i, i)); - - assert(ih_insert(ih, i)); - assert(mm_insert(mm, i, i)); - assert(ms_insert(ms, i)); - } - - int sums[16] = { 0 }; - - CMC_FOR_EACH(d, deque, d, { sums[0] += d_iter_value(&iter); }); - - CMC_FOR_EACH(hm, hmap, hm, { - sums[1] += hm_iter_key(&iter); - sums[2] += hm_iter_value(&iter); - }); - - CMC_FOR_EACH(hs, hset, hs, { sums[3] += hs_iter_value(&iter); }); - - CMC_FOR_EACH(h, heap, h, { sums[4] += h_iter_value(&iter); }); - - CMC_FOR_EACH(ll, linked, ll, { sums[5] += ll_iter_value(&iter); }); - - CMC_FOR_EACH(l, list, l, { sums[6] += l_iter_value(&iter); }); - - CMC_FOR_EACH(q, queue, q, { sums[7] += q_iter_value(&iter); }); - - CMC_FOR_EACH(s, stack, s, { sums[8] += s_iter_value(&iter); }); - - CMC_FOR_EACH(tm, tmap, tm, { - sums[9] += tm_iter_key(&iter); - sums[10] += tm_iter_value(&iter); - }); - - CMC_FOR_EACH(ts, tset, ts, { sums[11] += ts_iter_value(&iter); }); - - CMC_FOR_EACH(ih, iheap, ih, { sums[12] += ih_iter_value(&iter); }); - - CMC_FOR_EACH(mm, mmap, mm, { - sums[13] += mm_iter_key(&iter); - sums[14] += mm_iter_value(&iter); - }); - - CMC_FOR_EACH(ms, mset, ms, { sums[15] += ms_iter_value(&iter); }); - - printf("\n-------------------- CMC_FOR_EACH --------------------\n"); - if (sums[0] == 50005000) - printf("%12s PASSED\n", "DEQUE"); - else - printf("%12s FAILED\n", "DEQUE"); - if (sums[1] == 50005000 && sums[2] == 50005000) - printf("%12s PASSED\n", "HASHMAP"); - else - printf("%12s FAILED\n", "HASHMAP"); - if (sums[3] == 50005000) - printf("%12s PASSED\n", "HASHSET"); - else - printf("%12s FAILED\n", "HASHSET"); - if (sums[4] == 50005000) - printf("%12s PASSED\n", "HEAP"); - else - printf("%12s FAILED\n", "HEAP"); - if (sums[5] == 50005000) - printf("%12s PASSED\n", "LINKEDLIST"); - else - printf("%12s FAILED\n", "LINKEDLIST"); - if (sums[6] == 50005000) - printf("%12s PASSED\n", "LIST"); - else - printf("%12s FAILED\n", "LIST"); - if (sums[7] == 50005000) - printf("%12s PASSED\n", "QUEUE"); - else - printf("%12s FAILED\n", "QUEUE"); - if (sums[8] == 50005000) - printf("%12s PASSED\n", "STACK"); - else - printf("%12s FAILED\n", "STACK"); - if (sums[9] == 50005000 && sums[10] == 50005000) - printf("%12s PASSED\n", "TREEMAP"); - else - printf("%12s FAILED\n", "TREEMAP"); - if (sums[11] == 50005000) - printf("%12s PASSED\n", "TREESET"); - else - printf("%12s FAILED\n", "TREESET"); - if (sums[12] == 50005000) - printf("%12s PASSED\n", "INTERVALHEAP"); - else - printf("%12s FAILED\n", "INTERVALHEAP"); - if (sums[13] == 50005000 && sums[14] == 50005000) - printf("%12s PASSED\n", "MULTIMAP"); - else - printf("%12s FAILED\n", "MULTIMAP"); - if (sums[15] == 50005000) - printf("%12s PASSED\n", "MULTISET"); - else - printf("%12s FAILED\n", "MULTISET"); - - printf("\n\n"); - - memset(sums, 0, sizeof sums); - - CMC_FOR_EACH_REV(d, deque, d, { sums[0] += d_iter_value(&iter); }); - - CMC_FOR_EACH_REV(hm, hmap, hm, { - sums[1] += hm_iter_key(&iter); - sums[2] += hm_iter_value(&iter); - }); - - CMC_FOR_EACH_REV(hs, hset, hs, { sums[3] += hs_iter_value(&iter); }); - - CMC_FOR_EACH_REV(h, heap, h, { sums[4] += h_iter_value(&iter); }); - - CMC_FOR_EACH_REV(ll, linked, ll, { sums[5] += ll_iter_value(&iter); }); - - CMC_FOR_EACH_REV(l, list, l, { sums[6] += l_iter_value(&iter); }); - - CMC_FOR_EACH_REV(q, queue, q, { sums[7] += q_iter_value(&iter); }); - - CMC_FOR_EACH_REV(s, stack, s, { sums[8] += s_iter_value(&iter); }); - - CMC_FOR_EACH_REV(tm, tmap, tm, { - sums[9] += tm_iter_key(&iter); - sums[10] += tm_iter_value(&iter); - }); - - CMC_FOR_EACH_REV(ts, tset, ts, { sums[11] += ts_iter_value(&iter); }); - - CMC_FOR_EACH_REV(ih, iheap, ih, { sums[12] += ih_iter_value(&iter); }); - - CMC_FOR_EACH_REV(mm, mmap, mm, { - sums[13] += mm_iter_key(&iter); - sums[14] += mm_iter_value(&iter); - }); - - CMC_FOR_EACH_REV(ms, mset, ms, { sums[15] += ms_iter_value(&iter); }); - - printf("-------------------- CMC_FOR_EACH_REV --------------------\n"); - if (sums[0] == 50005000) - printf("%12s PASSED\n", "DEQUE"); - else - printf("%12s FAILED\n", "DEQUE"); - if (sums[1] == 50005000 && sums[2] == 50005000) - printf("%12s PASSED\n", "HASHMAP"); - else - printf("%12s FAILED\n", "HASHMAP"); - if (sums[3] == 50005000) - printf("%12s PASSED\n", "HASHSET"); - else - printf("%12s FAILED\n", "HASHSET"); - if (sums[4] == 50005000) - printf("%12s PASSED\n", "HEAP"); - else - printf("%12s FAILED\n", "HEAP"); - if (sums[5] == 50005000) - printf("%12s PASSED\n", "LINKEDLIST"); - else - printf("%12s FAILED\n", "LINKEDLIST"); - if (sums[6] == 50005000) - printf("%12s PASSED\n", "LIST"); - else - printf("%12s FAILED\n", "LIST"); - if (sums[7] == 50005000) - printf("%12s PASSED\n", "QUEUE"); - else - printf("%12s FAILED\n", "QUEUE"); - if (sums[8] == 50005000) - printf("%12s PASSED\n", "STACK"); - else - printf("%12s FAILED\n", "STACK"); - if (sums[9] == 50005000 && sums[10] == 50005000) - printf("%12s PASSED\n", "TREEMAP"); - else - printf("%12s FAILED\n", "TREEMAP"); - if (sums[11] == 50005000) - printf("%12s PASSED\n", "TREESET"); - else - printf("%12s FAILED\n", "TREESET"); - if (sums[12] == 50005000) - printf("%12s PASSED\n", "INTERVALHEAP"); - else - printf("%12s FAILED\n", "INTERVALHEAP"); - if (sums[13] == 50005000 && sums[14] == 50005000) - printf("%12s PASSED\n", "MULTIMAP"); - else - printf("%12s FAILED\n", "MULTIMAP"); - if (sums[15] == 50005000) - printf("%12s PASSED\n", "MULTISET"); - else - printf("%12s FAILED\n", "MULTISET"); - - printf("\n\n"); - - l_free(l, NULL); - ll_free(ll, NULL); - s_free(s, NULL); - q_free(q, NULL); - d_free(d, NULL); - h_free(h, NULL); - ts_free(ts, NULL); - tm_free(tm, NULL); - hs_free(hs, NULL); - hm_free(hm, NULL); - - ih_free(ih, NULL); - mm_free(mm, NULL); - ms_free(ms, NULL); - - return 0; -} diff --git a/tests/iterators.c b/tests/iterators.c deleted file mode 100644 index dc51442..0000000 --- a/tests/iterators.c +++ /dev/null @@ -1,139 +0,0 @@ -#include "../src/macro_collections.h" -#include - -int intcmp(int a, int b) -{ - return (a > b) - (a < b); -} - -size_t inthash(int t) -{ - size_t a = t; - a += ~(a << 15); - a ^= (a >> 10); - a += (a << 3); - a ^= (a >> 6); - a += ~(a << 11); - a ^= (a >> 16); - return a; -} - -CMC_COLLECTION_GENERATE(LIST, l, list, /* K */, int) -CMC_COLLECTION_GENERATE(STACK, s, stack, /* K */, int) -CMC_COLLECTION_GENERATE(QUEUE, q, queue, /* K */, int) -CMC_COLLECTION_GENERATE(DEQUE, d, deque, /* K */, int) -CMC_COLLECTION_GENERATE(LINKEDLIST, ll, linked, /* K */, int) -CMC_COLLECTION_GENERATE(HEAP, h, heap, /* K */, int) -CMC_COLLECTION_GENERATE(TREESET, ts, tset, /* K */, int) -CMC_COLLECTION_GENERATE(TREEMAP, tm, tmap, int, double) -CMC_COLLECTION_GENERATE(HASHSET, hs, hset, /* K */, int) -CMC_COLLECTION_GENERATE(HASHMAP, hm, hmap, int, double) - -CMC_COLLECTION_GENERATE(INTERVALHEAP, ih, iheap, /* K */, int) -CMC_COLLECTION_GENERATE(MULTIMAP, mm, mmap, int, double) -CMC_COLLECTION_GENERATE(MULTISET, ms, mset, /* K */, int) - -#define ITERATOR_TEST(NAME, PFX, sname, initfunc, insertbody, sumbody, \ - validation1, validation2) \ - void NAME##_iterator_test(void) \ - { \ - int sum1 = 0; \ - double sum2 = 0.0; \ - \ - struct sname *coll = initfunc; \ - for (int i = 0; i < 10; i++) \ - { \ - insertbody; \ - } \ - \ - struct sname##_iter iter; \ - PFX##_iter_init(&iter, coll); \ - \ - for (int j = 0; j < 4; j++) \ - { \ - while (!PFX##_iter_end(&iter)) \ - { \ - sumbody; \ - PFX##_iter_next(&iter); \ - } \ - while (!PFX##_iter_start(&iter)) \ - { \ - sumbody; \ - PFX##_iter_prev(&iter); \ - } \ - } \ - \ - for (PFX##_iter_to_start(&iter); !PFX##_iter_end(&iter); \ - PFX##_iter_next(&iter)) \ - { \ - sumbody; \ - } \ - \ - for (PFX##_iter_to_end(&iter); !PFX##_iter_start(&iter); \ - PFX##_iter_prev(&iter)) \ - { \ - sumbody; \ - } \ - \ - PFX##_free(coll, NULL); \ - \ - if ((validation1) && (validation2)) \ - printf("%12s PASSED\n", #NAME); \ - else \ - printf("%12s FAILED\n", #NAME); \ - } - -ITERATOR_TEST(DEQUE, d, deque, d_new(20), d_push_front(coll, i), - sum1 += d_iter_value(&iter), sum1 == 450, 1) -ITERATOR_TEST(HASHMAP, hm, hmap, hm_new(50, 0.6, intcmp, inthash), - hm_insert(coll, i, (double)i / 10.0), sum1 += hm_iter_key(&iter); - sum2 += hm_iter_value(&iter), sum1 == 450, (int)sum2 == (int)45) -ITERATOR_TEST(HASHSET, hs, hset, hs_new(50, 0.6, intcmp, inthash), - hs_insert(coll, i), sum1 += hs_iter_value(&iter), sum1 == 450, 1) -ITERATOR_TEST(HEAP, h, heap, h_new(20, cmc_max_heap, intcmp), h_insert(coll, i), - sum1 += h_iter_value(&iter), sum1 == 450, 1) -ITERATOR_TEST(LINKEDLIST, ll, linked, ll_new(), ll_push_back(coll, i), - sum1 += ll_iter_value(&iter), sum1 == 450, 1) -ITERATOR_TEST(LIST, l, list, l_new(20), l_push_back(coll, i), - sum1 += l_iter_value(&iter), sum1 == 450, 1) -ITERATOR_TEST(QUEUE, q, queue, q_new(20), q_enqueue(coll, i), - sum1 += q_iter_value(&iter), sum1 == 450, 1) -ITERATOR_TEST(STACK, s, stack, s_new(20), s_push(coll, i), - sum1 += s_iter_value(&iter), sum1 == 450, 1) -ITERATOR_TEST(TREEMAP, tm, tmap, tm_new(intcmp), - tm_insert(coll, i, (double)i / 10.0), sum1 += tm_iter_key(&iter); - sum2 += tm_iter_value(&iter), sum1 == 450, (int)sum2 == (int)45) -ITERATOR_TEST(TREESET, ts, tset, ts_new(intcmp), ts_insert(coll, i), - sum1 += ts_iter_value(&iter), sum1 == 450, 1) -ITERATOR_TEST(INTERVALHEAP, ih, iheap, ih_new(20, intcmp), ih_insert(coll, i), - sum1 += ih_iter_value(&iter), sum1 == 450, 1) -ITERATOR_TEST(MULTIMAP, mm, mmap, mm_new(50, 0.8, intcmp, inthash), - mm_insert(coll, i, (double)i / 10.0), sum1 += mm_iter_key(&iter); - sum2 += mm_iter_value(&iter), sum1 == 450, (int)sum2 == (int)45) -ITERATOR_TEST(MULTISET, ms, mset, ms_new(50, 0.6, intcmp, inthash), - ms_insert(coll, i), sum1 += ms_iter_value(&iter); - sum2 += ms_iter_multiplicity(&iter), sum1 == 450, - (size_t)sum2 == 100) - -int main(void) -{ - printf("\n-------------------- ITERATORS --------------------\n"); - DEQUE_iterator_test(); - HASHMAP_iterator_test(); - HASHSET_iterator_test(); - HEAP_iterator_test(); - LINKEDLIST_iterator_test(); - LIST_iterator_test(); - QUEUE_iterator_test(); - STACK_iterator_test(); - TREEMAP_iterator_test(); - TREESET_iterator_test(); - - INTERVALHEAP_iterator_test(); - MULTIMAP_iterator_test(); - MULTISET_iterator_test(); - - printf("\n\n"); - - return 0; -} diff --git a/tests/main/src/bitset.c b/tests/main/src/bitset.c index fdd081c..5975085 100644 --- a/tests/main/src/bitset.c +++ b/tests/main/src/bitset.c @@ -75,7 +75,7 @@ struct bitset *bs_new_custom(size_t n_bits, struct cmc_alloc_node *alloc, return ((void *)0); } _bitset_->capacity = capacity; - _bitset_->flag = cmc_flags.OK; + _bitset_->flag = CMC_FLAG_OK; _bitset_->alloc = alloc; _bitset_->callbacks = callbacks; return _bitset_; @@ -97,7 +97,7 @@ struct bitset bs_init_custom(size_t n_bits, struct cmc_alloc_node *alloc, if (!_bitset_.buffer) return _bitset_; _bitset_.capacity = capacity; - _bitset_.flag = cmc_flags.OK; + _bitset_.flag = CMC_FLAG_OK; _bitset_.alloc = alloc; _bitset_.callbacks = callbacks; return _bitset_; @@ -119,7 +119,7 @@ void bs_customize(struct bitset *_bitset_, struct cmc_alloc_node *alloc, else _bitset_->alloc = alloc; _bitset_->callbacks = callbacks; - _bitset_->flag = cmc_flags.OK; + _bitset_->flag = CMC_FLAG_OK; } _Bool bs_set(struct bitset *_bitset_, size_t bit_index) { @@ -128,7 +128,7 @@ _Bool bs_set(struct bitset *_bitset_, size_t bit_index) const cmc_bitset_word bits = sizeof(cmc_bitset_word) * 8; size_t i = bs_bit_to_index(bit_index); _bitset_->buffer[i] |= ((cmc_bitset_word)1) << (bit_index % bits); - _bitset_->flag = cmc_flags.OK; + _bitset_->flag = CMC_FLAG_OK; if (_bitset_->callbacks && _bitset_->callbacks->create) _bitset_->callbacks->create(); return 1; @@ -137,7 +137,7 @@ _Bool bs_set_range(struct bitset *_bitset_, size_t from, size_t to) { if (to < from) { - _bitset_->flag = cmc_flags.INVALID; + _bitset_->flag = CMC_FLAG_INVALID; return 0; } if (!bs_impl_resize(_bitset_, to + 1, 0)) @@ -161,7 +161,7 @@ _Bool bs_set_range(struct bitset *_bitset_, size_t from, size_t to) _bitset_->buffer[i] |= ~((cmc_bitset_word)0); _bitset_->buffer[end_index] |= end_mask; } - _bitset_->flag = cmc_flags.OK; + _bitset_->flag = CMC_FLAG_OK; if (_bitset_->callbacks && _bitset_->callbacks->create) _bitset_->callbacks->create(); return 1; @@ -173,7 +173,7 @@ _Bool bs_clear(struct bitset *_bitset_, size_t bit_index) const cmc_bitset_word bits = sizeof(cmc_bitset_word) * 8; size_t i = bs_bit_to_index(bit_index); _bitset_->buffer[i] &= ~(((cmc_bitset_word)1) << (bit_index % bits)); - _bitset_->flag = cmc_flags.OK; + _bitset_->flag = CMC_FLAG_OK; if (_bitset_->callbacks && _bitset_->callbacks->delete) _bitset_->callbacks->delete (); return 1; @@ -182,7 +182,7 @@ _Bool bs_clear_range(struct bitset *_bitset_, size_t from, size_t to) { if (to < from) { - _bitset_->flag = cmc_flags.INVALID; + _bitset_->flag = CMC_FLAG_INVALID; return 0; } if (!bs_impl_resize(_bitset_, to + 1, 0)) @@ -206,7 +206,7 @@ _Bool bs_clear_range(struct bitset *_bitset_, size_t from, size_t to) _bitset_->buffer[i] = 0; _bitset_->buffer[end_index] &= ~end_mask; } - _bitset_->flag = cmc_flags.OK; + _bitset_->flag = CMC_FLAG_OK; if (_bitset_->callbacks && _bitset_->callbacks->delete) _bitset_->callbacks->delete (); return 1; @@ -218,7 +218,7 @@ _Bool bs_flip(struct bitset *_bitset_, size_t bit_index) const cmc_bitset_word bits = sizeof(cmc_bitset_word) * 8; size_t i = bs_bit_to_index(bit_index); _bitset_->buffer[i] ^= ((cmc_bitset_word)1) << (bit_index % bits); - _bitset_->flag = cmc_flags.OK; + _bitset_->flag = CMC_FLAG_OK; if (_bitset_->callbacks && _bitset_->callbacks->update) _bitset_->callbacks->update(); return 1; @@ -227,7 +227,7 @@ _Bool bs_flip_range(struct bitset *_bitset_, size_t from, size_t to) { if (to < from) { - _bitset_->flag = cmc_flags.INVALID; + _bitset_->flag = CMC_FLAG_INVALID; return 0; } if (!bs_impl_resize(_bitset_, to + 1, 0)) @@ -251,7 +251,7 @@ _Bool bs_flip_range(struct bitset *_bitset_, size_t from, size_t to) _bitset_->buffer[i] ^= ones; _bitset_->buffer[end_index] ^= end_mask; } - _bitset_->flag = cmc_flags.OK; + _bitset_->flag = CMC_FLAG_OK; if (_bitset_->callbacks && _bitset_->callbacks->update) _bitset_->callbacks->update(); return 1; @@ -274,7 +274,7 @@ _Bool bs_set_all(struct bitset *_bitset_) { for (size_t i = 0; i < _bitset_->capacity; i++) _bitset_->buffer[i] = ~((cmc_bitset_word)0); - _bitset_->flag = cmc_flags.OK; + _bitset_->flag = CMC_FLAG_OK; if (_bitset_->callbacks && _bitset_->callbacks->create) _bitset_->callbacks->create(); return 1; @@ -283,7 +283,7 @@ _Bool bs_clear_all(struct bitset *_bitset_) { for (size_t i = 0; i < _bitset_->capacity; i++) _bitset_->buffer[i] = 0; - _bitset_->flag = cmc_flags.OK; + _bitset_->flag = CMC_FLAG_OK; if (_bitset_->callbacks && _bitset_->callbacks->delete) _bitset_->callbacks->delete (); return 1; @@ -292,7 +292,7 @@ _Bool bs_flip_all(struct bitset *_bitset_) { for (size_t i = 0; i < _bitset_->capacity; i++) _bitset_->buffer[i] ^= ~((cmc_bitset_word)0); - _bitset_->flag = cmc_flags.OK; + _bitset_->flag = CMC_FLAG_OK; if (_bitset_->callbacks && _bitset_->callbacks->create) _bitset_->callbacks->create(); return 1; @@ -311,7 +311,7 @@ _Bool bs_impl_resize(struct bitset *_bitset_, size_t n_bits, _Bool do_resize) { if (n_bits == 0) { - _bitset_->flag = cmc_flags.INVALID; + _bitset_->flag = CMC_FLAG_INVALID; return 0; } size_t words = bs_bit_to_index(n_bits - 1) + 1; @@ -321,7 +321,7 @@ _Bool bs_impl_resize(struct bitset *_bitset_, size_t n_bits, _Bool do_resize) realloc(_bitset_->buffer, words * sizeof(cmc_bitset_word)); if (!new_buffer) { - _bitset_->flag = cmc_flags.ALLOC; + _bitset_->flag = CMC_FLAG_ALLOC; return 0; } _bitset_->buffer = new_buffer; @@ -331,7 +331,7 @@ _Bool bs_impl_resize(struct bitset *_bitset_, size_t n_bits, _Bool do_resize) _bitset_->capacity = words; if (_bitset_->callbacks && _bitset_->callbacks->resize) _bitset_->callbacks->resize(); - _bitset_->flag = cmc_flags.OK; + _bitset_->flag = CMC_FLAG_OK; return 1; } diff --git a/tests/main/src/deque.c b/tests/main/src/deque.c index ba1e982..00c5992 100644 --- a/tests/main/src/deque.c +++ b/tests/main/src/deque.c @@ -36,10 +36,6 @@ struct deque *d_new(size_t capacity, struct deque_fval *f_val); struct deque *d_new_custom(size_t capacity, struct deque_fval *f_val, struct cmc_alloc_node *alloc, struct cmc_callbacks *callbacks); -struct deque d_init(size_t capacity, struct deque_fval *f_val); -struct deque d_init_custom(size_t capacity, struct deque_fval *f_val, - struct cmc_alloc_node *alloc, - struct cmc_callbacks *callbacks); void d_clear(struct deque *_deque_); void d_free(struct deque *_deque_); void d_release(struct deque _deque_); @@ -103,40 +99,12 @@ struct deque *d_new_custom(size_t capacity, struct deque_fval *f_val, _deque_->count = 0; _deque_->front = 0; _deque_->back = 0; - _deque_->flag = cmc_flags.OK; + _deque_->flag = CMC_FLAG_OK; _deque_->f_val = f_val; _deque_->alloc = alloc; _deque_->callbacks = callbacks; return _deque_; } -struct deque d_init(size_t capacity, struct deque_fval *f_val) -{ - return d_init_custom(capacity, f_val, ((void *)0), ((void *)0)); -} -struct deque d_init_custom(size_t capacity, struct deque_fval *f_val, - struct cmc_alloc_node *alloc, - struct cmc_callbacks *callbacks) -{ - struct deque _deque_ = { 0 }; - if (capacity < 1) - return _deque_; - if (!f_val) - return _deque_; - if (!alloc) - alloc = &cmc_alloc_node_default; - _deque_.buffer = alloc->calloc(capacity, sizeof(size_t)); - if (!_deque_.buffer) - return _deque_; - _deque_.capacity = capacity; - _deque_.count = 0; - _deque_.front = 0; - _deque_.back = 0; - _deque_.flag = cmc_flags.OK; - _deque_.f_val = f_val; - _deque_.alloc = alloc; - _deque_.callbacks = callbacks; - return _deque_; -} void d_clear(struct deque *_deque_) { if (_deque_->f_val->free) @@ -151,7 +119,7 @@ void d_clear(struct deque *_deque_) _deque_->count = 0; _deque_->front = 0; _deque_->back = 0; - _deque_->flag = cmc_flags.OK; + _deque_->flag = CMC_FLAG_OK; } void d_free(struct deque *_deque_) { @@ -186,7 +154,7 @@ void d_customize(struct deque *_deque_, struct cmc_alloc_node *alloc, else _deque_->alloc = alloc; _deque_->callbacks = callbacks; - _deque_->flag = cmc_flags.OK; + _deque_->flag = CMC_FLAG_OK; } _Bool d_push_front(struct deque *_deque_, size_t value) { @@ -199,7 +167,7 @@ _Bool d_push_front(struct deque *_deque_, size_t value) (_deque_->front == 0) ? _deque_->capacity - 1 : _deque_->front - 1; _deque_->buffer[_deque_->front] = value; _deque_->count++; - _deque_->flag = cmc_flags.OK; + _deque_->flag = CMC_FLAG_OK; if (_deque_->callbacks && _deque_->callbacks->create) _deque_->callbacks->create(); return 1; @@ -215,7 +183,7 @@ _Bool d_push_back(struct deque *_deque_, size_t value) _deque_->back = (_deque_->back == _deque_->capacity - 1) ? 0 : _deque_->back + 1; _deque_->count++; - _deque_->flag = cmc_flags.OK; + _deque_->flag = CMC_FLAG_OK; if (_deque_->callbacks && _deque_->callbacks->create) _deque_->callbacks->create(); return 1; @@ -224,14 +192,14 @@ _Bool d_pop_front(struct deque *_deque_) { if (d_empty(_deque_)) { - _deque_->flag = cmc_flags.EMPTY; + _deque_->flag = CMC_FLAG_EMPTY; return 0; } _deque_->buffer[_deque_->front] = (size_t){ 0 }; _deque_->front = (_deque_->front == _deque_->capacity - 1) ? 0 : _deque_->front + 1; _deque_->count--; - _deque_->flag = cmc_flags.OK; + _deque_->flag = CMC_FLAG_OK; if (_deque_->callbacks && _deque_->callbacks->delete) _deque_->callbacks->delete (); return 1; @@ -240,14 +208,14 @@ _Bool d_pop_back(struct deque *_deque_) { if (d_empty(_deque_)) { - _deque_->flag = cmc_flags.EMPTY; + _deque_->flag = CMC_FLAG_EMPTY; return 0; } _deque_->back = (_deque_->back == 0) ? _deque_->capacity - 1 : _deque_->back - 1; _deque_->buffer[_deque_->back] = (size_t){ 0 }; _deque_->count--; - _deque_->flag = cmc_flags.OK; + _deque_->flag = CMC_FLAG_OK; if (_deque_->callbacks && _deque_->callbacks->delete) _deque_->callbacks->delete (); return 1; @@ -256,10 +224,10 @@ size_t d_front(struct deque *_deque_) { if (d_empty(_deque_)) { - _deque_->flag = cmc_flags.EMPTY; + _deque_->flag = CMC_FLAG_EMPTY; return (size_t){ 0 }; } - _deque_->flag = cmc_flags.OK; + _deque_->flag = CMC_FLAG_OK; if (_deque_->callbacks && _deque_->callbacks->read) _deque_->callbacks->read(); return _deque_->buffer[_deque_->front]; @@ -268,10 +236,10 @@ size_t d_back(struct deque *_deque_) { if (d_empty(_deque_)) { - _deque_->flag = cmc_flags.EMPTY; + _deque_->flag = CMC_FLAG_EMPTY; return (size_t){ 0 }; } - _deque_->flag = cmc_flags.OK; + _deque_->flag = CMC_FLAG_OK; if (_deque_->callbacks && _deque_->callbacks->read) _deque_->callbacks->read(); return _deque_->buffer[(_deque_->back == 0) ? _deque_->capacity - 1 @@ -279,7 +247,7 @@ size_t d_back(struct deque *_deque_) } _Bool d_contains(struct deque *_deque_, size_t value) { - _deque_->flag = cmc_flags.OK; + _deque_->flag = CMC_FLAG_OK; _Bool result = 0; for (size_t i = _deque_->front, j = 0; j < _deque_->count; j++) { @@ -316,18 +284,18 @@ int d_flag(struct deque *_deque_) } _Bool d_resize(struct deque *_deque_, size_t capacity) { - _deque_->flag = cmc_flags.OK; + _deque_->flag = CMC_FLAG_OK; if (_deque_->capacity == capacity) goto success; if (capacity < _deque_->count) { - _deque_->flag = cmc_flags.INVALID; + _deque_->flag = CMC_FLAG_INVALID; return 0; } size_t *new_buffer = _deque_->alloc->malloc(sizeof(size_t) * capacity); if (!new_buffer) { - _deque_->flag = cmc_flags.ALLOC; + _deque_->flag = CMC_FLAG_ALLOC; return 0; } for (size_t i = _deque_->front, j = 0; j < _deque_->count; j++) @@ -351,7 +319,7 @@ struct deque *d_copy_of(struct deque *_deque_) _deque_->alloc, _deque_->callbacks); if (!result) { - _deque_->flag = cmc_flags.ERROR; + _deque_->flag = CMC_FLAG_ERROR; return ((void *)0); } if (_deque_->f_val->cpy) @@ -373,13 +341,13 @@ struct deque *d_copy_of(struct deque *_deque_) result->count = _deque_->count; result->front = 0; result->back = _deque_->count; - _deque_->flag = cmc_flags.OK; + _deque_->flag = CMC_FLAG_OK; return result; } _Bool d_equals(struct deque *_deque1_, struct deque *_deque2_) { - _deque1_->flag = cmc_flags.OK; - _deque2_->flag = cmc_flags.OK; + _deque1_->flag = CMC_FLAG_OK; + _deque2_->flag = CMC_FLAG_OK; if (_deque1_->count != _deque2_->count) return 0; size_t i, j, k; @@ -397,10 +365,11 @@ struct cmc_string d_to_string(struct deque *_deque_) { struct cmc_string str; struct deque *d_ = _deque_; - int n = - snprintf(str.s, cmc_string_len, cmc_string_fmt_deque, "deque", "size_t", - d_, d_->buffer, d_->capacity, d_->count, d_->front, d_->back, - d_->flag, d_->f_val, d_->alloc, d_->callbacks); + int n = snprintf(str.s, cmc_string_len, cmc_cmc_string_fmt_deque, + "CMC_PARAM_SNAME((d, deque, , , size_t))", + "CMC_PARAM_V((d, deque, , , size_t))", d_, d_->buffer, + d_->capacity, d_->count, d_->front, d_->back, d_->flag, + d_->f_val, d_->alloc, d_->callbacks); return n >= 0 ? str : (struct cmc_string){ 0 }; } _Bool d_print(struct deque *_deque_, FILE *fptr) diff --git a/tests/main/src/hashbidimap.c b/tests/main/src/hashbidimap.c index d8e98b8..f9cb231 100644 --- a/tests/main/src/hashbidimap.c +++ b/tests/main/src/hashbidimap.c @@ -142,7 +142,7 @@ struct hashbidimap *hbm_new(size_t capacity, double load, _map_->count = 0; _map_->capacity = real_capacity; _map_->load = load; - _map_->flag = cmc_flags.OK; + _map_->flag = CMC_FLAG_OK; _map_->f_key = f_key; _map_->f_val = f_val; _map_->alloc = alloc; @@ -180,10 +180,10 @@ struct hashbidimap *hbm_new_custom(size_t capacity, double load, _map_->count = 0; _map_->capacity = real_capacity; _map_->load = load; - _map_->flag = cmc_flags.OK; + _map_->flag = CMC_FLAG_OK; _map_->f_key = f_key; _map_->f_val = f_val; - _map_->flag = cmc_flags.OK; + _map_->flag = CMC_FLAG_OK; _map_->alloc = alloc; _map_->callbacks = callbacks; _map_->it_start = hbm_impl_it_start; @@ -207,7 +207,7 @@ void hbm_clear(struct hashbidimap *_map_) _map_->buffer[i][1] = ((void *)0); } _map_->count = 0; - _map_->flag = cmc_flags.OK; + _map_->flag = CMC_FLAG_OK; } void hbm_free(struct hashbidimap *_map_) { @@ -223,7 +223,7 @@ void hbm_customize(struct hashbidimap *_map_, struct cmc_alloc_node *alloc, else _map_->alloc = alloc; _map_->callbacks = callbacks; - _map_->flag = cmc_flags.OK; + _map_->flag = CMC_FLAG_OK; } _Bool hbm_insert(struct hashbidimap *_map_, size_t key, size_t value) { @@ -235,7 +235,7 @@ _Bool hbm_insert(struct hashbidimap *_map_, size_t key, size_t value) if (hbm_impl_get_entry_by_key(_map_, key) != ((void *)0) || hbm_impl_get_entry_by_val(_map_, value) != ((void *)0)) { - _map_->flag = cmc_flags.DUPLICATE; + _map_->flag = CMC_FLAG_DUPLICATE; return 0; } struct hashbidimap_entry *entry = hbm_impl_new_entry(_map_, key, value); @@ -250,11 +250,11 @@ _Bool hbm_insert(struct hashbidimap *_map_, size_t key, size_t value) if (val_entry) *val_entry = ((void *)1); _map_->alloc->free(entry); - _map_->flag = cmc_flags.ERROR; + _map_->flag = CMC_FLAG_ERROR; return 0; } _map_->count++; - _map_->flag = cmc_flags.OK; + _map_->flag = CMC_FLAG_OK; if (_map_->callbacks && _map_->callbacks->create) _map_->callbacks->create(); return 1; @@ -263,27 +263,27 @@ _Bool hbm_update_key(struct hashbidimap *_map_, size_t val, size_t new_key) { if (hbm_empty(_map_)) { - _map_->flag = cmc_flags.EMPTY; + _map_->flag = CMC_FLAG_EMPTY; return 0; } struct hashbidimap_entry **key_entry, **val_entry; val_entry = hbm_impl_get_entry_by_val(_map_, val); if (!val_entry) { - _map_->flag = cmc_flags.NOT_FOUND; + _map_->flag = CMC_FLAG_NOT_FOUND; return 0; } if (_map_->f_key->cmp(new_key, (*val_entry)->key) == 0) goto success; if (hbm_impl_get_entry_by_key(_map_, new_key) != ((void *)0)) { - _map_->flag = cmc_flags.DUPLICATE; + _map_->flag = CMC_FLAG_DUPLICATE; return 0; } key_entry = (*val_entry)->ref[0]; if (!key_entry || *key_entry != *val_entry) { - _map_->flag = cmc_flags.ERROR; + _map_->flag = CMC_FLAG_ERROR; return 0; } struct hashbidimap_entry *to_add = *key_entry; @@ -294,11 +294,11 @@ _Bool hbm_update_key(struct hashbidimap *_map_, size_t val, size_t new_key) { to_add->key = tmp_key; *key_entry = to_add; - _map_->flag = cmc_flags.ERROR; + _map_->flag = CMC_FLAG_ERROR; return 0; } success: - _map_->flag = cmc_flags.OK; + _map_->flag = CMC_FLAG_OK; if (_map_->callbacks && _map_->callbacks->update) _map_->callbacks->update(); return 1; @@ -307,27 +307,27 @@ _Bool hbm_update_val(struct hashbidimap *_map_, size_t key, size_t new_val) { if (hbm_empty(_map_)) { - _map_->flag = cmc_flags.EMPTY; + _map_->flag = CMC_FLAG_EMPTY; return 0; } struct hashbidimap_entry **key_entry, **val_entry; key_entry = hbm_impl_get_entry_by_key(_map_, key); if (!key_entry) { - _map_->flag = cmc_flags.NOT_FOUND; + _map_->flag = CMC_FLAG_NOT_FOUND; return 0; } if (_map_->f_key->cmp(new_val, (*key_entry)->value) == 0) goto success; if (hbm_impl_get_entry_by_val(_map_, new_val) != ((void *)0)) { - _map_->flag = cmc_flags.DUPLICATE; + _map_->flag = CMC_FLAG_DUPLICATE; return 0; } val_entry = (*key_entry)->ref[1]; if (!val_entry || *val_entry != *key_entry) { - _map_->flag = cmc_flags.ERROR; + _map_->flag = CMC_FLAG_ERROR; return 0; } struct hashbidimap_entry *to_add = *val_entry; @@ -338,11 +338,11 @@ _Bool hbm_update_val(struct hashbidimap *_map_, size_t key, size_t new_val) { to_add->value = tmp_val; *val_entry = to_add; - _map_->flag = cmc_flags.ERROR; + _map_->flag = CMC_FLAG_ERROR; return 0; } success: - _map_->flag = cmc_flags.OK; + _map_->flag = CMC_FLAG_OK; if (_map_->callbacks && _map_->callbacks->update) _map_->callbacks->update(); return 1; @@ -352,20 +352,20 @@ _Bool hbm_remove_by_key(struct hashbidimap *_map_, size_t key, size_t *out_key, { if (hbm_empty(_map_)) { - _map_->flag = cmc_flags.EMPTY; + _map_->flag = CMC_FLAG_EMPTY; return 0; } struct hashbidimap_entry **key_entry, **val_entry; key_entry = hbm_impl_get_entry_by_key(_map_, key); if (!key_entry) { - _map_->flag = cmc_flags.NOT_FOUND; + _map_->flag = CMC_FLAG_NOT_FOUND; return 0; } val_entry = (*key_entry)->ref[1]; if (!val_entry || *val_entry != *key_entry) { - _map_->flag = cmc_flags.ERROR; + _map_->flag = CMC_FLAG_ERROR; return 0; } if (out_key) @@ -376,7 +376,7 @@ _Bool hbm_remove_by_key(struct hashbidimap *_map_, size_t key, size_t *out_key, *key_entry = ((void *)1); *val_entry = ((void *)1); _map_->count--; - _map_->flag = cmc_flags.OK; + _map_->flag = CMC_FLAG_OK; if (_map_->callbacks && _map_->callbacks->delete) _map_->callbacks->delete (); return 1; @@ -386,20 +386,20 @@ _Bool hbm_remove_by_val(struct hashbidimap *_map_, size_t val, size_t *out_key, { if (hbm_empty(_map_)) { - _map_->flag = cmc_flags.EMPTY; + _map_->flag = CMC_FLAG_EMPTY; return 0; } struct hashbidimap_entry **key_entry, **val_entry; val_entry = hbm_impl_get_entry_by_val(_map_, val); if (!val_entry) { - _map_->flag = cmc_flags.NOT_FOUND; + _map_->flag = CMC_FLAG_NOT_FOUND; return 0; } key_entry = (*val_entry)->ref[0]; if (!key_entry || *key_entry != *val_entry) { - _map_->flag = cmc_flags.ERROR; + _map_->flag = CMC_FLAG_ERROR; return 0; } if (out_key) @@ -410,7 +410,7 @@ _Bool hbm_remove_by_val(struct hashbidimap *_map_, size_t val, size_t *out_key, *key_entry = ((void *)1); *val_entry = ((void *)1); _map_->count--; - _map_->flag = cmc_flags.OK; + _map_->flag = CMC_FLAG_OK; if (_map_->callbacks && _map_->callbacks->delete) _map_->callbacks->delete (); return 1; @@ -420,10 +420,10 @@ size_t hbm_get_key(struct hashbidimap *_map_, size_t val) struct hashbidimap_entry **entry = hbm_impl_get_entry_by_val(_map_, val); if (!entry) { - _map_->flag = cmc_flags.NOT_FOUND; + _map_->flag = CMC_FLAG_NOT_FOUND; return (size_t){ 0 }; } - _map_->flag = cmc_flags.OK; + _map_->flag = CMC_FLAG_OK; if (_map_->callbacks && _map_->callbacks->read) _map_->callbacks->read(); return (*entry)->key; @@ -433,17 +433,17 @@ size_t hbm_get_val(struct hashbidimap *_map_, size_t key) struct hashbidimap_entry **entry = hbm_impl_get_entry_by_key(_map_, key); if (!entry) { - _map_->flag = cmc_flags.NOT_FOUND; + _map_->flag = CMC_FLAG_NOT_FOUND; return (size_t){ 0 }; } - _map_->flag = cmc_flags.OK; + _map_->flag = CMC_FLAG_OK; if (_map_->callbacks && _map_->callbacks->read) _map_->callbacks->read(); return (*entry)->value; } _Bool hbm_contains_key(struct hashbidimap *_map_, size_t key) { - _map_->flag = cmc_flags.OK; + _map_->flag = CMC_FLAG_OK; _Bool result = hbm_impl_get_entry_by_key(_map_, key) != ((void *)0); if (_map_->callbacks && _map_->callbacks->read) _map_->callbacks->read(); @@ -451,7 +451,7 @@ _Bool hbm_contains_key(struct hashbidimap *_map_, size_t key) } _Bool hbm_contains_val(struct hashbidimap *_map_, size_t val) { - _map_->flag = cmc_flags.OK; + _map_->flag = CMC_FLAG_OK; _Bool result = hbm_impl_get_entry_by_val(_map_, val) != ((void *)0); if (_map_->callbacks && _map_->callbacks->read) _map_->callbacks->read(); @@ -483,20 +483,20 @@ int hbm_flag(struct hashbidimap *_map_) } _Bool hbm_resize(struct hashbidimap *_map_, size_t capacity) { - _map_->flag = cmc_flags.OK; + _map_->flag = CMC_FLAG_OK; if (_map_->capacity == capacity) goto success; if (_map_->capacity > capacity / _map_->load) goto success; if (capacity >= 0xffffffffffffffffULL * _map_->load) { - _map_->flag = cmc_flags.ERROR; + _map_->flag = CMC_FLAG_ERROR; return 0; } size_t new_cap = hbm_impl_calculate_size(capacity); if (new_cap < _map_->count / _map_->load) { - _map_->flag = cmc_flags.INVALID; + _map_->flag = CMC_FLAG_INVALID; return 0; } struct hashbidimap *_new_map_ = @@ -504,7 +504,7 @@ _Bool hbm_resize(struct hashbidimap *_map_, size_t capacity) _map_->alloc, ((void *)0)); if (!_new_map_) { - _map_->flag = cmc_flags.ALLOC; + _map_->flag = CMC_FLAG_ALLOC; return 0; } for (size_t i = 0; i < _map_->capacity; i++) @@ -522,7 +522,7 @@ _Bool hbm_resize(struct hashbidimap *_map_, size_t capacity) _new_map_->f_val = &(struct hashbidimap_fval){ ((void *)0) }; _map_->alloc->free(_new_map_->buffer); _map_->alloc->free(_new_map_); - _map_->flag = cmc_flags.ERROR; + _map_->flag = CMC_FLAG_ERROR; return 0; } _new_map_->count++; @@ -534,7 +534,7 @@ _Bool hbm_resize(struct hashbidimap *_map_, size_t capacity) _new_map_->f_val = &(struct hashbidimap_fval){ ((void *)0) }; _map_->alloc->free(_new_map_->buffer); _map_->alloc->free(_new_map_); - _map_->flag = cmc_flags.ERROR; + _map_->flag = CMC_FLAG_ERROR; return 0; } struct hashbidimap_entry *(*tmp_buff)[2] = _map_->buffer; @@ -554,7 +554,7 @@ struct hashbidimap *hbm_copy_of(struct hashbidimap *_map_) _map_->f_val, _map_->alloc, _map_->callbacks); if (!result) { - _map_->flag = cmc_flags.ERROR; + _map_->flag = CMC_FLAG_ERROR; return ((void *)0); } for (size_t i = 0; i < _map_->capacity; i++) @@ -579,13 +579,13 @@ struct hashbidimap *hbm_copy_of(struct hashbidimap *_map_) result->count++; } } - _map_->flag = cmc_flags.OK; + _map_->flag = CMC_FLAG_OK; return result; } _Bool hbm_equals(struct hashbidimap *_map1_, struct hashbidimap *_map2_) { - _map1_->flag = cmc_flags.OK; - _map2_->flag = cmc_flags.OK; + _map1_->flag = CMC_FLAG_OK; + _map2_->flag = CMC_FLAG_OK; if (_map1_->count != _map2_->count) return 0; struct hashbidimap *_mapA_; @@ -619,10 +619,12 @@ struct cmc_string hbm_to_string(struct hashbidimap *_map_) { struct cmc_string str; struct hashbidimap *m_ = _map_; - int n = snprintf(str.s, cmc_string_len, cmc_string_fmt_hashbidimap, - "hashbidimap", "size_t", "size_t", m_, m_->buffer, - m_->capacity, m_->count, m_->load, m_->flag, m_->f_key, - m_->f_val, m_->alloc, m_->callbacks); + int n = snprintf(str.s, cmc_string_len, cmc_cmc_string_fmt_hashbidimap, + "CMC_PARAM_SNAME((hbm, hashbidimap, , size_t, size_t))", + "CMC_PARAM_K((hbm, hashbidimap, , size_t, size_t))", + "CMC_PARAM_V((hbm, hashbidimap, , size_t, size_t))", m_, + m_->buffer, m_->capacity, m_->count, m_->load, m_->flag, + m_->f_key, m_->f_val, m_->alloc, m_->callbacks); return n >= 0 ? str : (struct cmc_string){ 0 }; } _Bool hbm_print(struct hashbidimap *_map_, FILE *fptr) @@ -795,7 +797,7 @@ size_t hbm_iter_key(struct hashbidimap_iter *iter) { if (hbm_empty(iter->target)) { - iter->target->flag = cmc_flags.EMPTY; + iter->target->flag = CMC_FLAG_EMPTY; return (size_t){ 0 }; } return iter->target->buffer[iter->cursor][0]->key; @@ -804,7 +806,7 @@ size_t hbm_iter_value(struct hashbidimap_iter *iter) { if (hbm_empty(iter->target)) { - iter->target->flag = cmc_flags.EMPTY; + iter->target->flag = CMC_FLAG_EMPTY; return (size_t){ 0 }; } return iter->target->buffer[iter->cursor][0]->value; diff --git a/tests/main/src/hashmap.c b/tests/main/src/hashmap.c index b771ab4..11c6b46 100644 --- a/tests/main/src/hashmap.c +++ b/tests/main/src/hashmap.c @@ -57,13 +57,6 @@ struct hashmap *hm_new_custom(size_t capacity, double load, struct hashmap_fval *f_val, struct cmc_alloc_node *alloc, struct cmc_callbacks *callbacks); -struct hashmap hm_init(size_t capacity, double load, struct hashmap_fkey *f_key, - struct hashmap_fval *f_val); -struct hashmap hm_init_custom(size_t capacity, double load, - struct hashmap_fkey *f_key, - struct hashmap_fval *f_val, - struct cmc_alloc_node *alloc, - struct cmc_callbacks *callbacks); void hm_clear(struct hashmap *_map_); void hm_free(struct hashmap *_map_); void hm_release(struct hashmap _map_); @@ -140,48 +133,13 @@ struct hashmap *hm_new_custom(size_t capacity, double load, _map_->count = 0; _map_->capacity = real_capacity; _map_->load = load; - _map_->flag = cmc_flags.OK; + _map_->flag = CMC_FLAG_OK; _map_->f_key = f_key; _map_->f_val = f_val; _map_->alloc = alloc; _map_->callbacks = callbacks; return _map_; } -struct hashmap hm_init(size_t capacity, double load, struct hashmap_fkey *f_key, - struct hashmap_fval *f_val) -{ - return hm_init_custom(capacity, load, f_key, f_val, ((void *)0), - ((void *)0)); -} -struct hashmap hm_init_custom(size_t capacity, double load, - struct hashmap_fkey *f_key, - struct hashmap_fval *f_val, - struct cmc_alloc_node *alloc, - struct cmc_callbacks *callbacks) -{ - struct hashmap _map_ = { 0 }; - if (capacity == 0 || load <= 0 || load >= 1) - return _map_; - if (capacity >= 0xffffffffffffffffULL * load) - return _map_; - if (!f_key || !f_val) - return _map_; - size_t real_capacity = hm_impl_calculate_size(capacity / load); - if (!alloc) - alloc = &cmc_alloc_node_default; - _map_.buffer = alloc->calloc(real_capacity, sizeof(struct hashmap_entry)); - if (!_map_.buffer) - return _map_; - _map_.count = 0; - _map_.capacity = real_capacity; - _map_.load = load; - _map_.flag = cmc_flags.OK; - _map_.f_key = f_key; - _map_.f_val = f_val; - _map_.alloc = alloc; - _map_.callbacks = callbacks; - return _map_; -} void hm_clear(struct hashmap *_map_) { if (_map_->f_key->free || _map_->f_val->free) @@ -200,7 +158,7 @@ void hm_clear(struct hashmap *_map_) } memset(_map_->buffer, 0, sizeof(struct hashmap_entry) * _map_->capacity); _map_->count = 0; - _map_->flag = cmc_flags.OK; + _map_->flag = CMC_FLAG_OK; } void hm_free(struct hashmap *_map_) { @@ -247,7 +205,7 @@ void hm_customize(struct hashmap *_map_, struct cmc_alloc_node *alloc, else _map_->alloc = alloc; _map_->callbacks = callbacks; - _map_->flag = cmc_flags.OK; + _map_->flag = CMC_FLAG_OK; } _Bool hm_insert(struct hashmap *_map_, size_t key, size_t value) { @@ -258,7 +216,7 @@ _Bool hm_insert(struct hashmap *_map_, size_t key, size_t value) } if (hm_impl_get_entry(_map_, key) != ((void *)0)) { - _map_->flag = cmc_flags.DUPLICATE; + _map_->flag = CMC_FLAG_DUPLICATE; return 0; } size_t hash = _map_->f_key->hash(key); @@ -302,7 +260,7 @@ _Bool hm_insert(struct hashmap *_map_, size_t key, size_t value) } } _map_->count++; - _map_->flag = cmc_flags.OK; + _map_->flag = CMC_FLAG_OK; if (_map_->callbacks && _map_->callbacks->create) _map_->callbacks->create(); return 1; @@ -312,19 +270,19 @@ _Bool hm_update(struct hashmap *_map_, size_t key, size_t new_value, { if (hm_empty(_map_)) { - _map_->flag = cmc_flags.EMPTY; + _map_->flag = CMC_FLAG_EMPTY; return 0; } struct hashmap_entry *entry = hm_impl_get_entry(_map_, key); if (!entry) { - _map_->flag = cmc_flags.NOT_FOUND; + _map_->flag = CMC_FLAG_NOT_FOUND; return 0; } if (old_value) *old_value = entry->value; entry->value = new_value; - _map_->flag = cmc_flags.OK; + _map_->flag = CMC_FLAG_OK; if (_map_->callbacks && _map_->callbacks->update) _map_->callbacks->update(); return 1; @@ -333,13 +291,13 @@ _Bool hm_remove(struct hashmap *_map_, size_t key, size_t *out_value) { if (hm_empty(_map_)) { - _map_->flag = cmc_flags.EMPTY; + _map_->flag = CMC_FLAG_EMPTY; return 0; } struct hashmap_entry *result = hm_impl_get_entry(_map_, key); if (result == ((void *)0)) { - _map_->flag = cmc_flags.NOT_FOUND; + _map_->flag = CMC_FLAG_NOT_FOUND; return 0; } if (out_value) @@ -349,7 +307,7 @@ _Bool hm_remove(struct hashmap *_map_, size_t key, size_t *out_value) result->dist = 0; result->state = CMC_ES_DELETED; _map_->count--; - _map_->flag = cmc_flags.OK; + _map_->flag = CMC_FLAG_OK; if (_map_->callbacks && _map_->callbacks->delete) _map_->callbacks->delete (); return 1; @@ -358,7 +316,7 @@ _Bool hm_max(struct hashmap *_map_, size_t *key, size_t *value) { if (hm_empty(_map_)) { - _map_->flag = cmc_flags.EMPTY; + _map_->flag = CMC_FLAG_EMPTY; return 0; } struct hashmap_iter iter = hm_iter_start(_map_); @@ -387,7 +345,7 @@ _Bool hm_min(struct hashmap *_map_, size_t *key, size_t *value) { if (hm_empty(_map_)) { - _map_->flag = cmc_flags.EMPTY; + _map_->flag = CMC_FLAG_EMPTY; return 0; } struct hashmap_iter iter = hm_iter_start(_map_); @@ -416,16 +374,16 @@ size_t hm_get(struct hashmap *_map_, size_t key) { if (hm_empty(_map_)) { - _map_->flag = cmc_flags.EMPTY; + _map_->flag = CMC_FLAG_EMPTY; return 0; } struct hashmap_entry *entry = hm_impl_get_entry(_map_, key); if (!entry) { - _map_->flag = cmc_flags.NOT_FOUND; + _map_->flag = CMC_FLAG_NOT_FOUND; return (size_t){ 0 }; } - _map_->flag = cmc_flags.OK; + _map_->flag = CMC_FLAG_OK; if (_map_->callbacks && _map_->callbacks->read) _map_->callbacks->read(); return entry->value; @@ -434,23 +392,23 @@ size_t *hm_get_ref(struct hashmap *_map_, size_t key) { if (hm_empty(_map_)) { - _map_->flag = cmc_flags.EMPTY; + _map_->flag = CMC_FLAG_EMPTY; return 0; } struct hashmap_entry *entry = hm_impl_get_entry(_map_, key); if (!entry) { - _map_->flag = cmc_flags.NOT_FOUND; + _map_->flag = CMC_FLAG_NOT_FOUND; return ((void *)0); } - _map_->flag = cmc_flags.OK; + _map_->flag = CMC_FLAG_OK; if (_map_->callbacks && _map_->callbacks->read) _map_->callbacks->read(); return &(entry->value); } _Bool hm_contains(struct hashmap *_map_, size_t key) { - _map_->flag = cmc_flags.OK; + _map_->flag = CMC_FLAG_OK; _Bool result = hm_impl_get_entry(_map_, key) != ((void *)0); if (_map_->callbacks && _map_->callbacks->read) _map_->callbacks->read(); @@ -482,20 +440,20 @@ int hm_flag(struct hashmap *_map_) } _Bool hm_resize(struct hashmap *_map_, size_t capacity) { - _map_->flag = cmc_flags.OK; + _map_->flag = CMC_FLAG_OK; if (_map_->capacity == capacity) goto success; if (_map_->capacity > capacity / _map_->load) goto success; if (capacity >= 0xffffffffffffffffULL * _map_->load) { - _map_->flag = cmc_flags.ERROR; + _map_->flag = CMC_FLAG_ERROR; return 0; } size_t theoretical_size = hm_impl_calculate_size(capacity); if (theoretical_size < _map_->count / _map_->load) { - _map_->flag = cmc_flags.INVALID; + _map_->flag = CMC_FLAG_INVALID; return 0; } struct hashmap *_new_map_ = @@ -503,7 +461,7 @@ _Bool hm_resize(struct hashmap *_map_, size_t capacity) _map_->alloc, ((void *)0)); if (!_new_map_) { - _map_->flag = cmc_flags.ALLOC; + _map_->flag = CMC_FLAG_ALLOC; return 0; } struct hashmap_iter iter = hm_iter_start(_map_); @@ -516,7 +474,7 @@ _Bool hm_resize(struct hashmap *_map_, size_t capacity) if (_map_->count != _new_map_->count) { hm_free(_new_map_); - _map_->flag = cmc_flags.ERROR; + _map_->flag = CMC_FLAG_ERROR; return 0; } struct hashmap_entry *tmp_b = _map_->buffer; @@ -540,7 +498,7 @@ struct hashmap *hm_copy_of(struct hashmap *_map_) _map_->f_val, _map_->alloc, _map_->callbacks); if (!result) { - _map_->flag = cmc_flags.ERROR; + _map_->flag = CMC_FLAG_ERROR; return ((void *)0); } if (_map_->f_key->cpy || _map_->f_val->cpy) @@ -573,13 +531,13 @@ struct hashmap *hm_copy_of(struct hashmap *_map_) memcpy(result->buffer, _map_->buffer, sizeof(struct hashmap_entry) * _map_->capacity); result->count = _map_->count; - _map_->flag = cmc_flags.OK; + _map_->flag = CMC_FLAG_OK; return result; } _Bool hm_equals(struct hashmap *_map1_, struct hashmap *_map2_) { - _map1_->flag = cmc_flags.OK; - _map2_->flag = cmc_flags.OK; + _map1_->flag = CMC_FLAG_OK; + _map2_->flag = CMC_FLAG_OK; if (_map1_->count != _map2_->count) return 0; struct hashmap_iter iter = hm_iter_start(_map1_); @@ -598,10 +556,12 @@ struct cmc_string hm_to_string(struct hashmap *_map_) { struct cmc_string str; struct hashmap *m_ = _map_; - int n = snprintf(str.s, cmc_string_len, cmc_string_fmt_hashmap, "hashmap", - "size_t", "size_t", m_, m_->buffer, m_->capacity, - m_->count, m_->load, m_->flag, m_->f_key, m_->f_val, - m_->alloc, m_->callbacks); + int n = snprintf(str.s, cmc_string_len, cmc_cmc_string_fmt_hashmap, + "CMC_PARAM_SNAME((hm, hashmap, , size_t, size_t))", + "CMC_PARAM_K((hm, hashmap, , size_t, size_t))", + "CMC_PARAM_V((hm, hashmap, , size_t, size_t))", m_, + m_->buffer, m_->capacity, m_->count, m_->load, m_->flag, + m_->f_key, m_->f_val, m_->alloc, m_->callbacks); return n >= 0 ? str : (struct cmc_string){ 0 }; } _Bool hm_print(struct hashmap *_map_, FILE *fptr) diff --git a/tests/main/src/hashmultimap.c b/tests/main/src/hashmultimap.c index ac1471e..ae280f9 100644 --- a/tests/main/src/hashmultimap.c +++ b/tests/main/src/hashmultimap.c @@ -134,7 +134,7 @@ struct hashmultimap *hmm_new(size_t capacity, double load, _map_->count = 0; _map_->capacity = real_capacity; _map_->load = load; - _map_->flag = cmc_flags.OK; + _map_->flag = CMC_FLAG_OK; _map_->f_key = f_key; _map_->f_val = f_val; _map_->alloc = alloc; @@ -169,7 +169,7 @@ struct hashmultimap *hmm_new_custom(size_t capacity, double load, _map_->count = 0; _map_->capacity = real_capacity; _map_->load = load; - _map_->flag = cmc_flags.OK; + _map_->flag = CMC_FLAG_OK; _map_->f_key = f_key; _map_->f_val = f_val; _map_->alloc = alloc; @@ -195,7 +195,7 @@ void hmm_clear(struct hashmultimap *_map_) memset(_map_->buffer, 0, sizeof(struct hashmultimap_entry *[2]) * _map_->capacity); _map_->count = 0; - _map_->flag = cmc_flags.OK; + _map_->flag = CMC_FLAG_OK; } void hmm_free(struct hashmultimap *_map_) { @@ -240,7 +240,7 @@ void hmm_customize(struct hashmultimap *_map_, struct cmc_alloc_node *alloc, else _map_->alloc = alloc; _map_->callbacks = callbacks; - _map_->flag = cmc_flags.OK; + _map_->flag = CMC_FLAG_OK; } _Bool hmm_insert(struct hashmultimap *_map_, size_t key, size_t value) { @@ -264,7 +264,7 @@ _Bool hmm_insert(struct hashmultimap *_map_, size_t key, size_t value) _map_->buffer[pos][1] = entry; } _map_->count++; - _map_->flag = cmc_flags.OK; + _map_->flag = CMC_FLAG_OK; if (_map_->callbacks && _map_->callbacks->create) _map_->callbacks->create(); return 1; @@ -274,19 +274,19 @@ _Bool hmm_update(struct hashmultimap *_map_, size_t key, size_t new_value, { if (hmm_empty(_map_)) { - _map_->flag = cmc_flags.EMPTY; + _map_->flag = CMC_FLAG_EMPTY; return 0; } struct hashmultimap_entry *entry = hmm_impl_get_entry(_map_, key); if (!entry) { - _map_->flag = cmc_flags.NOT_FOUND; + _map_->flag = CMC_FLAG_NOT_FOUND; return 0; } if (old_value) *old_value = entry->value; entry->value = new_value; - _map_->flag = cmc_flags.OK; + _map_->flag = CMC_FLAG_OK; if (_map_->callbacks && _map_->callbacks->update) _map_->callbacks->update(); return 1; @@ -296,14 +296,14 @@ size_t hmm_update_all(struct hashmultimap *_map_, size_t key, size_t new_value, { if (hmm_empty(_map_)) { - _map_->flag = cmc_flags.EMPTY; + _map_->flag = CMC_FLAG_EMPTY; return 0; } size_t hash = _map_->f_key->hash(key); struct hashmultimap_entry *entry = _map_->buffer[hash % _map_->capacity][0]; if (entry == ((void *)0)) { - _map_->flag = cmc_flags.NOT_FOUND; + _map_->flag = CMC_FLAG_NOT_FOUND; return 0; } if (old_values) @@ -311,13 +311,13 @@ size_t hmm_update_all(struct hashmultimap *_map_, size_t key, size_t new_value, size_t total = hmm_impl_key_count(_map_, key); if (total == 0) { - _map_->flag = cmc_flags.NOT_FOUND; + _map_->flag = CMC_FLAG_NOT_FOUND; return 0; } *old_values = _map_->alloc->malloc(sizeof(size_t) * total); if (!(*old_values)) { - _map_->flag = cmc_flags.ALLOC; + _map_->flag = CMC_FLAG_ALLOC; return 0; } } @@ -333,7 +333,7 @@ size_t hmm_update_all(struct hashmultimap *_map_, size_t key, size_t new_value, } entry = entry->next; } - _map_->flag = cmc_flags.OK; + _map_->flag = CMC_FLAG_OK; if (_map_->callbacks && _map_->callbacks->update) _map_->callbacks->update(); return index; @@ -342,7 +342,7 @@ _Bool hmm_remove(struct hashmultimap *_map_, size_t key, size_t *out_value) { if (hmm_empty(_map_)) { - _map_->flag = cmc_flags.EMPTY; + _map_->flag = CMC_FLAG_EMPTY; return 0; } size_t hash = _map_->f_key->hash(key); @@ -352,7 +352,7 @@ _Bool hmm_remove(struct hashmultimap *_map_, size_t key, size_t *out_value) &(_map_->buffer[hash % _map_->capacity][1]); if (*head == ((void *)0)) { - _map_->flag = cmc_flags.NOT_FOUND; + _map_->flag = CMC_FLAG_NOT_FOUND; return 0; } struct hashmultimap_entry *entry = *head; @@ -367,7 +367,7 @@ _Bool hmm_remove(struct hashmultimap *_map_, size_t key, size_t *out_value) } else { - _map_->flag = cmc_flags.NOT_FOUND; + _map_->flag = CMC_FLAG_NOT_FOUND; return 0; } } @@ -396,13 +396,13 @@ _Bool hmm_remove(struct hashmultimap *_map_, size_t key, size_t *out_value) } if (!found) { - _map_->flag = cmc_flags.NOT_FOUND; + _map_->flag = CMC_FLAG_NOT_FOUND; return 0; } } _map_->alloc->free(entry); _map_->count--; - _map_->flag = cmc_flags.OK; + _map_->flag = CMC_FLAG_OK; if (_map_->callbacks && _map_->callbacks->delete) _map_->callbacks->delete (); return 1; @@ -412,7 +412,7 @@ size_t hmm_remove_all(struct hashmultimap *_map_, size_t key, { if (hmm_empty(_map_)) { - _map_->flag = cmc_flags.EMPTY; + _map_->flag = CMC_FLAG_EMPTY; return 0; } size_t hash = _map_->f_key->hash(key); @@ -422,7 +422,7 @@ size_t hmm_remove_all(struct hashmultimap *_map_, size_t key, &(_map_->buffer[hash % _map_->capacity][1]); if (*head == ((void *)0)) { - _map_->flag = cmc_flags.NOT_FOUND; + _map_->flag = CMC_FLAG_NOT_FOUND; return 0; } if (out_values) @@ -430,13 +430,13 @@ size_t hmm_remove_all(struct hashmultimap *_map_, size_t key, size_t total = hmm_impl_key_count(_map_, key); if (total == 0) { - _map_->flag = cmc_flags.NOT_FOUND; + _map_->flag = CMC_FLAG_NOT_FOUND; return 0; } *out_values = _map_->alloc->malloc(sizeof(size_t) * total); if (!(*out_values)) { - _map_->flag = cmc_flags.ALLOC; + _map_->flag = CMC_FLAG_ALLOC; return 0; } } @@ -477,7 +477,7 @@ size_t hmm_remove_all(struct hashmultimap *_map_, size_t key, } } _map_->count -= index; - _map_->flag = cmc_flags.OK; + _map_->flag = CMC_FLAG_OK; if (_map_->callbacks && _map_->callbacks->delete) _map_->callbacks->delete (); return index; @@ -486,7 +486,7 @@ _Bool hmm_max(struct hashmultimap *_map_, size_t *key, size_t *value) { if (hmm_empty(_map_)) { - _map_->flag = cmc_flags.EMPTY; + _map_->flag = CMC_FLAG_EMPTY; return 0; } size_t max_key; @@ -512,7 +512,7 @@ _Bool hmm_max(struct hashmultimap *_map_, size_t *key, size_t *value) *key = max_key; if (value) *value = max_val; - _map_->flag = cmc_flags.OK; + _map_->flag = CMC_FLAG_OK; if (_map_->callbacks && _map_->callbacks->read) _map_->callbacks->read(); return 1; @@ -521,7 +521,7 @@ _Bool hmm_min(struct hashmultimap *_map_, size_t *key, size_t *value) { if (hmm_empty(_map_)) { - _map_->flag = cmc_flags.EMPTY; + _map_->flag = CMC_FLAG_EMPTY; return 0; } size_t min_key; @@ -547,7 +547,7 @@ _Bool hmm_min(struct hashmultimap *_map_, size_t *key, size_t *value) *key = min_key; if (value) *value = min_val; - _map_->flag = cmc_flags.OK; + _map_->flag = CMC_FLAG_OK; if (_map_->callbacks && _map_->callbacks->read) _map_->callbacks->read(); return 1; @@ -556,16 +556,16 @@ size_t hmm_get(struct hashmultimap *_map_, size_t key) { if (hmm_empty(_map_)) { - _map_->flag = cmc_flags.EMPTY; + _map_->flag = CMC_FLAG_EMPTY; return 0; } struct hashmultimap_entry *entry = hmm_impl_get_entry(_map_, key); if (!entry) { - _map_->flag = cmc_flags.NOT_FOUND; + _map_->flag = CMC_FLAG_NOT_FOUND; return (size_t){ 0 }; } - _map_->flag = cmc_flags.OK; + _map_->flag = CMC_FLAG_OK; if (_map_->callbacks && _map_->callbacks->read) _map_->callbacks->read(); return entry->value; @@ -574,23 +574,23 @@ size_t *hmm_get_ref(struct hashmultimap *_map_, size_t key) { if (hmm_empty(_map_)) { - _map_->flag = cmc_flags.EMPTY; + _map_->flag = CMC_FLAG_EMPTY; return 0; } struct hashmultimap_entry *entry = hmm_impl_get_entry(_map_, key); if (!entry) { - _map_->flag = cmc_flags.NOT_FOUND; + _map_->flag = CMC_FLAG_NOT_FOUND; return ((void *)0); } - _map_->flag = cmc_flags.OK; + _map_->flag = CMC_FLAG_OK; if (_map_->callbacks && _map_->callbacks->read) _map_->callbacks->read(); return &(entry->value); } _Bool hmm_contains(struct hashmultimap *_map_, size_t key) { - _map_->flag = cmc_flags.OK; + _map_->flag = CMC_FLAG_OK; _Bool result = hmm_impl_get_entry(_map_, key) != ((void *)0); if (_map_->callbacks && _map_->callbacks->read) _map_->callbacks->read(); @@ -626,20 +626,20 @@ int hmm_flag(struct hashmultimap *_map_) } _Bool hmm_resize(struct hashmultimap *_map_, size_t capacity) { - _map_->flag = cmc_flags.OK; + _map_->flag = CMC_FLAG_OK; if (_map_->capacity == capacity) goto success; if (_map_->capacity > capacity / _map_->load) goto success; if (capacity >= 0xffffffffffffffffULL * _map_->load) { - _map_->flag = cmc_flags.ERROR; + _map_->flag = CMC_FLAG_ERROR; return 0; } size_t theoretical_size = hmm_impl_calculate_size(capacity); if (theoretical_size < _map_->count / _map_->load) { - _map_->flag = cmc_flags.INVALID; + _map_->flag = CMC_FLAG_INVALID; return 0; } struct hashmultimap *_new_map_ = @@ -647,7 +647,7 @@ _Bool hmm_resize(struct hashmultimap *_map_, size_t capacity) _map_->alloc, ((void *)0)); if (!_new_map_) { - _map_->flag = cmc_flags.ALLOC; + _map_->flag = CMC_FLAG_ALLOC; return 0; } struct hashmultimap_iter iter = hmm_iter_start(_map_); @@ -660,7 +660,7 @@ _Bool hmm_resize(struct hashmultimap *_map_, size_t capacity) if (_map_->count != _new_map_->count) { hmm_free(_new_map_); - _map_->flag = cmc_flags.ERROR; + _map_->flag = CMC_FLAG_ERROR; return 0; } struct hashmultimap_entry *(*tmp_b)[2] = _map_->buffer; @@ -684,7 +684,7 @@ struct hashmultimap *hmm_copy_of(struct hashmultimap *_map_) _map_->f_val, _map_->alloc, ((void *)0)); if (!result) { - _map_->flag = cmc_flags.ERROR; + _map_->flag = CMC_FLAG_ERROR; return ((void *)0); } struct hashmultimap_iter iter = hmm_iter_start(_map_); @@ -702,13 +702,13 @@ struct hashmultimap *hmm_copy_of(struct hashmultimap *_map_) } } result->callbacks = _map_->callbacks; - _map_->flag = cmc_flags.OK; + _map_->flag = CMC_FLAG_OK; return result; } _Bool hmm_equals(struct hashmultimap *_map1_, struct hashmultimap *_map2_) { - _map1_->flag = cmc_flags.OK; - _map2_->flag = cmc_flags.OK; + _map1_->flag = CMC_FLAG_OK; + _map2_->flag = CMC_FLAG_OK; if (_map1_->count != _map2_->count) return 0; struct hashmultimap_iter iter = hmm_iter_start(_map1_); @@ -724,10 +724,12 @@ struct cmc_string hmm_to_string(struct hashmultimap *_map_) { struct cmc_string str; struct hashmultimap *m_ = _map_; - int n = snprintf(str.s, cmc_string_len, cmc_string_fmt_hashmultimap, - "hashmultimap", "size_t", "size_t", m_, m_->buffer, - m_->capacity, m_->count, m_->load, m_->flag, m_->f_key, - m_->f_val, m_->alloc, m_->callbacks); + int n = snprintf(str.s, cmc_string_len, cmc_cmc_string_fmt_hashmultimap, + "CMC_PARAM_SNAME((hmm, hashmultimap, , size_t, size_t))", + "CMC_PARAM_K((hmm, hashmultimap, , size_t, size_t))", + "CMC_PARAM_V((hmm, hashmultimap, , size_t, size_t))", m_, + m_->buffer, m_->capacity, m_->count, m_->load, m_->flag, + m_->f_key, m_->f_val, m_->alloc, m_->callbacks); return n >= 0 ? str : (struct cmc_string){ 0 }; } _Bool hmm_print(struct hashmultimap *_map_, FILE *fptr) diff --git a/tests/main/src/hashmultiset.c b/tests/main/src/hashmultiset.c index f51a4d0..1da5571 100644 --- a/tests/main/src/hashmultiset.c +++ b/tests/main/src/hashmultiset.c @@ -137,7 +137,7 @@ struct hashmultiset *hms_new(size_t capacity, double load, _set_->cardinality = 0; _set_->capacity = real_capacity; _set_->load = load; - _set_->flag = cmc_flags.OK; + _set_->flag = CMC_FLAG_OK; _set_->f_val = f_val; _set_->alloc = alloc; _set_->callbacks = ((void *)0); @@ -171,7 +171,7 @@ struct hashmultiset *hms_new_custom(size_t capacity, double load, _set_->cardinality = 0; _set_->capacity = real_capacity; _set_->load = load; - _set_->flag = cmc_flags.OK; + _set_->flag = CMC_FLAG_OK; _set_->f_val = f_val; _set_->alloc = alloc; _set_->callbacks = callbacks; @@ -193,7 +193,7 @@ void hms_clear(struct hashmultiset *_set_) memset(_set_->buffer, 0, sizeof(struct hashmultiset_entry) * _set_->capacity); _set_->count = 0; - _set_->flag = cmc_flags.OK; + _set_->flag = CMC_FLAG_OK; } void hms_free(struct hashmultiset *_set_) { @@ -219,7 +219,7 @@ void hms_customize(struct hashmultiset *_set_, struct cmc_alloc_node *alloc, else _set_->alloc = alloc; _set_->callbacks = callbacks; - _set_->flag = cmc_flags.OK; + _set_->flag = CMC_FLAG_OK; } _Bool hms_insert(struct hashmultiset *_set_, size_t value) { @@ -228,13 +228,13 @@ _Bool hms_insert(struct hashmultiset *_set_, size_t value) hms_impl_insert_and_return(_set_, value, &new_node); if (!entry) { - _set_->flag = cmc_flags.ERROR; + _set_->flag = CMC_FLAG_ERROR; return 0; } if (!new_node) entry->multiplicity++; _set_->cardinality++; - _set_->flag = cmc_flags.OK; + _set_->flag = CMC_FLAG_OK; if (_set_->callbacks && _set_->callbacks->create) _set_->callbacks->create(); return 1; @@ -248,7 +248,7 @@ _Bool hms_insert_many(struct hashmultiset *_set_, size_t value, size_t count) hms_impl_insert_and_return(_set_, value, &new_node); if (!entry) { - _set_->flag = cmc_flags.ERROR; + _set_->flag = CMC_FLAG_ERROR; return 0; } if (new_node) @@ -257,7 +257,7 @@ _Bool hms_insert_many(struct hashmultiset *_set_, size_t value, size_t count) entry->multiplicity += count; _set_->cardinality += count; success: - _set_->flag = cmc_flags.OK; + _set_->flag = CMC_FLAG_OK; if (_set_->callbacks && _set_->callbacks->create) _set_->callbacks->create(); return 1; @@ -288,7 +288,7 @@ _Bool hms_update(struct hashmultiset *_set_, size_t value, size_t multiplicity) (_set_->cardinality - entry->multiplicity) + multiplicity; entry->multiplicity = multiplicity; success: - _set_->flag = cmc_flags.OK; + _set_->flag = CMC_FLAG_OK; if (_set_->callbacks && _set_->callbacks->update) _set_->callbacks->update(); return 1; @@ -297,13 +297,13 @@ _Bool hms_remove(struct hashmultiset *_set_, size_t value) { if (hms_empty(_set_)) { - _set_->flag = cmc_flags.EMPTY; + _set_->flag = CMC_FLAG_EMPTY; return 0; } struct hashmultiset_entry *result = hms_impl_get_entry(_set_, value); if (!result) { - _set_->flag = cmc_flags.NOT_FOUND; + _set_->flag = CMC_FLAG_NOT_FOUND; return 0; } if (result->multiplicity > 1) @@ -317,7 +317,7 @@ _Bool hms_remove(struct hashmultiset *_set_, size_t value) _set_->count--; } _set_->cardinality--; - _set_->flag = cmc_flags.OK; + _set_->flag = CMC_FLAG_OK; if (_set_->callbacks && _set_->callbacks->delete) _set_->callbacks->delete (); return 1; @@ -326,13 +326,13 @@ size_t hms_remove_all(struct hashmultiset *_set_, size_t value) { if (hms_empty(_set_)) { - _set_->flag = cmc_flags.EMPTY; + _set_->flag = CMC_FLAG_EMPTY; return 0; } struct hashmultiset_entry *result = hms_impl_get_entry(_set_, value); if (!result) { - _set_->flag = cmc_flags.NOT_FOUND; + _set_->flag = CMC_FLAG_NOT_FOUND; return 0; } size_t removed = result->multiplicity; @@ -342,7 +342,7 @@ size_t hms_remove_all(struct hashmultiset *_set_, size_t value) result->state = CMC_ES_DELETED; _set_->count--; _set_->cardinality -= removed; - _set_->flag = cmc_flags.OK; + _set_->flag = CMC_FLAG_OK; if (_set_->callbacks && _set_->callbacks->delete) _set_->callbacks->delete (); return removed; @@ -351,7 +351,7 @@ _Bool hms_max(struct hashmultiset *_set_, size_t *value) { if (hms_empty(_set_)) { - _set_->flag = cmc_flags.EMPTY; + _set_->flag = CMC_FLAG_EMPTY; return 0; } size_t max_val; @@ -367,7 +367,7 @@ _Bool hms_max(struct hashmultiset *_set_, size_t *value) } if (value) *value = max_val; - _set_->flag = cmc_flags.OK; + _set_->flag = CMC_FLAG_OK; if (_set_->callbacks && _set_->callbacks->read) _set_->callbacks->read(); return 1; @@ -376,7 +376,7 @@ _Bool hms_min(struct hashmultiset *_set_, size_t *value) { if (hms_empty(_set_)) { - _set_->flag = cmc_flags.EMPTY; + _set_->flag = CMC_FLAG_EMPTY; return 0; } size_t min_val; @@ -392,7 +392,7 @@ _Bool hms_min(struct hashmultiset *_set_, size_t *value) } if (value) *value = min_val; - _set_->flag = cmc_flags.OK; + _set_->flag = CMC_FLAG_OK; if (_set_->callbacks && _set_->callbacks->read) _set_->callbacks->read(); return 1; @@ -400,7 +400,7 @@ _Bool hms_min(struct hashmultiset *_set_, size_t *value) size_t hms_multiplicity_of(struct hashmultiset *_set_, size_t value) { struct hashmultiset_entry *entry = hms_impl_get_entry(_set_, value); - _set_->flag = cmc_flags.OK; + _set_->flag = CMC_FLAG_OK; if (_set_->callbacks && _set_->callbacks->read) _set_->callbacks->read(); if (!entry) @@ -409,7 +409,7 @@ size_t hms_multiplicity_of(struct hashmultiset *_set_, size_t value) } _Bool hms_contains(struct hashmultiset *_set_, size_t value) { - _set_->flag = cmc_flags.OK; + _set_->flag = CMC_FLAG_OK; _Bool result = hms_impl_get_entry(_set_, value) != ((void *)0); if (_set_->callbacks && _set_->callbacks->read) _set_->callbacks->read(); @@ -445,27 +445,27 @@ int hms_flag(struct hashmultiset *_set_) } _Bool hms_resize(struct hashmultiset *_set_, size_t capacity) { - _set_->flag = cmc_flags.OK; + _set_->flag = CMC_FLAG_OK; if (_set_->capacity == capacity) goto success; if (_set_->capacity > capacity / _set_->load) goto success; if (capacity >= 0xffffffffffffffffULL * _set_->load) { - _set_->flag = cmc_flags.ERROR; + _set_->flag = CMC_FLAG_ERROR; return 0; } size_t theoretical_size = hms_impl_calculate_size(capacity); if (theoretical_size < _set_->count / _set_->load) { - _set_->flag = cmc_flags.INVALID; + _set_->flag = CMC_FLAG_INVALID; return 0; } struct hashmultiset *_new_set_ = hms_new_custom( capacity, _set_->load, _set_->f_val, _set_->alloc, ((void *)0)); if (!_new_set_) { - _set_->flag = cmc_flags.ERROR; + _set_->flag = CMC_FLAG_ERROR; return 0; } struct hashmultiset_iter iter = hms_iter_start(_set_); @@ -477,7 +477,7 @@ _Bool hms_resize(struct hashmultiset *_set_, size_t capacity) if (_set_->count != _new_set_->count) { hms_free(_new_set_); - _set_->flag = cmc_flags.ERROR; + _set_->flag = CMC_FLAG_ERROR; return 0; } struct hashmultiset_entry *tmp_b = _set_->buffer; @@ -500,7 +500,7 @@ struct hashmultiset *hms_copy_of(struct hashmultiset *_set_) _set_->alloc, _set_->callbacks); if (!result) { - _set_->flag = cmc_flags.ERROR; + _set_->flag = CMC_FLAG_ERROR; return ((void *)0); } if (_set_->f_val->cpy) @@ -528,13 +528,13 @@ struct hashmultiset *hms_copy_of(struct hashmultiset *_set_) sizeof(struct hashmultiset_entry) * _set_->capacity); result->count = _set_->count; result->cardinality = _set_->cardinality; - _set_->flag = cmc_flags.OK; + _set_->flag = CMC_FLAG_OK; return result; } _Bool hms_equals(struct hashmultiset *_set1_, struct hashmultiset *_set2_) { - _set1_->flag = cmc_flags.OK; - _set2_->flag = cmc_flags.OK; + _set1_->flag = CMC_FLAG_OK; + _set2_->flag = CMC_FLAG_OK; if (_set1_->count != _set2_->count) return 0; if (_set1_->cardinality != _set2_->cardinality) @@ -557,10 +557,11 @@ struct cmc_string hms_to_string(struct hashmultiset *_set_) { struct cmc_string str; struct hashmultiset *s_ = _set_; - int n = snprintf(str.s, cmc_string_len, cmc_string_fmt_hashmultiset, - "hashmultiset", "size_t", s_, s_->buffer, s_->capacity, - s_->count, s_->cardinality, s_->load, s_->flag, s_->f_val, - s_->alloc, s_->callbacks); + int n = snprintf(str.s, cmc_string_len, cmc_cmc_string_fmt_hashmultiset, + "CMC_PARAM_SNAME((hms, hashmultiset, , , size_t))", + "CMC_PARAM_V((hms, hashmultiset, , , size_t))", s_, + s_->buffer, s_->capacity, s_->count, s_->cardinality, + s_->load, s_->flag, s_->f_val, s_->alloc, s_->callbacks); return n >= 0 ? str : (struct cmc_string){ 0 }; } _Bool hms_print(struct hashmultiset *_set_, FILE *fptr) diff --git a/tests/main/src/hashset.c b/tests/main/src/hashset.c index 856920d..4f39d25 100644 --- a/tests/main/src/hashset.c +++ b/tests/main/src/hashset.c @@ -115,7 +115,7 @@ struct hashset *hs_new(size_t capacity, double load, struct hashset_fval *f_val) _set_->count = 0; _set_->capacity = real_capacity; _set_->load = load; - _set_->flag = cmc_flags.OK; + _set_->flag = CMC_FLAG_OK; _set_->f_val = f_val; _set_->alloc = alloc; _set_->callbacks = ((void *)0); @@ -147,7 +147,7 @@ struct hashset *hs_new_custom(size_t capacity, double load, _set_->count = 0; _set_->capacity = real_capacity; _set_->load = load; - _set_->flag = cmc_flags.OK; + _set_->flag = CMC_FLAG_OK; _set_->f_val = f_val; _set_->alloc = alloc; _set_->callbacks = callbacks; @@ -168,7 +168,7 @@ void hs_clear(struct hashset *_set_) } memset(_set_->buffer, 0, sizeof(struct hashset_entry) * _set_->capacity); _set_->count = 0; - _set_->flag = cmc_flags.OK; + _set_->flag = CMC_FLAG_OK; } void hs_free(struct hashset *_set_) { @@ -194,7 +194,7 @@ void hs_customize(struct hashset *_set_, struct cmc_alloc_node *alloc, else _set_->alloc = alloc; _set_->callbacks = callbacks; - _set_->flag = cmc_flags.OK; + _set_->flag = CMC_FLAG_OK; } _Bool hs_insert(struct hashset *_set_, size_t value) { @@ -205,7 +205,7 @@ _Bool hs_insert(struct hashset *_set_, size_t value) } if (hs_impl_get_entry(_set_, value) != ((void *)0)) { - _set_->flag = cmc_flags.DUPLICATE; + _set_->flag = CMC_FLAG_DUPLICATE; return 0; } size_t hash = _set_->f_val->hash(value); @@ -244,7 +244,7 @@ _Bool hs_insert(struct hashset *_set_, size_t value) } } _set_->count++; - _set_->flag = cmc_flags.OK; + _set_->flag = CMC_FLAG_OK; if (_set_->callbacks && _set_->callbacks->create) _set_->callbacks->create(); return 1; @@ -253,20 +253,20 @@ _Bool hs_remove(struct hashset *_set_, size_t value) { if (hs_empty(_set_)) { - _set_->flag = cmc_flags.EMPTY; + _set_->flag = CMC_FLAG_EMPTY; return 0; } struct hashset_entry *result = hs_impl_get_entry(_set_, value); if (result == ((void *)0)) { - _set_->flag = cmc_flags.NOT_FOUND; + _set_->flag = CMC_FLAG_NOT_FOUND; return 0; } result->value = (size_t){ 0 }; result->dist = 0; result->state = CMC_ES_DELETED; _set_->count--; - _set_->flag = cmc_flags.OK; + _set_->flag = CMC_FLAG_OK; if (_set_->callbacks && _set_->callbacks->delete) _set_->callbacks->delete (); return 1; @@ -275,7 +275,7 @@ _Bool hs_max(struct hashset *_set_, size_t *value) { if (hs_empty(_set_)) { - _set_->flag = cmc_flags.EMPTY; + _set_->flag = CMC_FLAG_EMPTY; return 0; } size_t max_value; @@ -291,7 +291,7 @@ _Bool hs_max(struct hashset *_set_, size_t *value) } if (value) *value = max_value; - _set_->flag = cmc_flags.OK; + _set_->flag = CMC_FLAG_OK; if (_set_->callbacks && _set_->callbacks->read) _set_->callbacks->read(); return 1; @@ -300,7 +300,7 @@ _Bool hs_min(struct hashset *_set_, size_t *value) { if (hs_empty(_set_)) { - _set_->flag = cmc_flags.EMPTY; + _set_->flag = CMC_FLAG_EMPTY; return 0; } size_t min_value; @@ -316,14 +316,14 @@ _Bool hs_min(struct hashset *_set_, size_t *value) } if (value) *value = min_value; - _set_->flag = cmc_flags.OK; + _set_->flag = CMC_FLAG_OK; if (_set_->callbacks && _set_->callbacks->read) _set_->callbacks->read(); return 1; } _Bool hs_contains(struct hashset *_set_, size_t value) { - _set_->flag = cmc_flags.OK; + _set_->flag = CMC_FLAG_OK; _Bool result = hs_impl_get_entry(_set_, value) != ((void *)0); if (_set_->callbacks && _set_->callbacks->read) _set_->callbacks->read(); @@ -355,27 +355,27 @@ int hs_flag(struct hashset *_set_) } _Bool hs_resize(struct hashset *_set_, size_t capacity) { - _set_->flag = cmc_flags.OK; + _set_->flag = CMC_FLAG_OK; if (_set_->capacity == capacity) goto success; if (_set_->capacity > capacity / _set_->load) goto success; if (capacity >= 0xffffffffffffffffULL * _set_->load) { - _set_->flag = cmc_flags.ERROR; + _set_->flag = CMC_FLAG_ERROR; return 0; } size_t theoretical_size = hs_impl_calculate_size(capacity); if (theoretical_size < _set_->count / _set_->load) { - _set_->flag = cmc_flags.INVALID; + _set_->flag = CMC_FLAG_INVALID; return 0; } struct hashset *_new_set_ = hs_new_custom( capacity, _set_->load, _set_->f_val, _set_->alloc, ((void *)0)); if (!_new_set_) { - _set_->flag = cmc_flags.ALLOC; + _set_->flag = CMC_FLAG_ALLOC; return 0; } struct hashset_iter iter = hs_iter_start(_set_); @@ -387,7 +387,7 @@ _Bool hs_resize(struct hashset *_set_, size_t capacity) if (_set_->count != _new_set_->count) { hs_free(_new_set_); - _set_->flag = cmc_flags.ERROR; + _set_->flag = CMC_FLAG_ERROR; return 0; } struct hashset_entry *tmp_b = _set_->buffer; @@ -410,7 +410,7 @@ struct hashset *hs_copy_of(struct hashset *_set_) _set_->alloc, _set_->callbacks); if (!result) { - _set_->flag = cmc_flags.ERROR; + _set_->flag = CMC_FLAG_ERROR; return ((void *)0); } if (_set_->f_val->cpy) @@ -436,13 +436,13 @@ struct hashset *hs_copy_of(struct hashset *_set_) memcpy(result->buffer, _set_->buffer, sizeof(struct hashset_entry) * _set_->capacity); result->count = _set_->count; - _set_->flag = cmc_flags.OK; + _set_->flag = CMC_FLAG_OK; return result; } _Bool hs_equals(struct hashset *_set1_, struct hashset *_set2_) { - _set1_->flag = cmc_flags.OK; - _set2_->flag = cmc_flags.OK; + _set1_->flag = CMC_FLAG_OK; + _set2_->flag = CMC_FLAG_OK; if (_set1_->count != _set2_->count) return 0; if (_set1_->count == 0) @@ -459,9 +459,11 @@ struct cmc_string hs_to_string(struct hashset *_set_) { struct cmc_string str; struct hashset *s_ = _set_; - int n = snprintf(str.s, cmc_string_len, cmc_string_fmt_hashset, "hashset", - "size_t", s_, s_->buffer, s_->capacity, s_->count, - s_->load, s_->flag, s_->f_val, s_->alloc, s_->callbacks); + int n = snprintf(str.s, cmc_string_len, cmc_cmc_string_fmt_hashset, + "CMC_PARAM_SNAME((hs, hashset, , , size_t))", + "CMC_PARAM_V((hs, hashset, , , size_t))", s_, s_->buffer, + s_->capacity, s_->count, s_->load, s_->flag, s_->f_val, + s_->alloc, s_->callbacks); return n >= 0 ? str : (struct cmc_string){ 0 }; } _Bool hs_print(struct hashset *_set_, FILE *fptr) @@ -484,8 +486,8 @@ struct hashset *hs_union(struct hashset *_set1_, struct hashset *_set2_) _set1_->alloc, ((void *)0)); if (!_set_r_) { - _set1_->flag = cmc_flags.ALLOC; - _set2_->flag = cmc_flags.ALLOC; + _set1_->flag = CMC_FLAG_ALLOC; + _set2_->flag = CMC_FLAG_ALLOC; return ((void *)0); } struct hashset_iter iter1 = hs_iter_start(_set1_); @@ -508,8 +510,8 @@ struct hashset *hs_intersection(struct hashset *_set1_, struct hashset *_set2_) _set1_->alloc, ((void *)0)); if (!_set_r_) { - _set1_->flag = cmc_flags.ALLOC; - _set2_->flag = cmc_flags.ALLOC; + _set1_->flag = CMC_FLAG_ALLOC; + _set2_->flag = CMC_FLAG_ALLOC; return ((void *)0); } struct hashset *_set_A_ = _set1_->count < _set2_->count ? _set1_ : _set2_; @@ -531,8 +533,8 @@ struct hashset *hs_difference(struct hashset *_set1_, struct hashset *_set2_) _set1_->alloc, ((void *)0)); if (!_set_r_) { - _set1_->flag = cmc_flags.ALLOC; - _set2_->flag = cmc_flags.ALLOC; + _set1_->flag = CMC_FLAG_ALLOC; + _set2_->flag = CMC_FLAG_ALLOC; return ((void *)0); } struct hashset_iter iter = hs_iter_start(_set1_); @@ -553,8 +555,8 @@ struct hashset *hs_symmetric_difference(struct hashset *_set1_, _set1_->alloc, ((void *)0)); if (!_set_r_) { - _set1_->flag = cmc_flags.ALLOC; - _set2_->flag = cmc_flags.ALLOC; + _set1_->flag = CMC_FLAG_ALLOC; + _set2_->flag = CMC_FLAG_ALLOC; return ((void *)0); } struct hashset_iter iter1 = hs_iter_start(_set1_); @@ -576,8 +578,8 @@ struct hashset *hs_symmetric_difference(struct hashset *_set1_, } _Bool hs_is_subset(struct hashset *_set1_, struct hashset *_set2_) { - _set1_->flag = cmc_flags.OK; - _set2_->flag = cmc_flags.OK; + _set1_->flag = CMC_FLAG_OK; + _set2_->flag = CMC_FLAG_OK; if (_set1_->count > _set2_->count) return 0; if (hs_empty(_set1_)) @@ -597,8 +599,8 @@ _Bool hs_is_superset(struct hashset *_set1_, struct hashset *_set2_) } _Bool hs_is_proper_subset(struct hashset *_set1_, struct hashset *_set2_) { - _set1_->flag = cmc_flags.OK; - _set2_->flag = cmc_flags.OK; + _set1_->flag = CMC_FLAG_OK; + _set2_->flag = CMC_FLAG_OK; if (_set1_->count >= _set2_->count) return 0; if (hs_empty(_set1_)) @@ -623,8 +625,8 @@ _Bool hs_is_proper_superset(struct hashset *_set1_, struct hashset *_set2_) } _Bool hs_is_disjointset(struct hashset *_set1_, struct hashset *_set2_) { - _set1_->flag = cmc_flags.OK; - _set2_->flag = cmc_flags.OK; + _set1_->flag = CMC_FLAG_OK; + _set2_->flag = CMC_FLAG_OK; if (hs_empty(_set1_)) return 1; struct hashset_iter iter = hs_iter_start(_set1_); diff --git a/tests/main/src/heap.c b/tests/main/src/heap.c index 972af1d..fefc99f 100644 --- a/tests/main/src/heap.c +++ b/tests/main/src/heap.c @@ -90,7 +90,7 @@ struct heap *h_new(size_t capacity, enum cmc_heap_order HO, _heap_->capacity = capacity; _heap_->count = 0; _heap_->HO = HO; - _heap_->flag = cmc_flags.OK; + _heap_->flag = CMC_FLAG_OK; _heap_->f_val = f_val; _heap_->alloc = alloc; _heap_->callbacks = ((void *)0); @@ -120,7 +120,7 @@ struct heap *h_new_custom(size_t capacity, enum cmc_heap_order HO, _heap_->capacity = capacity; _heap_->count = 0; _heap_->HO = HO; - _heap_->flag = cmc_flags.OK; + _heap_->flag = CMC_FLAG_OK; _heap_->f_val = f_val; _heap_->alloc = alloc; _heap_->callbacks = callbacks; @@ -137,7 +137,7 @@ void h_clear(struct heap *_heap_) } memset(_heap_->buffer, 0, sizeof(size_t) * _heap_->capacity); _heap_->count = 0; - _heap_->flag = cmc_flags.OK; + _heap_->flag = CMC_FLAG_OK; } void h_free(struct heap *_heap_) { @@ -159,7 +159,7 @@ void h_customize(struct heap *_heap_, struct cmc_alloc_node *alloc, else _heap_->alloc = alloc; _heap_->callbacks = callbacks; - _heap_->flag = cmc_flags.OK; + _heap_->flag = CMC_FLAG_OK; } _Bool h_insert(struct heap *_heap_, size_t value) { @@ -173,7 +173,7 @@ _Bool h_insert(struct heap *_heap_, size_t value) { h_impl_float_up(_heap_, _heap_->count - 1); } - _heap_->flag = cmc_flags.OK; + _heap_->flag = CMC_FLAG_OK; if (_heap_->callbacks && _heap_->callbacks->create) _heap_->callbacks->create(); return 1; @@ -182,14 +182,14 @@ _Bool h_remove(struct heap *_heap_) { if (h_empty(_heap_)) { - _heap_->flag = cmc_flags.EMPTY; + _heap_->flag = CMC_FLAG_EMPTY; return 0; } _heap_->buffer[0] = _heap_->buffer[_heap_->count - 1]; _heap_->buffer[_heap_->count - 1] = (size_t){ 0 }; _heap_->count--; h_impl_float_down(_heap_, 0); - _heap_->flag = cmc_flags.OK; + _heap_->flag = CMC_FLAG_OK; if (_heap_->callbacks && _heap_->callbacks->delete) _heap_->callbacks->delete (); return 1; @@ -198,17 +198,17 @@ size_t h_peek(struct heap *_heap_) { if (h_empty(_heap_)) { - _heap_->flag = cmc_flags.EMPTY; + _heap_->flag = CMC_FLAG_EMPTY; return (size_t){ 0 }; } - _heap_->flag = cmc_flags.OK; + _heap_->flag = CMC_FLAG_OK; if (_heap_->callbacks && _heap_->callbacks->read) _heap_->callbacks->read(); return _heap_->buffer[0]; } _Bool h_contains(struct heap *_heap_, size_t value) { - _heap_->flag = cmc_flags.OK; + _heap_->flag = CMC_FLAG_OK; _Bool result = 0; for (size_t i = 0; i < _heap_->count; i++) { @@ -244,19 +244,19 @@ int h_flag(struct heap *_heap_) } _Bool h_resize(struct heap *_heap_, size_t capacity) { - _heap_->flag = cmc_flags.OK; + _heap_->flag = CMC_FLAG_OK; if (_heap_->capacity == capacity) goto success; if (capacity < _heap_->count) { - _heap_->flag = cmc_flags.INVALID; + _heap_->flag = CMC_FLAG_INVALID; return 0; } size_t *new_buffer = _heap_->alloc->realloc(_heap_->buffer, sizeof(size_t) * capacity); if (!new_buffer) { - _heap_->flag = cmc_flags.ALLOC; + _heap_->flag = CMC_FLAG_ALLOC; return 0; } _heap_->buffer = new_buffer; @@ -273,7 +273,7 @@ struct heap *h_copy_of(struct heap *_heap_) _heap_->callbacks); if (!result) { - _heap_->flag = cmc_flags.ERROR; + _heap_->flag = CMC_FLAG_ERROR; return ((void *)0); } if (_heap_->f_val->cpy) @@ -284,13 +284,13 @@ struct heap *h_copy_of(struct heap *_heap_) else memcpy(result->buffer, _heap_->buffer, sizeof(size_t) * _heap_->count); result->count = _heap_->count; - _heap_->flag = cmc_flags.OK; + _heap_->flag = CMC_FLAG_OK; return result; } _Bool h_equals(struct heap *_heap1_, struct heap *_heap2_) { - _heap1_->flag = cmc_flags.OK; - _heap2_->flag = cmc_flags.OK; + _heap1_->flag = CMC_FLAG_OK; + _heap2_->flag = CMC_FLAG_OK; if (_heap1_->count != _heap2_->count) return 0; for (size_t i = 0; i < _heap1_->count; i++) @@ -305,9 +305,11 @@ struct cmc_string h_to_string(struct heap *_heap_) struct cmc_string str; struct heap *h_ = _heap_; const char *t = h_->HO == 1 ? "MaxHeap" : "MinHeap"; - int n = snprintf(str.s, cmc_string_len, cmc_string_fmt_heap, "heap", - "size_t", h_, h_->buffer, h_->capacity, h_->count, t, - h_->flag, h_->f_val, h_->alloc, h_->callbacks); + int n = snprintf(str.s, cmc_string_len, cmc_cmc_string_fmt_heap, + "CMC_PARAM_SNAME((h, heap, , , size_t))", + "CMC_PARAM_V((h, heap, , , size_t))", h_, h_->buffer, + h_->capacity, h_->count, t, h_->flag, h_->f_val, h_->alloc, + h_->callbacks); return n >= 0 ? str : (struct cmc_string){ 0 }; } _Bool h_print(struct heap *_heap_, FILE *fptr) diff --git a/tests/main/src/intervalheap.c b/tests/main/src/intervalheap.c index 568ac19..ddcce5b 100644 --- a/tests/main/src/intervalheap.c +++ b/tests/main/src/intervalheap.c @@ -94,7 +94,7 @@ struct intervalheap *ih_new(size_t capacity, struct intervalheap_fval *f_val) _heap_->capacity = capacity; _heap_->size = 0; _heap_->count = 0; - _heap_->flag = cmc_flags.OK; + _heap_->flag = CMC_FLAG_OK; _heap_->f_val = f_val; _heap_->alloc = alloc; _heap_->callbacks = ((void *)0); @@ -124,7 +124,7 @@ struct intervalheap *ih_new_custom(size_t capacity, _heap_->capacity = capacity; _heap_->size = 0; _heap_->count = 0; - _heap_->flag = cmc_flags.OK; + _heap_->flag = CMC_FLAG_OK; _heap_->f_val = f_val; _heap_->alloc = alloc; _heap_->callbacks = callbacks; @@ -142,7 +142,7 @@ void ih_clear(struct intervalheap *_heap_) memset(_heap_->buffer, 0, sizeof(size_t[2]) * _heap_->capacity); _heap_->size = 0; _heap_->count = 0; - _heap_->flag = cmc_flags.OK; + _heap_->flag = CMC_FLAG_OK; } void ih_free(struct intervalheap *_heap_) { @@ -164,7 +164,7 @@ void ih_customize(struct intervalheap *_heap_, struct cmc_alloc_node *alloc, else _heap_->alloc = alloc; _heap_->callbacks = callbacks; - _heap_->flag = cmc_flags.OK; + _heap_->flag = CMC_FLAG_OK; } _Bool ih_insert(struct intervalheap *_heap_, size_t value) { @@ -193,7 +193,7 @@ _Bool ih_insert(struct intervalheap *_heap_, size_t value) } } _heap_->count++; - _heap_->flag = cmc_flags.OK; + _heap_->flag = CMC_FLAG_OK; if (_heap_->count > 2) { size_t(*parent)[2] = &(_heap_->buffer[(_heap_->size - 2) / 2]); @@ -210,7 +210,7 @@ _Bool ih_remove_max(struct intervalheap *_heap_) { if (ih_empty(_heap_)) { - _heap_->flag = cmc_flags.EMPTY; + _heap_->flag = CMC_FLAG_EMPTY; return 0; } if (_heap_->count == 1) @@ -235,7 +235,7 @@ _Bool ih_remove_max(struct intervalheap *_heap_) _heap_->count--; ih_impl_float_down_max(_heap_); success: - _heap_->flag = cmc_flags.OK; + _heap_->flag = CMC_FLAG_OK; if (_heap_->callbacks && _heap_->callbacks->delete) _heap_->callbacks->delete (); return 1; @@ -244,7 +244,7 @@ _Bool ih_remove_min(struct intervalheap *_heap_) { if (ih_empty(_heap_)) { - _heap_->flag = cmc_flags.EMPTY; + _heap_->flag = CMC_FLAG_EMPTY; return 0; } if (_heap_->count == 1) @@ -269,7 +269,7 @@ _Bool ih_remove_min(struct intervalheap *_heap_) _heap_->count--; ih_impl_float_down_min(_heap_); success: - _heap_->flag = cmc_flags.OK; + _heap_->flag = CMC_FLAG_OK; if (_heap_->callbacks && _heap_->callbacks->delete) _heap_->callbacks->delete (); return 1; @@ -278,7 +278,7 @@ _Bool ih_update_max(struct intervalheap *_heap_, size_t value) { if (ih_empty(_heap_)) { - _heap_->flag = cmc_flags.EMPTY; + _heap_->flag = CMC_FLAG_EMPTY; return 0; } if (_heap_->count == 1) @@ -296,7 +296,7 @@ _Bool ih_update_max(struct intervalheap *_heap_, size_t value) _heap_->buffer[0][1] = value; ih_impl_float_down_max(_heap_); } - _heap_->flag = cmc_flags.OK; + _heap_->flag = CMC_FLAG_OK; if (_heap_->callbacks && _heap_->callbacks->update) _heap_->callbacks->update(); return 1; @@ -305,7 +305,7 @@ _Bool ih_update_min(struct intervalheap *_heap_, size_t value) { if (ih_empty(_heap_)) { - _heap_->flag = cmc_flags.EMPTY; + _heap_->flag = CMC_FLAG_EMPTY; return 0; } if (_heap_->count == 1) @@ -323,7 +323,7 @@ _Bool ih_update_min(struct intervalheap *_heap_, size_t value) _heap_->buffer[0][0] = value; ih_impl_float_down_min(_heap_); } - _heap_->flag = cmc_flags.OK; + _heap_->flag = CMC_FLAG_OK; if (_heap_->callbacks && _heap_->callbacks->update) _heap_->callbacks->update(); return 1; @@ -332,10 +332,10 @@ size_t ih_max(struct intervalheap *_heap_) { if (ih_empty(_heap_)) { - _heap_->flag = cmc_flags.EMPTY; + _heap_->flag = CMC_FLAG_EMPTY; return (size_t){ 0 }; } - _heap_->flag = cmc_flags.OK; + _heap_->flag = CMC_FLAG_OK; if (_heap_->callbacks && _heap_->callbacks->read) _heap_->callbacks->read(); if (_heap_->count == 1) @@ -346,17 +346,17 @@ size_t ih_min(struct intervalheap *_heap_) { if (ih_empty(_heap_)) { - _heap_->flag = cmc_flags.EMPTY; + _heap_->flag = CMC_FLAG_EMPTY; return (size_t){ 0 }; } - _heap_->flag = cmc_flags.OK; + _heap_->flag = CMC_FLAG_OK; if (_heap_->callbacks && _heap_->callbacks->read) _heap_->callbacks->read(); return _heap_->buffer[0][0]; } _Bool ih_contains(struct intervalheap *_heap_, size_t value) { - _heap_->flag = cmc_flags.OK; + _heap_->flag = CMC_FLAG_OK; _Bool result = 0; for (size_t i = 0; i < _heap_->count; i++) { @@ -396,12 +396,12 @@ _Bool ih_resize(struct intervalheap *_heap_, size_t capacity) goto success; if (capacity < _heap_->count) { - _heap_->flag = cmc_flags.INVALID; + _heap_->flag = CMC_FLAG_INVALID; return 0; } if (capacity == 0xffffffffffffffffULL) { - _heap_->flag = cmc_flags.ERROR; + _heap_->flag = CMC_FLAG_ERROR; return 0; } capacity += capacity % 2; @@ -409,7 +409,7 @@ _Bool ih_resize(struct intervalheap *_heap_, size_t capacity) _heap_->alloc->realloc(_heap_->buffer, sizeof(size_t[2]) * capacity); if (!new_buffer) { - _heap_->flag = cmc_flags.ALLOC; + _heap_->flag = CMC_FLAG_ALLOC; return 0; } if (capacity > _heap_->capacity) @@ -420,7 +420,7 @@ _Bool ih_resize(struct intervalheap *_heap_, size_t capacity) _heap_->buffer = new_buffer; _heap_->capacity = capacity; success: - _heap_->flag = cmc_flags.OK; + _heap_->flag = CMC_FLAG_OK; if (_heap_->callbacks && _heap_->callbacks->resize) _heap_->callbacks->resize(); return 1; @@ -431,7 +431,7 @@ struct intervalheap *ih_copy_of(struct intervalheap *_heap_) _heap_->alloc->malloc(sizeof(struct intervalheap)); if (!result) { - _heap_->flag = cmc_flags.ALLOC; + _heap_->flag = CMC_FLAG_ALLOC; return ((void *)0); } memcpy(result, _heap_, sizeof(struct intervalheap)); @@ -440,7 +440,7 @@ struct intervalheap *ih_copy_of(struct intervalheap *_heap_) if (!result->buffer) { _heap_->alloc->free(result); - _heap_->flag = cmc_flags.ALLOC; + _heap_->flag = CMC_FLAG_ALLOC; return ((void *)0); } if (_heap_->f_val->cpy) @@ -455,17 +455,17 @@ struct intervalheap *ih_copy_of(struct intervalheap *_heap_) result->capacity = _heap_->capacity; result->size = _heap_->size; result->count = _heap_->count; - result->flag = cmc_flags.OK; + result->flag = CMC_FLAG_OK; result->f_val = _heap_->f_val; result->alloc = _heap_->alloc; result->callbacks = _heap_->callbacks; - _heap_->flag = cmc_flags.OK; + _heap_->flag = CMC_FLAG_OK; return result; } _Bool ih_equals(struct intervalheap *_heap1_, struct intervalheap *_heap2_) { - _heap1_->flag = cmc_flags.OK; - _heap2_->flag = cmc_flags.OK; + _heap1_->flag = CMC_FLAG_OK; + _heap2_->flag = CMC_FLAG_OK; if (_heap1_->count != _heap2_->count) return 0; for (size_t i = 0; i < _heap1_->count; i++) @@ -481,10 +481,11 @@ struct cmc_string ih_to_string(struct intervalheap *_heap_) { struct cmc_string str; struct intervalheap *h_ = _heap_; - int n = snprintf(str.s, cmc_string_len, cmc_string_fmt_intervalheap, - "intervalheap", "size_t", h_, h_->buffer, h_->capacity, - h_->size, h_->count, h_->flag, h_->f_val, h_->alloc, - h_->callbacks); + int n = snprintf(str.s, cmc_string_len, cmc_cmc_string_fmt_intervalheap, + "CMC_PARAM_SNAME((ih, intervalheap, , , size_t))", + "CMC_PARAM_V((ih, intervalheap, , , size_t))", h_, + h_->buffer, h_->capacity, h_->size, h_->count, h_->flag, + h_->f_val, h_->alloc, h_->callbacks); return n >= 0 ? str : (struct cmc_string){ 0 }; } _Bool ih_print(struct intervalheap *_heap_, FILE *fptr) diff --git a/tests/main/src/linkedlist.c b/tests/main/src/linkedlist.c index f5d3d6a..acf7384 100644 --- a/tests/main/src/linkedlist.c +++ b/tests/main/src/linkedlist.c @@ -102,7 +102,7 @@ struct linkedlist *ll_new(struct linkedlist_fval *f_val) _list_->count = 0; _list_->head = ((void *)0); _list_->tail = ((void *)0); - _list_->flag = cmc_flags.OK; + _list_->flag = CMC_FLAG_OK; _list_->f_val = f_val; _list_->alloc = alloc; _list_->callbacks = ((void *)0); @@ -122,7 +122,7 @@ struct linkedlist *ll_new_custom(struct linkedlist_fval *f_val, _list_->count = 0; _list_->head = ((void *)0); _list_->tail = ((void *)0); - _list_->flag = cmc_flags.OK; + _list_->flag = CMC_FLAG_OK; _list_->f_val = f_val; _list_->alloc = alloc; _list_->callbacks = callbacks; @@ -144,7 +144,7 @@ void ll_clear(struct linkedlist *_list_) _list_->count = 0; _list_->head = ((void *)0); _list_->tail = ((void *)0); - _list_->flag = cmc_flags.OK; + _list_->flag = CMC_FLAG_OK; } void ll_free(struct linkedlist *_list_) { @@ -159,7 +159,7 @@ void ll_customize(struct linkedlist *_list_, struct cmc_alloc_node *alloc, else _list_->alloc = alloc; _list_->callbacks = callbacks; - _list_->flag = cmc_flags.OK; + _list_->flag = CMC_FLAG_OK; } _Bool ll_push_front(struct linkedlist *_list_, size_t value) { @@ -178,7 +178,7 @@ _Bool ll_push_front(struct linkedlist *_list_, size_t value) _list_->head = _node_; } _list_->count++; - _list_->flag = cmc_flags.OK; + _list_->flag = CMC_FLAG_OK; if (_list_->callbacks && _list_->callbacks->create) _list_->callbacks->create(); return 1; @@ -187,7 +187,7 @@ _Bool ll_push_at(struct linkedlist *_list_, size_t value, size_t index) { if (index > _list_->count) { - _list_->flag = cmc_flags.RANGE; + _list_->flag = CMC_FLAG_RANGE; return 0; } if (index == 0) @@ -207,7 +207,7 @@ _Bool ll_push_at(struct linkedlist *_list_, size_t value, size_t index) _node_->next->prev = _node_; _node_->prev->next = _node_; _list_->count++; - _list_->flag = cmc_flags.OK; + _list_->flag = CMC_FLAG_OK; if (_list_->callbacks && _list_->callbacks->create) _list_->callbacks->create(); return 1; @@ -229,7 +229,7 @@ _Bool ll_push_back(struct linkedlist *_list_, size_t value) _list_->tail = _node_; } _list_->count++; - _list_->flag = cmc_flags.OK; + _list_->flag = CMC_FLAG_OK; if (_list_->callbacks && _list_->callbacks->create) _list_->callbacks->create(); return 1; @@ -238,7 +238,7 @@ _Bool ll_pop_front(struct linkedlist *_list_) { if (ll_empty(_list_)) { - _list_->flag = cmc_flags.EMPTY; + _list_->flag = CMC_FLAG_EMPTY; return 0; } struct linkedlist_node *_node_ = _list_->head; @@ -249,7 +249,7 @@ _Bool ll_pop_front(struct linkedlist *_list_) else _list_->head->prev = ((void *)0); _list_->count--; - _list_->flag = cmc_flags.OK; + _list_->flag = CMC_FLAG_OK; if (_list_->callbacks && _list_->callbacks->delete) _list_->callbacks->delete (); return 1; @@ -258,12 +258,12 @@ _Bool ll_pop_at(struct linkedlist *_list_, size_t index) { if (ll_empty(_list_)) { - _list_->flag = cmc_flags.EMPTY; + _list_->flag = CMC_FLAG_EMPTY; return 0; } if (index >= _list_->count) { - _list_->flag = cmc_flags.RANGE; + _list_->flag = CMC_FLAG_RANGE; return 0; } if (index == 0) @@ -281,7 +281,7 @@ _Bool ll_pop_at(struct linkedlist *_list_, size_t index) _node_->prev->next = _node_->next; _list_->alloc->free(_node_); _list_->count--; - _list_->flag = cmc_flags.OK; + _list_->flag = CMC_FLAG_OK; if (_list_->callbacks && _list_->callbacks->delete) _list_->callbacks->delete (); return 1; @@ -290,7 +290,7 @@ _Bool ll_pop_back(struct linkedlist *_list_) { if (ll_empty(_list_)) { - _list_->flag = cmc_flags.EMPTY; + _list_->flag = CMC_FLAG_EMPTY; return 0; } struct linkedlist_node *_node_ = _list_->tail; @@ -301,7 +301,7 @@ _Bool ll_pop_back(struct linkedlist *_list_) else _list_->tail->next = ((void *)0); _list_->count--; - _list_->flag = cmc_flags.OK; + _list_->flag = CMC_FLAG_OK; if (_list_->callbacks && _list_->callbacks->delete) _list_->callbacks->delete (); return 1; @@ -310,10 +310,10 @@ size_t ll_front(struct linkedlist *_list_) { if (ll_empty(_list_)) { - _list_->flag = cmc_flags.EMPTY; + _list_->flag = CMC_FLAG_EMPTY; return (size_t){ 0 }; } - _list_->flag = cmc_flags.OK; + _list_->flag = CMC_FLAG_OK; if (_list_->callbacks && _list_->callbacks->read) _list_->callbacks->read(); return _list_->head->value; @@ -322,12 +322,12 @@ size_t ll_get(struct linkedlist *_list_, size_t index) { if (ll_empty(_list_)) { - _list_->flag = cmc_flags.EMPTY; + _list_->flag = CMC_FLAG_EMPTY; return (size_t){ 0 }; } if (index >= _list_->count) { - _list_->flag = cmc_flags.RANGE; + _list_->flag = CMC_FLAG_RANGE; return (size_t){ 0 }; } struct linkedlist_node *scan = ll_get_node(_list_, index); @@ -341,12 +341,12 @@ size_t *ll_get_ref(struct linkedlist *_list_, size_t index) { if (ll_empty(_list_)) { - _list_->flag = cmc_flags.EMPTY; + _list_->flag = CMC_FLAG_EMPTY; return ((void *)0); } if (index >= _list_->count) { - _list_->flag = cmc_flags.RANGE; + _list_->flag = CMC_FLAG_RANGE; return ((void *)0); } struct linkedlist_node *scan = ll_get_node(_list_, index); @@ -360,17 +360,17 @@ size_t ll_back(struct linkedlist *_list_) { if (ll_empty(_list_)) { - _list_->flag = cmc_flags.EMPTY; + _list_->flag = CMC_FLAG_EMPTY; return (size_t){ 0 }; } - _list_->flag = cmc_flags.OK; + _list_->flag = CMC_FLAG_OK; if (_list_->callbacks && _list_->callbacks->read) _list_->callbacks->read(); return _list_->tail->value; } _Bool ll_contains(struct linkedlist *_list_, size_t value) { - _list_->flag = cmc_flags.OK; + _list_->flag = CMC_FLAG_OK; _Bool result = 0; struct linkedlist_node *scan = _list_->head; while (scan != ((void *)0)) @@ -426,13 +426,13 @@ struct linkedlist *ll_copy_of(struct linkedlist *_list_) scan = scan->next; } result->count = _list_->count; - _list_->flag = cmc_flags.OK; + _list_->flag = CMC_FLAG_OK; return result; } _Bool ll_equals(struct linkedlist *_list1_, struct linkedlist *_list2_) { - _list1_->flag = cmc_flags.OK; - _list2_->flag = cmc_flags.OK; + _list1_->flag = CMC_FLAG_OK; + _list2_->flag = CMC_FLAG_OK; if (_list1_->count != _list2_->count) return 0; struct linkedlist_node *scan1 = _list1_->head; @@ -450,9 +450,11 @@ struct cmc_string ll_to_string(struct linkedlist *_list_) { struct cmc_string str; struct linkedlist *l_ = _list_; - int n = snprintf(str.s, cmc_string_len, cmc_string_fmt_linkedlist, - "linkedlist", "size_t", l_, l_->count, l_->head, l_->tail, - l_->flag, l_->f_val, l_->alloc, l_->callbacks); + int n = snprintf(str.s, cmc_string_len, cmc_cmc_string_fmt_linkedlist, + "CMC_PARAM_SNAME((ll, linkedlist, , , size_t))", + "CMC_PARAM_V((ll, linkedlist, , , size_t))", l_, l_->count, + l_->head, l_->tail, l_->flag, l_->f_val, l_->alloc, + l_->callbacks); return n >= 0 ? str : (struct cmc_string){ 0 }; } _Bool ll_print(struct linkedlist *_list_, FILE *fptr) @@ -472,7 +474,7 @@ struct linkedlist_node *ll_new_node(struct linkedlist *_list_, size_t value) _list_->alloc->malloc(sizeof(struct linkedlist_node)); if (!_node_) { - _list_->flag = cmc_flags.ALLOC; + _list_->flag = CMC_FLAG_ALLOC; return ((void *)0); } _node_->value = value; @@ -492,12 +494,12 @@ struct linkedlist_node *ll_get_node(struct linkedlist *_list_, size_t index) { if (ll_empty(_list_)) { - _list_->flag = cmc_flags.EMPTY; + _list_->flag = CMC_FLAG_EMPTY; return ((void *)0); } if (index >= _list_->count) { - _list_->flag = cmc_flags.RANGE; + _list_->flag = CMC_FLAG_RANGE; return ((void *)0); } struct linkedlist_node *_node_ = ((void *)0); @@ -517,7 +519,7 @@ struct linkedlist_node *ll_get_node(struct linkedlist *_list_, size_t index) _node_ = _node_->prev; } } - _list_->flag = cmc_flags.OK; + _list_->flag = CMC_FLAG_OK; return _node_; } struct linkedlist_node *ll_tail(struct linkedlist *_list_) @@ -538,7 +540,7 @@ _Bool ll_add_next(struct linkedlist *_owner_, struct linkedlist_node *_node_, new_node->prev = _node_; _node_->next = new_node; _owner_->count++; - _owner_->flag = cmc_flags.OK; + _owner_->flag = CMC_FLAG_OK; return 1; } _Bool ll_add_prev(struct linkedlist *_owner_, struct linkedlist_node *_node_, @@ -555,14 +557,14 @@ _Bool ll_add_prev(struct linkedlist *_owner_, struct linkedlist_node *_node_, new_node->next = _node_; _node_->prev = new_node; _owner_->count++; - _owner_->flag = cmc_flags.OK; + _owner_->flag = CMC_FLAG_OK; return 1; } _Bool ll_del_next(struct linkedlist *_owner_, struct linkedlist_node *_node_) { if (_node_->next == ((void *)0)) { - _owner_->flag = cmc_flags.INVALID; + _owner_->flag = CMC_FLAG_INVALID; return 0; } struct linkedlist_node *tmp = _node_->next; @@ -573,7 +575,7 @@ _Bool ll_del_next(struct linkedlist *_owner_, struct linkedlist_node *_node_) _owner_->tail = _node_; _owner_->alloc->free(tmp); _owner_->count--; - _owner_->flag = cmc_flags.OK; + _owner_->flag = CMC_FLAG_OK; return 1; } _Bool ll_del_curr(struct linkedlist *_owner_, struct linkedlist_node *_node_) @@ -588,14 +590,14 @@ _Bool ll_del_curr(struct linkedlist *_owner_, struct linkedlist_node *_node_) _owner_->tail = _node_->prev; _owner_->alloc->free(_node_); _owner_->count--; - _owner_->flag = cmc_flags.OK; + _owner_->flag = CMC_FLAG_OK; return 1; } _Bool ll_del_prev(struct linkedlist *_owner_, struct linkedlist_node *_node_) { if (_node_->prev == ((void *)0)) { - _owner_->flag = cmc_flags.INVALID; + _owner_->flag = CMC_FLAG_INVALID; return 0; } struct linkedlist_node *tmp = _node_->prev; @@ -606,7 +608,7 @@ _Bool ll_del_prev(struct linkedlist *_owner_, struct linkedlist_node *_node_) _owner_->head = _node_; _owner_->alloc->free(tmp); _owner_->count--; - _owner_->flag = cmc_flags.OK; + _owner_->flag = CMC_FLAG_OK; return 1; } struct linkedlist_node *ll_next_node(struct linkedlist_node *_node_) diff --git a/tests/main/src/list.c b/tests/main/src/list.c index 221171c..b0e8824 100644 --- a/tests/main/src/list.c +++ b/tests/main/src/list.c @@ -96,7 +96,7 @@ struct list *l_new(size_t capacity, struct list_fval *f_val) } _list_->capacity = capacity; _list_->count = 0; - _list_->flag = cmc_flags.OK; + _list_->flag = CMC_FLAG_OK; _list_->f_val = f_val; _list_->alloc = alloc; _list_->callbacks = ((void *)0); @@ -123,7 +123,7 @@ struct list *l_new_custom(size_t capacity, struct list_fval *f_val, } _list_->capacity = capacity; _list_->count = 0; - _list_->flag = cmc_flags.OK; + _list_->flag = CMC_FLAG_OK; _list_->f_val = f_val; _list_->alloc = alloc; _list_->callbacks = callbacks; @@ -138,7 +138,7 @@ void l_clear(struct list *_list_) } memset(_list_->buffer, 0, sizeof(size_t) * _list_->capacity); _list_->count = 0; - _list_->flag = cmc_flags.OK; + _list_->flag = CMC_FLAG_OK; } void l_free(struct list *_list_) { @@ -158,7 +158,7 @@ void l_customize(struct list *_list_, struct cmc_alloc_node *alloc, else _list_->alloc = alloc; _list_->callbacks = callbacks; - _list_->flag = cmc_flags.OK; + _list_->flag = CMC_FLAG_OK; } _Bool l_push_front(struct list *_list_, size_t value) { @@ -174,7 +174,7 @@ _Bool l_push_front(struct list *_list_, size_t value) } _list_->buffer[0] = value; _list_->count++; - _list_->flag = cmc_flags.OK; + _list_->flag = CMC_FLAG_OK; if (_list_->callbacks && _list_->callbacks->create) _list_->callbacks->create(); return 1; @@ -183,7 +183,7 @@ _Bool l_push_at(struct list *_list_, size_t value, size_t index) { if (index > _list_->count) { - _list_->flag = cmc_flags.RANGE; + _list_->flag = CMC_FLAG_RANGE; return 0; } if (l_full(_list_)) @@ -195,7 +195,7 @@ _Bool l_push_at(struct list *_list_, size_t value, size_t index) (_list_->count - index) * sizeof(size_t)); _list_->buffer[index] = value; _list_->count++; - _list_->flag = cmc_flags.OK; + _list_->flag = CMC_FLAG_OK; if (_list_->callbacks && _list_->callbacks->create) _list_->callbacks->create(); return 1; @@ -208,7 +208,7 @@ _Bool l_push_back(struct list *_list_, size_t value) return 0; } _list_->buffer[_list_->count++] = value; - _list_->flag = cmc_flags.OK; + _list_->flag = CMC_FLAG_OK; if (_list_->callbacks && _list_->callbacks->create) _list_->callbacks->create(); return 1; @@ -217,13 +217,13 @@ _Bool l_pop_front(struct list *_list_) { if (l_empty(_list_)) { - _list_->flag = cmc_flags.EMPTY; + _list_->flag = CMC_FLAG_EMPTY; return 0; } memmove(_list_->buffer, _list_->buffer + 1, (_list_->count - 1) * sizeof(size_t)); _list_->buffer[--_list_->count] = (size_t){ 0 }; - _list_->flag = cmc_flags.OK; + _list_->flag = CMC_FLAG_OK; if (_list_->callbacks && _list_->callbacks->delete) _list_->callbacks->delete (); return 1; @@ -232,18 +232,18 @@ _Bool l_pop_at(struct list *_list_, size_t index) { if (l_empty(_list_)) { - _list_->flag = cmc_flags.EMPTY; + _list_->flag = CMC_FLAG_EMPTY; return 0; } if (index >= _list_->count) { - _list_->flag = cmc_flags.RANGE; + _list_->flag = CMC_FLAG_RANGE; return 0; } memmove(_list_->buffer + index, _list_->buffer + index + 1, (_list_->count - index - 1) * sizeof(size_t)); _list_->buffer[--_list_->count] = (size_t){ 0 }; - _list_->flag = cmc_flags.OK; + _list_->flag = CMC_FLAG_OK; if (_list_->callbacks && _list_->callbacks->delete) _list_->callbacks->delete (); return 1; @@ -253,7 +253,7 @@ _Bool l_pop_back(struct list *_list_) if (l_empty(_list_)) return 0; _list_->buffer[--_list_->count] = (size_t){ 0 }; - _list_->flag = cmc_flags.OK; + _list_->flag = CMC_FLAG_OK; if (_list_->callbacks && _list_->callbacks->delete) _list_->callbacks->delete (); return 1; @@ -262,7 +262,7 @@ _Bool l_seq_push_front(struct list *_list_, size_t *values, size_t size) { if (size == 0) { - _list_->flag = cmc_flags.INVALID; + _list_->flag = CMC_FLAG_INVALID; return 0; } if (!l_fits(_list_, size)) @@ -274,7 +274,7 @@ _Bool l_seq_push_front(struct list *_list_, size_t *values, size_t size) _list_->count * sizeof(size_t)); memcpy(_list_->buffer, values, size * sizeof(size_t)); _list_->count += size; - _list_->flag = cmc_flags.OK; + _list_->flag = CMC_FLAG_OK; if (_list_->callbacks && _list_->callbacks->create) _list_->callbacks->create(); return 1; @@ -284,12 +284,12 @@ _Bool l_seq_push_at(struct list *_list_, size_t *values, size_t size, { if (size == 0) { - _list_->flag = cmc_flags.INVALID; + _list_->flag = CMC_FLAG_INVALID; return 0; } if (index > _list_->count) { - _list_->flag = cmc_flags.RANGE; + _list_->flag = CMC_FLAG_RANGE; return 0; } if (index == 0) @@ -305,7 +305,7 @@ _Bool l_seq_push_at(struct list *_list_, size_t *values, size_t size, (_list_->count - index) * sizeof(size_t)); memcpy(_list_->buffer + index, values, size * sizeof(size_t)); _list_->count += size; - _list_->flag = cmc_flags.OK; + _list_->flag = CMC_FLAG_OK; if (_list_->callbacks && _list_->callbacks->create) _list_->callbacks->create(); return 1; @@ -314,7 +314,7 @@ _Bool l_seq_push_back(struct list *_list_, size_t *values, size_t size) { if (size == 0) { - _list_->flag = cmc_flags.INVALID; + _list_->flag = CMC_FLAG_INVALID; return 0; } if (!l_fits(_list_, size)) @@ -324,7 +324,7 @@ _Bool l_seq_push_back(struct list *_list_, size_t *values, size_t size) } memcpy(_list_->buffer + _list_->count, values, size * sizeof(size_t)); _list_->count += size; - _list_->flag = cmc_flags.OK; + _list_->flag = CMC_FLAG_OK; if (_list_->callbacks && _list_->callbacks->create) _list_->callbacks->create(); return 1; @@ -333,12 +333,12 @@ _Bool l_seq_pop_at(struct list *_list_, size_t from, size_t to) { if (from > to) { - _list_->flag = cmc_flags.INVALID; + _list_->flag = CMC_FLAG_INVALID; return 0; } if (to >= _list_->count) { - _list_->flag = cmc_flags.RANGE; + _list_->flag = CMC_FLAG_RANGE; return 0; } size_t length = (to - from + 1); @@ -346,7 +346,7 @@ _Bool l_seq_pop_at(struct list *_list_, size_t from, size_t to) (_list_->count - to - 1) * sizeof(size_t)); memset(_list_->buffer + _list_->count - length, 0, length * sizeof(size_t)); _list_->count -= to - from + 1; - _list_->flag = cmc_flags.OK; + _list_->flag = CMC_FLAG_OK; if (_list_->callbacks && _list_->callbacks->delete) _list_->callbacks->delete (); return 1; @@ -355,12 +355,12 @@ struct list *l_seq_sublist(struct list *_list_, size_t from, size_t to) { if (from > to) { - _list_->flag = cmc_flags.INVALID; + _list_->flag = CMC_FLAG_INVALID; return ((void *)0); } if (to >= _list_->count) { - _list_->flag = cmc_flags.RANGE; + _list_->flag = CMC_FLAG_RANGE; return ((void *)0); } size_t length = to - from + 1; @@ -368,7 +368,7 @@ struct list *l_seq_sublist(struct list *_list_, size_t from, size_t to) l_new_custom(length, _list_->f_val, _list_->alloc, _list_->callbacks); if (!result) { - _list_->flag = cmc_flags.ALLOC; + _list_->flag = CMC_FLAG_ALLOC; return ((void *)0); } memcpy(result->buffer, _list_->buffer, length * sizeof(size_t)); @@ -377,7 +377,7 @@ struct list *l_seq_sublist(struct list *_list_, size_t from, size_t to) memset(_list_->buffer + _list_->count - length, 0, length * sizeof(size_t)); _list_->count -= length; result->count = length; - _list_->flag = cmc_flags.OK; + _list_->flag = CMC_FLAG_OK; if (_list_->callbacks && _list_->callbacks->delete) _list_->callbacks->delete (); return result; @@ -386,10 +386,10 @@ size_t l_front(struct list *_list_) { if (l_empty(_list_)) { - _list_->flag = cmc_flags.EMPTY; + _list_->flag = CMC_FLAG_EMPTY; return (size_t){ 0 }; } - _list_->flag = cmc_flags.OK; + _list_->flag = CMC_FLAG_OK; if (_list_->callbacks && _list_->callbacks->read) _list_->callbacks->read(); return _list_->buffer[0]; @@ -398,15 +398,15 @@ size_t l_get(struct list *_list_, size_t index) { if (l_empty(_list_)) { - _list_->flag = cmc_flags.EMPTY; + _list_->flag = CMC_FLAG_EMPTY; return (size_t){ 0 }; } if (index >= _list_->count) { - _list_->flag = cmc_flags.RANGE; + _list_->flag = CMC_FLAG_RANGE; return (size_t){ 0 }; } - _list_->flag = cmc_flags.OK; + _list_->flag = CMC_FLAG_OK; if (_list_->callbacks && _list_->callbacks->read) _list_->callbacks->read(); return _list_->buffer[index]; @@ -415,15 +415,15 @@ size_t *l_get_ref(struct list *_list_, size_t index) { if (l_empty(_list_)) { - _list_->flag = cmc_flags.EMPTY; + _list_->flag = CMC_FLAG_EMPTY; return ((void *)0); } if (index >= _list_->count) { - _list_->flag = cmc_flags.RANGE; + _list_->flag = CMC_FLAG_RANGE; return ((void *)0); } - _list_->flag = cmc_flags.OK; + _list_->flag = CMC_FLAG_OK; if (_list_->callbacks && _list_->callbacks->read) _list_->callbacks->read(); return &(_list_->buffer[index]); @@ -432,17 +432,17 @@ size_t l_back(struct list *_list_) { if (l_empty(_list_)) { - _list_->flag = cmc_flags.EMPTY; + _list_->flag = CMC_FLAG_EMPTY; return (size_t){ 0 }; } - _list_->flag = cmc_flags.OK; + _list_->flag = CMC_FLAG_OK; if (_list_->callbacks && _list_->callbacks->read) _list_->callbacks->read(); return _list_->buffer[_list_->count - 1]; } size_t l_index_of(struct list *_list_, size_t value, _Bool from_start) { - _list_->flag = cmc_flags.OK; + _list_->flag = CMC_FLAG_OK; size_t result = _list_->count; if (from_start) { @@ -472,7 +472,7 @@ size_t l_index_of(struct list *_list_, size_t value, _Bool from_start) } _Bool l_contains(struct list *_list_, size_t value) { - _list_->flag = cmc_flags.OK; + _list_->flag = CMC_FLAG_OK; _Bool result = 0; for (size_t i = 0; i < _list_->count; i++) { @@ -512,19 +512,19 @@ int l_flag(struct list *_list_) } _Bool l_resize(struct list *_list_, size_t capacity) { - _list_->flag = cmc_flags.OK; + _list_->flag = CMC_FLAG_OK; if (_list_->capacity == capacity) return 1; if (capacity < _list_->count) { - _list_->flag = cmc_flags.INVALID; + _list_->flag = CMC_FLAG_INVALID; return 0; } size_t *new_buffer = _list_->alloc->realloc(_list_->buffer, sizeof(size_t) * capacity); if (!new_buffer) { - _list_->flag = cmc_flags.ALLOC; + _list_->flag = CMC_FLAG_ALLOC; return 0; } _list_->buffer = new_buffer; @@ -539,7 +539,7 @@ struct list *l_copy_of(struct list *_list_) _list_->alloc, _list_->callbacks); if (!result) { - _list_->flag = cmc_flags.ALLOC; + _list_->flag = CMC_FLAG_ALLOC; return ((void *)0); } if (_list_->f_val->cpy) @@ -550,13 +550,13 @@ struct list *l_copy_of(struct list *_list_) else memcpy(result->buffer, _list_->buffer, sizeof(size_t) * _list_->count); result->count = _list_->count; - _list_->flag = cmc_flags.OK; + _list_->flag = CMC_FLAG_OK; return result; } _Bool l_equals(struct list *_list1_, struct list *_list2_) { - _list1_->flag = cmc_flags.OK; - _list2_->flag = cmc_flags.OK; + _list1_->flag = CMC_FLAG_OK; + _list2_->flag = CMC_FLAG_OK; if (_list1_->count != _list2_->count) return 0; for (size_t i = 0; i < _list1_->count; i++) @@ -570,9 +570,11 @@ struct cmc_string l_to_string(struct list *_list_) { struct cmc_string str; struct list *l_ = _list_; - int n = snprintf(str.s, cmc_string_len, cmc_string_fmt_list, "list", - "size_t", l_, l_->buffer, l_->capacity, l_->count, - l_->flag, l_->f_val, l_->alloc, l_->callbacks); + int n = snprintf(str.s, cmc_string_len, cmc_cmc_string_fmt_list, + "CMC_PARAM_SNAME((l, list, , , size_t))", + "CMC_PARAM_V((l, list, , , size_t))", l_, l_->buffer, + l_->capacity, l_->count, l_->flag, l_->f_val, l_->alloc, + l_->callbacks); return n >= 0 ? str : (struct cmc_string){ 0 }; } _Bool l_print(struct list *_list_, FILE *fptr) diff --git a/tests/main/src/queue.c b/tests/main/src/queue.c index f749065..73abdce 100644 --- a/tests/main/src/queue.c +++ b/tests/main/src/queue.c @@ -88,7 +88,7 @@ struct queue *q_new(size_t capacity, struct queue_fval *f_val) _queue_->count = 0; _queue_->front = 0; _queue_->back = 0; - _queue_->flag = cmc_flags.OK; + _queue_->flag = CMC_FLAG_OK; _queue_->f_val = f_val; _queue_->alloc = alloc; _queue_->callbacks = ((void *)0); @@ -117,7 +117,7 @@ struct queue *q_new_custom(size_t capacity, struct queue_fval *f_val, _queue_->count = 0; _queue_->front = 0; _queue_->back = 0; - _queue_->flag = cmc_flags.OK; + _queue_->flag = CMC_FLAG_OK; _queue_->f_val = f_val; _queue_->alloc = alloc; _queue_->callbacks = callbacks; @@ -137,7 +137,7 @@ void q_clear(struct queue *_queue_) _queue_->count = 0; _queue_->front = 0; _queue_->back = 0; - _queue_->flag = cmc_flags.OK; + _queue_->flag = CMC_FLAG_OK; } void q_free(struct queue *_queue_) { @@ -160,7 +160,7 @@ void q_customize(struct queue *_queue_, struct cmc_alloc_node *alloc, else _queue_->alloc = alloc; _queue_->callbacks = callbacks; - _queue_->flag = cmc_flags.OK; + _queue_->flag = CMC_FLAG_OK; } _Bool q_enqueue(struct queue *_queue_, size_t value) { @@ -173,7 +173,7 @@ _Bool q_enqueue(struct queue *_queue_, size_t value) _queue_->back = (_queue_->back == _queue_->capacity - 1) ? 0 : _queue_->back + 1; _queue_->count++; - _queue_->flag = cmc_flags.OK; + _queue_->flag = CMC_FLAG_OK; if (_queue_->callbacks && _queue_->callbacks->create) _queue_->callbacks->create(); return 1; @@ -182,14 +182,14 @@ _Bool q_dequeue(struct queue *_queue_) { if (q_empty(_queue_)) { - _queue_->flag = cmc_flags.EMPTY; + _queue_->flag = CMC_FLAG_EMPTY; return 0; } _queue_->buffer[_queue_->front] = (size_t){ 0 }; _queue_->front = (_queue_->front == _queue_->capacity - 1) ? 0 : _queue_->front + 1; _queue_->count--; - _queue_->flag = cmc_flags.OK; + _queue_->flag = CMC_FLAG_OK; if (_queue_->callbacks && _queue_->callbacks->delete) _queue_->callbacks->delete (); return 1; @@ -198,17 +198,17 @@ size_t q_peek(struct queue *_queue_) { if (q_empty(_queue_)) { - _queue_->flag = cmc_flags.EMPTY; + _queue_->flag = CMC_FLAG_EMPTY; return (size_t){ 0 }; } - _queue_->flag = cmc_flags.OK; + _queue_->flag = CMC_FLAG_OK; if (_queue_->callbacks && _queue_->callbacks->read) _queue_->callbacks->read(); return _queue_->buffer[_queue_->front]; } _Bool q_contains(struct queue *_queue_, size_t value) { - _queue_->flag = cmc_flags.OK; + _queue_->flag = CMC_FLAG_OK; _Bool result = 0; for (size_t i = _queue_->front, j = 0; j < _queue_->count; j++) { @@ -249,13 +249,13 @@ _Bool q_resize(struct queue *_queue_, size_t capacity) goto success; if (capacity < _queue_->count) { - _queue_->flag = cmc_flags.INVALID; + _queue_->flag = CMC_FLAG_INVALID; return 0; } size_t *new_buffer = _queue_->alloc->malloc(sizeof(size_t) * capacity); if (!new_buffer) { - _queue_->flag = cmc_flags.ALLOC; + _queue_->flag = CMC_FLAG_ALLOC; return 0; } for (size_t i = _queue_->front, j = 0; j < _queue_->count; j++) @@ -269,7 +269,7 @@ _Bool q_resize(struct queue *_queue_, size_t capacity) _queue_->front = 0; _queue_->back = _queue_->count; success: - _queue_->flag = cmc_flags.OK; + _queue_->flag = CMC_FLAG_OK; if (_queue_->callbacks && _queue_->callbacks->resize) _queue_->callbacks->resize(); return 1; @@ -280,7 +280,7 @@ struct queue *q_copy_of(struct queue *_queue_) _queue_->alloc, _queue_->callbacks); if (!result) { - _queue_->flag = cmc_flags.ERROR; + _queue_->flag = CMC_FLAG_ERROR; return ((void *)0); } if (_queue_->f_val->cpy) @@ -302,13 +302,13 @@ struct queue *q_copy_of(struct queue *_queue_) result->count = _queue_->count; result->front = 0; result->back = _queue_->count; - _queue_->flag = cmc_flags.OK; + _queue_->flag = CMC_FLAG_OK; return result; } _Bool q_equals(struct queue *_queue1_, struct queue *_queue2_) { - _queue1_->flag = cmc_flags.OK; - _queue2_->flag = cmc_flags.OK; + _queue1_->flag = CMC_FLAG_OK; + _queue2_->flag = CMC_FLAG_OK; if (_queue1_->count != _queue2_->count) return 0; size_t i, j, k; @@ -326,10 +326,11 @@ struct cmc_string q_to_string(struct queue *_queue_) { struct cmc_string str; struct queue *q_ = _queue_; - int n = - snprintf(str.s, cmc_string_len, cmc_string_fmt_queue, "queue", "size_t", - q_, q_->buffer, q_->capacity, q_->count, q_->front, q_->back, - q_->flag, q_->f_val, q_->alloc, q_->callbacks); + int n = snprintf(str.s, cmc_string_len, cmc_cmc_string_fmt_queue, + "CMC_PARAM_SNAME((q, queue, , , size_t))", + "CMC_PARAM_V((q, queue, , , size_t))", q_, q_->buffer, + q_->capacity, q_->count, q_->front, q_->back, q_->flag, + q_->f_val, q_->alloc, q_->callbacks); return n >= 0 ? str : (struct cmc_string){ 0 }; } _Bool q_print(struct queue *_queue_, FILE *fptr) diff --git a/tests/main/src/sortedlist.c b/tests/main/src/sortedlist.c index efa0d92..61c1141 100644 --- a/tests/main/src/sortedlist.c +++ b/tests/main/src/sortedlist.c @@ -96,7 +96,7 @@ struct sortedlist *sl_new(size_t capacity, struct sortedlist_fval *f_val) _list_->capacity = capacity; _list_->count = 0; _list_->is_sorted = 0; - _list_->flag = cmc_flags.OK; + _list_->flag = CMC_FLAG_OK; _list_->f_val = f_val; _list_->alloc = alloc; _list_->callbacks = ((void *)0); @@ -122,7 +122,7 @@ struct sortedlist *sl_new_custom(size_t capacity, struct sortedlist_fval *f_val, _list_->capacity = capacity; _list_->count = 0; _list_->is_sorted = 0; - _list_->flag = cmc_flags.OK; + _list_->flag = CMC_FLAG_OK; _list_->f_val = f_val; _list_->alloc = alloc; _list_->callbacks = callbacks; @@ -137,7 +137,7 @@ void sl_clear(struct sortedlist *_list_) } memset(_list_->buffer, 0, sizeof(size_t) * _list_->capacity); _list_->count = 0; - _list_->flag = cmc_flags.OK; + _list_->flag = CMC_FLAG_OK; } void sl_free(struct sortedlist *_list_) { @@ -157,7 +157,7 @@ void sl_customize(struct sortedlist *_list_, struct cmc_alloc_node *alloc, else _list_->alloc = alloc; _list_->callbacks = callbacks; - _list_->flag = cmc_flags.OK; + _list_->flag = CMC_FLAG_OK; } _Bool sl_insert(struct sortedlist *_list_, size_t value) { @@ -168,7 +168,7 @@ _Bool sl_insert(struct sortedlist *_list_, size_t value) } _list_->buffer[_list_->count++] = value; _list_->is_sorted = 0; - _list_->flag = cmc_flags.OK; + _list_->flag = CMC_FLAG_OK; if (_list_->callbacks && _list_->callbacks->create) _list_->callbacks->create(); return 1; @@ -177,18 +177,18 @@ _Bool sl_remove(struct sortedlist *_list_, size_t index) { if (sl_empty(_list_)) { - _list_->flag = cmc_flags.EMPTY; + _list_->flag = CMC_FLAG_EMPTY; return 0; } if (index >= _list_->count) { - _list_->flag = cmc_flags.RANGE; + _list_->flag = CMC_FLAG_RANGE; return 0; } memmove(_list_->buffer + index, _list_->buffer + index + 1, (_list_->count - index) * sizeof(size_t)); _list_->buffer[--_list_->count] = (size_t){ 0 }; - _list_->flag = cmc_flags.OK; + _list_->flag = CMC_FLAG_OK; if (_list_->callbacks && _list_->callbacks->delete) _list_->callbacks->delete (); return 1; @@ -197,11 +197,11 @@ size_t sl_max(struct sortedlist *_list_) { if (sl_empty(_list_)) { - _list_->flag = cmc_flags.EMPTY; + _list_->flag = CMC_FLAG_EMPTY; return (size_t){ 0 }; } sl_sort(_list_); - _list_->flag = cmc_flags.OK; + _list_->flag = CMC_FLAG_OK; if (_list_->callbacks && _list_->callbacks->read) _list_->callbacks->read(); return _list_->buffer[_list_->count - 1]; @@ -210,11 +210,11 @@ size_t sl_min(struct sortedlist *_list_) { if (sl_empty(_list_)) { - _list_->flag = cmc_flags.EMPTY; + _list_->flag = CMC_FLAG_EMPTY; return (size_t){ 0 }; } sl_sort(_list_); - _list_->flag = cmc_flags.OK; + _list_->flag = CMC_FLAG_OK; if (_list_->callbacks && _list_->callbacks->read) _list_->callbacks->read(); return _list_->buffer[0]; @@ -223,23 +223,23 @@ size_t sl_get(struct sortedlist *_list_, size_t index) { if (sl_empty(_list_)) { - _list_->flag = cmc_flags.EMPTY; + _list_->flag = CMC_FLAG_EMPTY; return (size_t){ 0 }; } if (index >= _list_->count) { - _list_->flag = cmc_flags.RANGE; + _list_->flag = CMC_FLAG_RANGE; return (size_t){ 0 }; } sl_sort(_list_); - _list_->flag = cmc_flags.OK; + _list_->flag = CMC_FLAG_OK; if (_list_->callbacks && _list_->callbacks->read) _list_->callbacks->read(); return _list_->buffer[index]; } size_t sl_index_of(struct sortedlist *_list_, size_t value, _Bool from_start) { - _list_->flag = cmc_flags.OK; + _list_->flag = CMC_FLAG_OK; sl_sort(_list_); if (_list_->callbacks && _list_->callbacks->read) _list_->callbacks->read(); @@ -251,7 +251,7 @@ size_t sl_index_of(struct sortedlist *_list_, size_t value, _Bool from_start) } _Bool sl_contains(struct sortedlist *_list_, size_t value) { - _list_->flag = cmc_flags.OK; + _list_->flag = CMC_FLAG_OK; if (sl_empty(_list_)) return 0; sl_sort(_list_); @@ -285,27 +285,27 @@ _Bool sl_resize(struct sortedlist *_list_, size_t capacity) goto success; if (capacity < _list_->count) { - _list_->flag = cmc_flags.INVALID; + _list_->flag = CMC_FLAG_INVALID; return 0; } size_t *new_buffer = _list_->alloc->realloc(_list_->buffer, sizeof(size_t) * capacity); if (!new_buffer) { - _list_->flag = cmc_flags.ALLOC; + _list_->flag = CMC_FLAG_ALLOC; return 0; } _list_->buffer = new_buffer; _list_->capacity = capacity; success: - _list_->flag = cmc_flags.OK; + _list_->flag = CMC_FLAG_OK; if (_list_->callbacks && _list_->callbacks->resize) _list_->callbacks->resize(); return 1; } void sl_sort(struct sortedlist *_list_) { - _list_->flag = cmc_flags.OK; + _list_->flag = CMC_FLAG_OK; if (!_list_->is_sorted && _list_->count > 1) { sl_impl_sort_quicksort(_list_->buffer, _list_->f_val->cmp, 0, @@ -319,7 +319,7 @@ struct sortedlist *sl_copy_of(struct sortedlist *_list_) _list_->alloc, _list_->callbacks); if (!result) { - _list_->flag = cmc_flags.ERROR; + _list_->flag = CMC_FLAG_ERROR; return ((void *)0); } if (_list_->f_val->cpy) @@ -330,7 +330,7 @@ struct sortedlist *sl_copy_of(struct sortedlist *_list_) else memcpy(result->buffer, _list_->buffer, sizeof(size_t) * _list_->count); result->count = _list_->count; - _list_->flag = cmc_flags.OK; + _list_->flag = CMC_FLAG_OK; return result; } _Bool sl_equals(struct sortedlist *_list1_, struct sortedlist *_list2_) @@ -350,10 +350,12 @@ struct cmc_string sl_to_string(struct sortedlist *_list_) { struct cmc_string str; struct sortedlist *l_ = _list_; - int n = snprintf(str.s, cmc_string_len, cmc_string_fmt_sortedlist, - "sortedlist", "size_t", l_, l_->buffer, l_->capacity, - l_->count, l_->is_sorted ? "true" : "false", l_->flag, - l_->f_val, l_->alloc, l_->callbacks); + int n = + snprintf(str.s, cmc_string_len, cmc_cmc_string_fmt_sortedlist, + "CMC_PARAM_SNAME((sl, sortedlist, , , size_t))", + "CMC_PARAM_V((sl, sortedlist, , , size_t))", l_, l_->buffer, + l_->capacity, l_->count, l_->is_sorted ? "true" : "false", + l_->flag, l_->f_val, l_->alloc, l_->callbacks); return n >= 0 ? str : (struct cmc_string){ 0 }; } _Bool sl_print(struct sortedlist *_list_, FILE *fptr) diff --git a/tests/main/src/stack.c b/tests/main/src/stack.c index a0be8dd..b98f023 100644 --- a/tests/main/src/stack.c +++ b/tests/main/src/stack.c @@ -83,7 +83,7 @@ struct stack *s_new(size_t capacity, struct stack_fval *f_val) } _stack_->capacity = capacity; _stack_->count = 0; - _stack_->flag = cmc_flags.OK; + _stack_->flag = CMC_FLAG_OK; _stack_->f_val = f_val; _stack_->alloc = alloc; _stack_->callbacks = ((void *)0); @@ -110,7 +110,7 @@ struct stack *s_new_custom(size_t capacity, struct stack_fval *f_val, } _stack_->capacity = capacity; _stack_->count = 0; - _stack_->flag = cmc_flags.OK; + _stack_->flag = CMC_FLAG_OK; _stack_->f_val = f_val; _stack_->alloc = alloc; _stack_->callbacks = callbacks; @@ -125,7 +125,7 @@ void s_clear(struct stack *_stack_) } memset(_stack_->buffer, 0, sizeof(size_t) * _stack_->capacity); _stack_->count = 0; - _stack_->flag = cmc_flags.OK; + _stack_->flag = CMC_FLAG_OK; } void s_free(struct stack *_stack_) { @@ -145,7 +145,7 @@ void s_customize(struct stack *_stack_, struct cmc_alloc_node *alloc, else _stack_->alloc = alloc; _stack_->callbacks = callbacks; - _stack_->flag = cmc_flags.OK; + _stack_->flag = CMC_FLAG_OK; } _Bool s_push(struct stack *_stack_, size_t value) { @@ -155,7 +155,7 @@ _Bool s_push(struct stack *_stack_, size_t value) return 0; } _stack_->buffer[_stack_->count++] = value; - _stack_->flag = cmc_flags.OK; + _stack_->flag = CMC_FLAG_OK; if (_stack_->callbacks && _stack_->callbacks->create) _stack_->callbacks->create(); return 1; @@ -164,11 +164,11 @@ _Bool s_pop(struct stack *_stack_) { if (s_empty(_stack_)) { - _stack_->flag = cmc_flags.EMPTY; + _stack_->flag = CMC_FLAG_EMPTY; return 0; } _stack_->buffer[--_stack_->count] = (size_t){ 0 }; - _stack_->flag = cmc_flags.OK; + _stack_->flag = CMC_FLAG_OK; if (_stack_->callbacks && _stack_->callbacks->delete) _stack_->callbacks->delete (); return 1; @@ -177,17 +177,17 @@ size_t s_top(struct stack *_stack_) { if (s_empty(_stack_)) { - _stack_->flag = cmc_flags.EMPTY; + _stack_->flag = CMC_FLAG_EMPTY; return (size_t){ 0 }; } - _stack_->flag = cmc_flags.OK; + _stack_->flag = CMC_FLAG_OK; if (_stack_->callbacks && _stack_->callbacks->read) _stack_->callbacks->read(); return _stack_->buffer[_stack_->count - 1]; } _Bool s_contains(struct stack *_stack_, size_t value) { - _stack_->flag = cmc_flags.OK; + _stack_->flag = CMC_FLAG_OK; _Bool result = 0; for (size_t i = 0; i < _stack_->count; i++) { @@ -227,20 +227,20 @@ _Bool s_resize(struct stack *_stack_, size_t capacity) goto success; if (capacity < _stack_->count) { - _stack_->flag = cmc_flags.INVALID; + _stack_->flag = CMC_FLAG_INVALID; return 0; } size_t *new_buffer = _stack_->alloc->realloc(_stack_->buffer, sizeof(size_t) * capacity); if (!new_buffer) { - _stack_->flag = cmc_flags.ALLOC; + _stack_->flag = CMC_FLAG_ALLOC; return 0; } _stack_->buffer = new_buffer; _stack_->capacity = capacity; success: - _stack_->flag = cmc_flags.OK; + _stack_->flag = CMC_FLAG_OK; if (_stack_->callbacks && _stack_->callbacks->resize) _stack_->callbacks->resize(); return 1; @@ -251,7 +251,7 @@ struct stack *s_copy_of(struct stack *_stack_) _stack_->alloc, _stack_->callbacks); if (!result) { - _stack_->flag = cmc_flags.ERROR; + _stack_->flag = CMC_FLAG_ERROR; return ((void *)0); } if (_stack_->f_val->cpy) @@ -263,13 +263,13 @@ struct stack *s_copy_of(struct stack *_stack_) memcpy(result->buffer, _stack_->buffer, sizeof(size_t) * _stack_->count); result->count = _stack_->count; - _stack_->flag = cmc_flags.OK; + _stack_->flag = CMC_FLAG_OK; return result; } _Bool s_equals(struct stack *_stack1_, struct stack *_stack2_) { - _stack1_->flag = cmc_flags.OK; - _stack2_->flag = cmc_flags.OK; + _stack1_->flag = CMC_FLAG_OK; + _stack2_->flag = CMC_FLAG_OK; if (_stack1_->count != _stack2_->count) return 0; for (size_t i = 0; i < _stack1_->count; i++) @@ -283,9 +283,11 @@ struct cmc_string s_to_string(struct stack *_stack_) { struct cmc_string str; struct stack *s_ = _stack_; - int n = snprintf(str.s, cmc_string_len, cmc_string_fmt_stack, "stack", - "size_t", s_, s_->buffer, s_->capacity, s_->count, - s_->flag, s_->f_val, s_->alloc, s_->callbacks); + int n = snprintf(str.s, cmc_string_len, cmc_cmc_string_fmt_stack, + "CMC_PARAM_SNAME((s, stack, , , size_t))", + "CMC_PARAM_V((s, stack, , , size_t))", s_, s_->buffer, + s_->capacity, s_->count, s_->flag, s_->f_val, s_->alloc, + s_->callbacks); return n >= 0 ? str : (struct cmc_string){ 0 }; } _Bool s_print(struct stack *_stack_, FILE *fptr) diff --git a/tests/main/src/treemap.c b/tests/main/src/treemap.c index f30a722..66d955f 100644 --- a/tests/main/src/treemap.c +++ b/tests/main/src/treemap.c @@ -108,7 +108,7 @@ struct treemap *tm_new(struct treemap_fkey *f_key, struct treemap_fval *f_val) return ((void *)0); _map_->count = 0; _map_->root = ((void *)0); - _map_->flag = cmc_flags.OK; + _map_->flag = CMC_FLAG_OK; _map_->f_key = f_key; _map_->f_val = f_val; _map_->alloc = alloc; @@ -129,7 +129,7 @@ struct treemap *tm_new_custom(struct treemap_fkey *f_key, return ((void *)0); _map_->count = 0; _map_->root = ((void *)0); - _map_->flag = cmc_flags.OK; + _map_->flag = CMC_FLAG_OK; _map_->f_key = f_key; _map_->f_val = f_val; _map_->alloc = alloc; @@ -191,7 +191,7 @@ void tm_clear(struct treemap *_map_) } _map_->count = 0; _map_->root = ((void *)0); - _map_->flag = cmc_flags.OK; + _map_->flag = CMC_FLAG_OK; } void tm_free(struct treemap *_map_) { @@ -206,7 +206,7 @@ void tm_customize(struct treemap *_map_, struct cmc_alloc_node *alloc, else _map_->alloc = alloc; _map_->callbacks = callbacks; - _map_->flag = cmc_flags.OK; + _map_->flag = CMC_FLAG_OK; } _Bool tm_insert(struct treemap *_map_, size_t key, size_t value) { @@ -215,7 +215,7 @@ _Bool tm_insert(struct treemap *_map_, size_t key, size_t value) _map_->root = tm_impl_new_node(_map_, key, value); if (!_map_->root) { - _map_->flag = cmc_flags.ALLOC; + _map_->flag = CMC_FLAG_ALLOC; return 0; } } @@ -232,7 +232,7 @@ _Bool tm_insert(struct treemap *_map_, size_t key, size_t value) scan = scan->right; else { - _map_->flag = cmc_flags.DUPLICATE; + _map_->flag = CMC_FLAG_DUPLICATE; return 0; } } @@ -242,7 +242,7 @@ _Bool tm_insert(struct treemap *_map_, size_t key, size_t value) parent->left = tm_impl_new_node(_map_, key, value); if (!parent->left) { - _map_->flag = cmc_flags.ALLOC; + _map_->flag = CMC_FLAG_ALLOC; return 0; } parent->left->parent = parent; @@ -253,7 +253,7 @@ _Bool tm_insert(struct treemap *_map_, size_t key, size_t value) parent->right = tm_impl_new_node(_map_, key, value); if (!parent->right) { - _map_->flag = cmc_flags.ALLOC; + _map_->flag = CMC_FLAG_ALLOC; return 0; } parent->right->parent = parent; @@ -262,7 +262,7 @@ _Bool tm_insert(struct treemap *_map_, size_t key, size_t value) tm_impl_rebalance(_map_, node); } _map_->count++; - _map_->flag = cmc_flags.OK; + _map_->flag = CMC_FLAG_OK; if (_map_->callbacks && _map_->callbacks->create) _map_->callbacks->create(); return 1; @@ -273,13 +273,13 @@ _Bool tm_update(struct treemap *_map_, size_t key, size_t new_value, struct treemap_node *node = tm_impl_get_node(_map_, key); if (!node) { - _map_->flag = cmc_flags.NOT_FOUND; + _map_->flag = CMC_FLAG_NOT_FOUND; return 0; } if (old_value) *old_value = node->value; node->value = new_value; - _map_->flag = cmc_flags.OK; + _map_->flag = CMC_FLAG_OK; if (_map_->callbacks && _map_->callbacks->update) _map_->callbacks->update(); return 1; @@ -288,13 +288,13 @@ _Bool tm_remove(struct treemap *_map_, size_t key, size_t *out_value) { if (tm_empty(_map_)) { - _map_->flag = cmc_flags.EMPTY; + _map_->flag = CMC_FLAG_EMPTY; return 0; } struct treemap_node *node = tm_impl_get_node(_map_, key); if (!node) { - _map_->flag = cmc_flags.NOT_FOUND; + _map_->flag = CMC_FLAG_NOT_FOUND; return 0; } if (out_value) @@ -391,7 +391,7 @@ _Bool tm_remove(struct treemap *_map_, size_t key, size_t *out_value) if (_map_->count == 0) _map_->root = ((void *)0); _map_->count--; - _map_->flag = cmc_flags.OK; + _map_->flag = CMC_FLAG_OK; if (_map_->callbacks && _map_->callbacks->delete) _map_->callbacks->delete (); return 1; @@ -400,7 +400,7 @@ _Bool tm_max(struct treemap *_map_, size_t *key, size_t *value) { if (tm_empty(_map_)) { - _map_->flag = cmc_flags.EMPTY; + _map_->flag = CMC_FLAG_EMPTY; return 0; } struct treemap_node *scan = _map_->root; @@ -410,7 +410,7 @@ _Bool tm_max(struct treemap *_map_, size_t *key, size_t *value) *key = scan->key; if (value) *value = scan->value; - _map_->flag = cmc_flags.OK; + _map_->flag = CMC_FLAG_OK; if (_map_->callbacks && _map_->callbacks->read) _map_->callbacks->read(); return 1; @@ -419,7 +419,7 @@ _Bool tm_min(struct treemap *_map_, size_t *key, size_t *value) { if (tm_empty(_map_)) { - _map_->flag = cmc_flags.EMPTY; + _map_->flag = CMC_FLAG_EMPTY; return 0; } struct treemap_node *scan = _map_->root; @@ -429,7 +429,7 @@ _Bool tm_min(struct treemap *_map_, size_t *key, size_t *value) *key = scan->key; if (value) *value = scan->value; - _map_->flag = cmc_flags.OK; + _map_->flag = CMC_FLAG_OK; if (_map_->callbacks && _map_->callbacks->read) _map_->callbacks->read(); return 1; @@ -438,16 +438,16 @@ size_t tm_get(struct treemap *_map_, size_t key) { if (tm_empty(_map_)) { - _map_->flag = cmc_flags.EMPTY; + _map_->flag = CMC_FLAG_EMPTY; return 0; } struct treemap_node *node = tm_impl_get_node(_map_, key); if (!node) { - _map_->flag = cmc_flags.NOT_FOUND; + _map_->flag = CMC_FLAG_NOT_FOUND; return (size_t){ 0 }; } - _map_->flag = cmc_flags.OK; + _map_->flag = CMC_FLAG_OK; if (_map_->callbacks && _map_->callbacks->read) _map_->callbacks->read(); return node->value; @@ -456,16 +456,16 @@ size_t *tm_get_ref(struct treemap *_map_, size_t key) { if (tm_empty(_map_)) { - _map_->flag = cmc_flags.EMPTY; + _map_->flag = CMC_FLAG_EMPTY; return 0; } struct treemap_node *node = tm_impl_get_node(_map_, key); if (!node) { - _map_->flag = cmc_flags.NOT_FOUND; + _map_->flag = CMC_FLAG_NOT_FOUND; return ((void *)0); } - _map_->flag = cmc_flags.OK; + _map_->flag = CMC_FLAG_OK; if (_map_->callbacks && _map_->callbacks->read) _map_->callbacks->read(); return &(node->value); @@ -495,7 +495,7 @@ struct treemap *tm_copy_of(struct treemap *_map_) tm_new_custom(_map_->f_key, _map_->f_val, _map_->alloc, ((void *)0)); if (!result) { - _map_->flag = cmc_flags.ERROR; + _map_->flag = CMC_FLAG_ERROR; return ((void *)0); } struct treemap_iter iter = tm_iter_start(_map_); @@ -510,13 +510,13 @@ struct treemap *tm_copy_of(struct treemap *_map_) tm_insert(result, key, value); } result->callbacks = _map_->callbacks; - _map_->flag = cmc_flags.OK; + _map_->flag = CMC_FLAG_OK; return result; } _Bool tm_equals(struct treemap *_map1_, struct treemap *_map2_) { - _map1_->flag = cmc_flags.OK; - _map2_->flag = cmc_flags.OK; + _map1_->flag = CMC_FLAG_OK; + _map2_->flag = CMC_FLAG_OK; if (_map1_->count != _map2_->count) return 0; struct treemap_iter iter = tm_iter_start(_map1_); @@ -535,9 +535,12 @@ struct cmc_string tm_to_string(struct treemap *_map_) { struct cmc_string str; struct treemap *m_ = _map_; - int n = snprintf(str.s, cmc_string_len, cmc_string_fmt_treemap, "treemap", - "size_t", "size_t", m_, m_->root, m_->count, m_->flag, - m_->f_key, m_->f_val, m_->alloc, m_->callbacks); + int n = snprintf(str.s, cmc_string_len, cmc_cmc_string_fmt_treemap, + "CMC_PARAM_SNAME((tm, treemap, , size_t, size_t))", + "CMC_PARAM_K((tm, treemap, , size_t, size_t))", + "CMC_PARAM_V((tm, treemap, , size_t, size_t))", m_, + m_->root, m_->count, m_->flag, m_->f_key, m_->f_val, + m_->alloc, m_->callbacks); return n >= 0 ? str : (struct cmc_string){ 0 }; } _Bool tm_print(struct treemap *_map_, FILE *fptr) diff --git a/tests/main/src/treeset.c b/tests/main/src/treeset.c index 517b40a..9952dc2 100644 --- a/tests/main/src/treeset.c +++ b/tests/main/src/treeset.c @@ -107,7 +107,7 @@ struct treeset *ts_new(struct treeset_fval *f_val) return ((void *)0); _set_->count = 0; _set_->root = ((void *)0); - _set_->flag = cmc_flags.OK; + _set_->flag = CMC_FLAG_OK; _set_->f_val = f_val; _set_->alloc = alloc; _set_->callbacks = ((void *)0); @@ -126,7 +126,7 @@ struct treeset *ts_new_custom(struct treeset_fval *f_val, return ((void *)0); _set_->count = 0; _set_->root = ((void *)0); - _set_->flag = cmc_flags.OK; + _set_->flag = CMC_FLAG_OK; _set_->f_val = f_val; _set_->alloc = alloc; _set_->callbacks = callbacks; @@ -183,7 +183,7 @@ void ts_clear(struct treeset *_set_) } _set_->count = 0; _set_->root = ((void *)0); - _set_->flag = cmc_flags.OK; + _set_->flag = CMC_FLAG_OK; } void ts_free(struct treeset *_set_) { @@ -198,7 +198,7 @@ void ts_customize(struct treeset *_set_, struct cmc_alloc_node *alloc, else _set_->alloc = alloc; _set_->callbacks = callbacks; - _set_->flag = cmc_flags.OK; + _set_->flag = CMC_FLAG_OK; } _Bool ts_insert(struct treeset *_set_, size_t value) { @@ -207,7 +207,7 @@ _Bool ts_insert(struct treeset *_set_, size_t value) _set_->root = ts_impl_new_node(_set_, value); if (!_set_->root) { - _set_->flag = cmc_flags.ALLOC; + _set_->flag = CMC_FLAG_ALLOC; return 0; } } @@ -224,7 +224,7 @@ _Bool ts_insert(struct treeset *_set_, size_t value) scan = scan->right; else { - _set_->flag = cmc_flags.DUPLICATE; + _set_->flag = CMC_FLAG_DUPLICATE; return 0; } } @@ -234,7 +234,7 @@ _Bool ts_insert(struct treeset *_set_, size_t value) parent->left = ts_impl_new_node(_set_, value); if (!parent->left) { - _set_->flag = cmc_flags.ALLOC; + _set_->flag = CMC_FLAG_ALLOC; return 0; } parent->left->parent = parent; @@ -245,7 +245,7 @@ _Bool ts_insert(struct treeset *_set_, size_t value) parent->right = ts_impl_new_node(_set_, value); if (!parent->right) { - _set_->flag = cmc_flags.ALLOC; + _set_->flag = CMC_FLAG_ALLOC; return 0; } parent->right->parent = parent; @@ -254,7 +254,7 @@ _Bool ts_insert(struct treeset *_set_, size_t value) ts_impl_rebalance(_set_, node); } _set_->count++; - _set_->flag = cmc_flags.OK; + _set_->flag = CMC_FLAG_OK; if (_set_->callbacks && _set_->callbacks->create) _set_->callbacks->create(); return 1; @@ -263,13 +263,13 @@ _Bool ts_remove(struct treeset *_set_, size_t value) { if (ts_empty(_set_)) { - _set_->flag = cmc_flags.EMPTY; + _set_->flag = CMC_FLAG_EMPTY; return 0; } struct treeset_node *node = ts_impl_get_node(_set_, value); if (!node) { - _set_->flag = cmc_flags.NOT_FOUND; + _set_->flag = CMC_FLAG_NOT_FOUND; return 0; } struct treeset_node *temp = ((void *)0), *unbalanced = ((void *)0); @@ -362,7 +362,7 @@ _Bool ts_remove(struct treeset *_set_, size_t value) if (_set_->count == 0) _set_->root = ((void *)0); _set_->count--; - _set_->flag = cmc_flags.OK; + _set_->flag = CMC_FLAG_OK; if (_set_->callbacks && _set_->callbacks->delete) _set_->callbacks->delete (); return 1; @@ -371,7 +371,7 @@ _Bool ts_max(struct treeset *_set_, size_t *value) { if (ts_empty(_set_)) { - _set_->flag = cmc_flags.EMPTY; + _set_->flag = CMC_FLAG_EMPTY; return 0; } struct treeset_node *scan = _set_->root; @@ -379,7 +379,7 @@ _Bool ts_max(struct treeset *_set_, size_t *value) scan = scan->right; if (value) *value = scan->value; - _set_->flag = cmc_flags.OK; + _set_->flag = CMC_FLAG_OK; if (_set_->callbacks && _set_->callbacks->read) _set_->callbacks->read(); return 1; @@ -388,7 +388,7 @@ _Bool ts_min(struct treeset *_set_, size_t *value) { if (ts_empty(_set_)) { - _set_->flag = cmc_flags.EMPTY; + _set_->flag = CMC_FLAG_EMPTY; return 0; } struct treeset_node *scan = _set_->root; @@ -396,7 +396,7 @@ _Bool ts_min(struct treeset *_set_, size_t *value) scan = scan->left; if (value) *value = scan->value; - _set_->flag = cmc_flags.OK; + _set_->flag = CMC_FLAG_OK; if (_set_->callbacks && _set_->callbacks->read) _set_->callbacks->read(); return 1; @@ -426,7 +426,7 @@ struct treeset *ts_copy_of(struct treeset *_set_) ts_new_custom(_set_->f_val, _set_->alloc, _set_->callbacks); if (!result) { - _set_->flag = cmc_flags.ERROR; + _set_->flag = CMC_FLAG_ERROR; return ((void *)0); } if (!ts_empty(_set_)) @@ -440,13 +440,13 @@ struct treeset *ts_copy_of(struct treeset *_set_) ts_insert(result, ts_iter_value(&iter)); } } - _set_->flag = cmc_flags.OK; + _set_->flag = CMC_FLAG_OK; return result; } _Bool ts_equals(struct treeset *_set1_, struct treeset *_set2_) { - _set1_->flag = cmc_flags.OK; - _set2_->flag = cmc_flags.OK; + _set1_->flag = CMC_FLAG_OK; + _set2_->flag = CMC_FLAG_OK; if (_set1_->count != _set2_->count) return 0; struct treeset_iter iter = ts_iter_start(_set1_); @@ -461,9 +461,10 @@ struct cmc_string ts_to_string(struct treeset *_set_) { struct cmc_string str; struct treeset *s_ = _set_; - int n = snprintf(str.s, cmc_string_len, cmc_string_fmt_treeset, "treeset", - "size_t", s_, s_->root, s_->count, s_->flag, s_->f_val, - s_->alloc, s_->callbacks); + int n = snprintf(str.s, cmc_string_len, cmc_cmc_string_fmt_treeset, + "CMC_PARAM_SNAME((ts, treeset, , , size_t))", + "CMC_PARAM_V((ts, treeset, , , size_t))", s_, s_->root, + s_->count, s_->flag, s_->f_val, s_->alloc, s_->callbacks); return n >= 0 ? str : (struct cmc_string){ 0 }; } _Bool ts_print(struct treeset *_set_, FILE *fptr) diff --git a/tests/main/unt/bitset.c b/tests/main/unt/bitset.c index 85c61b9..7c39da6 100644 --- a/tests/main/unt/bitset.c +++ b/tests/main/unt/bitset.c @@ -106,19 +106,19 @@ CMC_CREATE_UNIT(BitSet, true, { cmc_assert_not_equals(ptr, NULL, bs); - bs->flag = cmc_flags.ERROR; + bs->flag = CMC_FLAG_ERROR; bs_customize(bs, bs_alloc_node, callbacks); cmc_assert_equals(ptr, bs_alloc_node, bs->alloc); cmc_assert_equals(ptr, callbacks, bs->callbacks); - cmc_assert_equals(int32_t, cmc_flags.OK, bs->flag); + cmc_assert_equals(int32_t, CMC_FLAG_OK, bs->flag); - bs->flag = cmc_flags.ERROR; + bs->flag = CMC_FLAG_ERROR; bs_customize(bs, NULL, NULL); cmc_assert_equals(ptr, &cmc_alloc_node_default, bs->alloc); cmc_assert_equals(ptr, NULL, bs->callbacks); - cmc_assert_equals(int32_t, cmc_flags.OK, bs->flag); + cmc_assert_equals(int32_t, CMC_FLAG_OK, bs->flag); bs_free(bs); }); @@ -129,10 +129,10 @@ CMC_CREATE_UNIT(BitSet, true, { cmc_assert_not_equals(ptr, NULL, bs); cmc_assert_equals(CMC_BITSET_WORD_TYPE, 0, bs->buffer[0]); - bs->flag = cmc_flags.ERROR; + bs->flag = CMC_FLAG_ERROR; cmc_assert(bs_set(bs, 0)); cmc_assert_equals(CMC_BITSET_WORD_TYPE, 1, bs->buffer[0]); - cmc_assert_equals(int32_t, cmc_flags.OK, bs->flag); + cmc_assert_equals(int32_t, CMC_FLAG_OK, bs->flag); bs->buffer[0] = 0; @@ -160,13 +160,13 @@ CMC_CREATE_UNIT(BitSet, true, { cmc_assert_not_equals(ptr, NULL, bs); cmc_assert_equals(CMC_BITSET_WORD_TYPE, 0, bs->buffer[0]); - bs->flag = cmc_flags.ERROR; + bs->flag = CMC_FLAG_ERROR; cmc_assert(bs_set_range(bs, 0, 0)); cmc_assert_equals(uint8_t, 1, bs->buffer[0]); - cmc_assert_equals(int32_t, cmc_flags.OK, bs->flag); + cmc_assert_equals(int32_t, CMC_FLAG_OK, bs->flag); cmc_assert(!bs_set_range(bs, 1, 0)); - cmc_assert_equals(int32_t, cmc_flags.INVALID, bs->flag); + cmc_assert_equals(int32_t, CMC_FLAG_INVALID, bs->flag); bs->buffer[0] = 0; @@ -231,7 +231,7 @@ CMC_CREATE_UNIT(BitSet, true, { cmc_assert_equals(CMC_BITSET_WORD_TYPE, 0, bs->buffer[0]); cmc_assert(!bs_clear_range(bs, 1, 0)); - cmc_assert_equals(int32_t, cmc_flags.INVALID, bs->flag); + cmc_assert_equals(int32_t, CMC_FLAG_INVALID, bs->flag); cmc_assert(bs_clear_range(bs, 0, word_bits * 100 - 1)); cmc_assert_equals(size_t, 100, bs->capacity); diff --git a/tests/main/unt/deque.c b/tests/main/unt/deque.c index c46374d..5706294 100644 --- a/tests/main/unt/deque.c +++ b/tests/main/unt/deque.c @@ -32,7 +32,7 @@ CMC_CREATE_UNIT(Deque, true, { cmc_assert_equals(size_t, 0, d->count); cmc_assert_equals(size_t, 0, d->front); cmc_assert_equals(size_t, 0, d->back); - cmc_assert_equals(int32_t, cmc_flags.OK, d->flag); + cmc_assert_equals(int32_t, CMC_FLAG_OK, d->flag); cmc_assert_equals(ptr, d_fval, d->f_val); cmc_assert_equals(ptr, &cmc_alloc_node_default, d->alloc); cmc_assert_equals(ptr, NULL, d->callbacks); @@ -59,7 +59,7 @@ CMC_CREATE_UNIT(Deque, true, { cmc_assert_equals(size_t, 0, d->count); cmc_assert_equals(size_t, 0, d->front); cmc_assert_equals(size_t, 0, d->back); - cmc_assert_equals(int32_t, cmc_flags.OK, d->flag); + cmc_assert_equals(int32_t, CMC_FLAG_OK, d->flag); cmc_assert_equals(ptr, d_fval, d->f_val); cmc_assert_equals(ptr, d_alloc_node, d->alloc); cmc_assert_equals(ptr, callbacks, d->callbacks); @@ -76,74 +76,74 @@ CMC_CREATE_UNIT(Deque, true, { cmc_assert_equals(ptr, NULL, d); }); - CMC_CREATE_TEST(PFX##_init(), { - struct deque d = d_init(1000000, d_fval); + // CMC_CREATE_TEST(PFX##_init(), { + // struct deque d = d_init(1000000, d_fval); - cmc_assert_not_equals(ptr, NULL, d.buffer); - cmc_assert_equals(size_t, 1000000, d.capacity); - cmc_assert_equals(size_t, 0, d.count); - cmc_assert_equals(size_t, 0, d.front); - cmc_assert_equals(size_t, 0, d.back); - cmc_assert_equals(int32_t, cmc_flags.OK, d.flag); - cmc_assert_equals(ptr, d_fval, d.f_val); - cmc_assert_equals(ptr, &cmc_alloc_node_default, d.alloc); - cmc_assert_equals(ptr, NULL, d.callbacks); + // cmc_assert_not_equals(ptr, NULL, d.buffer); + // cmc_assert_equals(size_t, 1000000, d.capacity); + // cmc_assert_equals(size_t, 0, d.count); + // cmc_assert_equals(size_t, 0, d.front); + // cmc_assert_equals(size_t, 0, d.back); + // cmc_assert_equals(int32_t, CMC_FLAG_OK, d.flag); + // cmc_assert_equals(ptr, d_fval, d.f_val); + // cmc_assert_equals(ptr, &cmc_alloc_node_default, d.alloc); + // cmc_assert_equals(ptr, NULL, d.callbacks); - d_release(d); + // d_release(d); - d = d_init(0, d_fval); + // d = d_init(0, d_fval); - cmc_assert_equals(size_t, 0, d.capacity); - cmc_assert_equals(ptr, NULL, d.buffer); + // cmc_assert_equals(size_t, 0, d.capacity); + // cmc_assert_equals(ptr, NULL, d.buffer); - d = d_init(1000, NULL); + // d = d_init(1000, NULL); - cmc_assert_equals(size_t, 0, d.capacity); - cmc_assert_equals(ptr, NULL, d.buffer); + // cmc_assert_equals(size_t, 0, d.capacity); + // cmc_assert_equals(ptr, NULL, d.buffer); - d = d_init(UINT64_MAX, d_fval); + // d = d_init(UINT64_MAX, d_fval); - cmc_assert_equals(size_t, 0, d.capacity); - cmc_assert_equals(ptr, NULL, d.buffer); + // cmc_assert_equals(size_t, 0, d.capacity); + // cmc_assert_equals(ptr, NULL, d.buffer); - if (d.buffer) - d_release(d); - }); + // if (d.buffer) + // d_release(d); + // }); - CMC_CREATE_TEST(PFX##_init_custom(), { - struct deque d = - d_init_custom(1000000, d_fval, d_alloc_node, callbacks); + // CMC_CREATE_TEST(PFX##_init_custom(), { + // struct deque d = + // d_init_custom(1000000, d_fval, d_alloc_node, callbacks); - cmc_assert_not_equals(ptr, NULL, d.buffer); - cmc_assert_equals(size_t, 1000000, d.capacity); - cmc_assert_equals(size_t, 0, d.count); - cmc_assert_equals(size_t, 0, d.front); - cmc_assert_equals(size_t, 0, d.back); - cmc_assert_equals(int32_t, cmc_flags.OK, d.flag); - cmc_assert_equals(ptr, d_fval, d.f_val); - cmc_assert_equals(ptr, d_alloc_node, d.alloc); - cmc_assert_equals(ptr, callbacks, d.callbacks); + // cmc_assert_not_equals(ptr, NULL, d.buffer); + // cmc_assert_equals(size_t, 1000000, d.capacity); + // cmc_assert_equals(size_t, 0, d.count); + // cmc_assert_equals(size_t, 0, d.front); + // cmc_assert_equals(size_t, 0, d.back); + // cmc_assert_equals(int32_t, CMC_FLAG_OK, d.flag); + // cmc_assert_equals(ptr, d_fval, d.f_val); + // cmc_assert_equals(ptr, d_alloc_node, d.alloc); + // cmc_assert_equals(ptr, callbacks, d.callbacks); - d_release(d); + // d_release(d); - d = d_init_custom(0, d_fval, d_alloc_node, callbacks); + // d = d_init_custom(0, d_fval, d_alloc_node, callbacks); - cmc_assert_equals(size_t, 0, d.capacity); - cmc_assert_equals(ptr, NULL, d.buffer); + // cmc_assert_equals(size_t, 0, d.capacity); + // cmc_assert_equals(ptr, NULL, d.buffer); - d = d_init_custom(1000, NULL, d_alloc_node, callbacks); + // d = d_init_custom(1000, NULL, d_alloc_node, callbacks); - cmc_assert_equals(size_t, 0, d.capacity); - cmc_assert_equals(ptr, NULL, d.buffer); + // cmc_assert_equals(size_t, 0, d.capacity); + // cmc_assert_equals(ptr, NULL, d.buffer); - d = d_init_custom(UINT64_MAX, d_fval, d_alloc_node, callbacks); + // d = d_init_custom(UINT64_MAX, d_fval, d_alloc_node, callbacks); - cmc_assert_equals(size_t, 0, d.capacity); - cmc_assert_equals(ptr, NULL, d.buffer); + // cmc_assert_equals(size_t, 0, d.capacity); + // cmc_assert_equals(ptr, NULL, d.buffer); - if (d.buffer) - d_release(d); - }); + // if (d.buffer) + // d_release(d); + // }); CMC_CREATE_TEST(PFX##_clear(), { v_total_free = 0; @@ -156,11 +156,11 @@ CMC_CREATE_UNIT(Deque, true, { cmc_assert_equals(size_t, 50, d_count(d)); - d->flag = cmc_flags.ERROR; + d->flag = CMC_FLAG_ERROR; d_clear(d); cmc_assert_equals(size_t, 50, v_total_free); - cmc_assert_equals(int32_t, cmc_flags.OK, d_flag(d)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, d_flag(d)); cmc_assert_equals(size_t, 0, d_count(d)); cmc_assert_equals(size_t, 100, d_capacity(d)); @@ -182,11 +182,11 @@ CMC_CREATE_UNIT(Deque, true, { cmc_assert_equals(size_t, 500500, sum); - d->flag = cmc_flags.ERROR; + d->flag = CMC_FLAG_ERROR; d_clear(d); cmc_assert_equals(size_t, 1050, v_total_free); - cmc_assert_equals(int32_t, cmc_flags.OK, d_flag(d)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, d_flag(d)); sum = 0; for (size_t i = 0; i < d->capacity; i++) @@ -232,55 +232,55 @@ CMC_CREATE_UNIT(Deque, true, { v_total_free = 0; }); - CMC_CREATE_TEST(PFX##_release(), { - v_total_free = 0; + // CMC_CREATE_TEST(PFX##_release(), { + // v_total_free = 0; - struct deque d = d_init(100, d_fval_counter); + // struct deque d = d_init(100, d_fval_counter); - cmc_assert_not_equals(ptr, NULL, d.buffer); + // cmc_assert_not_equals(ptr, NULL, d.buffer); - for (size_t i = 1; i <= 1000; i++) - { - if (i % 2 == 0) - d_push_front(&d, i); - else - d_push_back(&d, i); - } + // for (size_t i = 1; i <= 1000; i++) + // { + // if (i % 2 == 0) + // d_push_front(&d, i); + // else + // d_push_back(&d, i); + // } - cmc_assert_equals(size_t, 1000, d_count(&d)); + // cmc_assert_equals(size_t, 1000, d_count(&d)); - size_t sum = 0; - for (size_t i = d.front, j = 0; j < d.count; - i = (i + 1) % d.capacity, j++) - sum += d.buffer[i]; + // size_t sum = 0; + // for (size_t i = d.front, j = 0; j < d.count; + // i = (i + 1) % d.capacity, j++) + // sum += d.buffer[i]; - cmc_assert_equals(size_t, 500500, sum); + // cmc_assert_equals(size_t, 500500, sum); - d_release(d); + // d_release(d); - cmc_assert_equals(size_t, 1000, v_total_free); + // cmc_assert_equals(size_t, 1000, v_total_free); - v_total_free = 0; - }); + // v_total_free = 0; + // }); CMC_CREATE_TEST(PFX##_customize(), { struct deque *d = d_new(100, d_fval); cmc_assert_not_equals(ptr, NULL, d); - d->flag = cmc_flags.ERROR; + d->flag = CMC_FLAG_ERROR; d_customize(d, d_alloc_node, callbacks); cmc_assert_equals(ptr, d_alloc_node, d->alloc); cmc_assert_equals(ptr, callbacks, d->callbacks); - cmc_assert_equals(int32_t, cmc_flags.OK, d_flag(d)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, d_flag(d)); - d->flag = cmc_flags.ERROR; + d->flag = CMC_FLAG_ERROR; d_customize(d, NULL, NULL); cmc_assert_equals(ptr, &cmc_alloc_node_default, d->alloc); cmc_assert_equals(ptr, NULL, d->callbacks); - cmc_assert_equals(int32_t, cmc_flags.OK, d_flag(d)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, d_flag(d)); d_free(d); }); @@ -291,12 +291,12 @@ CMC_CREATE_UNIT(Deque, true, { cmc_assert_not_equals(ptr, NULL, d); - d->flag = cmc_flags.ERROR; + d->flag = CMC_FLAG_ERROR; cmc_assert(d_push_front(d, 10)); cmc_assert_equals(size_t, 1, d_count(d)); cmc_assert_equals(int32_t, 1, total_create); - cmc_assert_equals(int32_t, cmc_flags.OK, d_flag(d)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, d_flag(d)); d_customize(d, NULL, NULL); @@ -339,12 +339,12 @@ CMC_CREATE_UNIT(Deque, true, { cmc_assert_not_equals(ptr, NULL, d); - d->flag = cmc_flags.ERROR; + d->flag = CMC_FLAG_ERROR; cmc_assert(d_push_front(d, 10)); cmc_assert_equals(size_t, 1, d_count(d)); cmc_assert_equals(int32_t, 1, total_create); - cmc_assert_equals(int32_t, cmc_flags.OK, d_flag(d)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, d_flag(d)); d_customize(d, NULL, NULL); @@ -387,14 +387,14 @@ CMC_CREATE_UNIT(Deque, true, { cmc_assert_not_equals(ptr, NULL, d); cmc_assert(!d_pop_front(d)); - cmc_assert_equals(int32_t, cmc_flags.EMPTY, d_flag(d)); + cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, d_flag(d)); cmc_assert(d_push_front(d, 10)); - d->flag = cmc_flags.ERROR; + d->flag = CMC_FLAG_ERROR; cmc_assert(d_pop_front(d)); cmc_assert_equals(size_t, 0, d_count(d)); - cmc_assert_equals(int32_t, cmc_flags.OK, d_flag(d)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, d_flag(d)); cmc_assert(d_push_back(d, 10)); cmc_assert(d_pop_front(d)); @@ -454,14 +454,14 @@ CMC_CREATE_UNIT(Deque, true, { cmc_assert_not_equals(ptr, NULL, d); cmc_assert(!d_pop_back(d)); - cmc_assert_equals(int32_t, cmc_flags.EMPTY, d_flag(d)); + cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, d_flag(d)); cmc_assert(d_push_front(d, 10)); - d->flag = cmc_flags.ERROR; + d->flag = CMC_FLAG_ERROR; cmc_assert(d_pop_back(d)); cmc_assert_equals(size_t, 0, d_count(d)); - cmc_assert_equals(int32_t, cmc_flags.OK, d_flag(d)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, d_flag(d)); cmc_assert(d_push_back(d, 10)); cmc_assert(d_pop_back(d)); @@ -520,13 +520,13 @@ CMC_CREATE_UNIT(Deque, true, { d_front(d); - cmc_assert_equals(int32_t, cmc_flags.EMPTY, d_flag(d)); + cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, d_flag(d)); cmc_assert(d_push_front(d, 99)); - d->flag = cmc_flags.ERROR; + d->flag = CMC_FLAG_ERROR; cmc_assert_equals(size_t, 99, d_front(d)); - cmc_assert_equals(int32_t, cmc_flags.OK, d_flag(d)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, d_flag(d)); cmc_assert(d_push_back(d, 98)); cmc_assert_equals(size_t, 99, d_front(d)); @@ -573,13 +573,13 @@ CMC_CREATE_UNIT(Deque, true, { d_back(d); - cmc_assert_equals(int32_t, cmc_flags.EMPTY, d_flag(d)); + cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, d_flag(d)); cmc_assert(d_push_back(d, 99)); - d->flag = cmc_flags.ERROR; + d->flag = CMC_FLAG_ERROR; cmc_assert_equals(size_t, 99, d_back(d)); - cmc_assert_equals(int32_t, cmc_flags.OK, d_flag(d)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, d_flag(d)); cmc_assert(d_push_front(d, 98)); cmc_assert_equals(size_t, 99, d_back(d)); @@ -754,7 +754,7 @@ CMC_CREATE_UNIT(Deque, true, { cmc_assert_not_equals(ptr, NULL, d); cmc_assert_equals(size_t, 100, d_capacity(d)); - d->flag = cmc_flags.ERROR; + d->flag = CMC_FLAG_ERROR; cmc_assert(d_resize(d, 100)); cmc_assert_equals(size_t, 100, d_capacity(d)); @@ -781,7 +781,7 @@ CMC_CREATE_UNIT(Deque, true, { cmc_assert_equals(size_t, 150, d_capacity(d)); cmc_assert(!d_resize(d, d_count(d) - 10)); - cmc_assert_equals(int32_t, cmc_flags.INVALID, d_flag(d)); + cmc_assert_equals(int32_t, CMC_FLAG_INVALID, d_flag(d)); d_free(d); @@ -1107,82 +1107,82 @@ CMC_CREATE_UNIT(Deque, true, { struct deque *d = d_new(100, d_fval); cmc_assert_not_equals(ptr, NULL, d); - cmc_assert_equals(int32_t, cmc_flags.OK, d_flag(d)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, d_flag(d)); // customize - d->flag = cmc_flags.ERROR; + d->flag = CMC_FLAG_ERROR; d_customize(d, &cmc_alloc_node_default, &(struct cmc_callbacks){ 0 }); - cmc_assert_equals(int32_t, cmc_flags.OK, d_flag(d)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, d_flag(d)); // push_front - d->flag = cmc_flags.ERROR; + d->flag = CMC_FLAG_ERROR; cmc_assert(d_push_front(d, 1)); - cmc_assert_equals(int32_t, cmc_flags.OK, d_flag(d)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, d_flag(d)); // pop_front - d->flag = cmc_flags.ERROR; + d->flag = CMC_FLAG_ERROR; cmc_assert(d_pop_front(d)); - cmc_assert_equals(int32_t, cmc_flags.OK, d_flag(d)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, d_flag(d)); cmc_assert(!d_pop_front(d)); - cmc_assert_equals(int32_t, cmc_flags.EMPTY, d_flag(d)); + cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, d_flag(d)); // push_back cmc_assert(d_push_back(d, 1)); - cmc_assert_equals(int32_t, cmc_flags.OK, d_flag(d)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, d_flag(d)); // pop_back - d->flag = cmc_flags.ERROR; + d->flag = CMC_FLAG_ERROR; cmc_assert(d_pop_back(d)); - cmc_assert_equals(int32_t, cmc_flags.OK, d_flag(d)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, d_flag(d)); cmc_assert(!d_pop_back(d)); - cmc_assert_equals(int32_t, cmc_flags.EMPTY, d_flag(d)); + cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, d_flag(d)); // front - d->flag = cmc_flags.ERROR; + d->flag = CMC_FLAG_ERROR; cmc_assert(d_front(d) == 0); - cmc_assert_equals(int32_t, cmc_flags.EMPTY, d_flag(d)); + cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, d_flag(d)); cmc_assert(d_push_back(d, 1)); - d->flag = cmc_flags.ERROR; + d->flag = CMC_FLAG_ERROR; cmc_assert(d_front(d) == 1); - cmc_assert_equals(int32_t, cmc_flags.OK, d_flag(d)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, d_flag(d)); // clear - d->flag = cmc_flags.ERROR; + d->flag = CMC_FLAG_ERROR; d_clear(d); - cmc_assert_equals(int32_t, cmc_flags.OK, d_flag(d)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, d_flag(d)); // back cmc_assert(d_back(d) == 0); - cmc_assert_equals(int32_t, cmc_flags.EMPTY, d_flag(d)); + cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, d_flag(d)); cmc_assert(d_push_front(d, 1)); cmc_assert(d_back(d) == 1); - cmc_assert_equals(int32_t, cmc_flags.OK, d_flag(d)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, d_flag(d)); // contains - d->flag = cmc_flags.ERROR; + d->flag = CMC_FLAG_ERROR; cmc_assert(d_contains(d, 1)); - cmc_assert_equals(int32_t, cmc_flags.OK, d_flag(d)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, d_flag(d)); // copy_of - d->flag = cmc_flags.ERROR; + d->flag = CMC_FLAG_ERROR; struct deque *d2 = d_copy_of(d); - cmc_assert_equals(int32_t, cmc_flags.OK, d_flag(d)); - cmc_assert_equals(int32_t, cmc_flags.OK, d_flag(d2)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, d_flag(d)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, d_flag(d2)); // equals cmc_assert(d_pop_back(d)); cmc_assert(d_pop_back(d2)); - d->flag = cmc_flags.ERROR; - d2->flag = cmc_flags.ERROR; + d->flag = CMC_FLAG_ERROR; + d2->flag = CMC_FLAG_ERROR; d_front(d); d_front(d2); - cmc_assert_equals(int32_t, cmc_flags.EMPTY, d_flag(d)); - cmc_assert_equals(int32_t, cmc_flags.EMPTY, d_flag(d2)); + cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, d_flag(d)); + cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, d_flag(d2)); cmc_assert(d_equals(d, d2)); - cmc_assert_equals(int32_t, cmc_flags.OK, d_flag(d)); - cmc_assert_equals(int32_t, cmc_flags.OK, d_flag(d2)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, d_flag(d)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, d_flag(d2)); d_free(d); d_free(d2); diff --git a/tests/main/unt/hashbidimap.c b/tests/main/unt/hashbidimap.c index d9342a1..40f139f 100644 --- a/tests/main/unt/hashbidimap.c +++ b/tests/main/unt/hashbidimap.c @@ -48,7 +48,7 @@ CMC_CREATE_UNIT(HashBidiMap, true, { cmc_assert_not_equals(ptr, NULL, map->buffer); cmc_assert_equals(size_t, 0, map->count); cmc_assert_equals(double, 0.6, map->load); - cmc_assert_equals(int32_t, cmc_flags.OK, map->flag); + cmc_assert_equals(int32_t, CMC_FLAG_OK, map->flag); cmc_assert_equals(ptr, hbm_fkey, map->f_key); cmc_assert_equals(ptr, hbm_fval, map->f_val); cmc_assert_equals(ptr, &cmc_alloc_node_default, map->alloc); @@ -94,7 +94,7 @@ CMC_CREATE_UNIT(HashBidiMap, true, { cmc_assert_not_equals(ptr, NULL, map->buffer); cmc_assert_equals(size_t, 0, map->count); cmc_assert_equals(double, 0.6, map->load); - cmc_assert_equals(int32_t, cmc_flags.OK, map->flag); + cmc_assert_equals(int32_t, CMC_FLAG_OK, map->flag); cmc_assert_equals(ptr, hbm_fkey, map->f_key); cmc_assert_equals(ptr, hbm_fval, map->f_val); cmc_assert_equals(ptr, hbm_alloc_node, map->alloc); @@ -133,11 +133,11 @@ CMC_CREATE_UNIT(HashBidiMap, true, { cmc_assert_equals(size_t, 1000, map->count); - map->flag = cmc_flags.ERROR; + map->flag = CMC_FLAG_ERROR; hbm_clear(map); cmc_assert_equals(size_t, 0, map->count); - cmc_assert_equals(int32_t, cmc_flags.OK, map->flag); + cmc_assert_equals(int32_t, CMC_FLAG_OK, map->flag); cmc_assert_equals(int32_t, 1000, k_total_free); cmc_assert_equals(int32_t, 1000, v_total_free); @@ -365,7 +365,7 @@ CMC_CREATE_UNIT(HashBidiMap, true, { cmc_assert(!hbm_update_key(map, 1, 1)); - cmc_assert_equals(int32_t, cmc_flags.EMPTY, hbm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, hbm_flag(map)); hbm_free(map); }); @@ -379,21 +379,21 @@ CMC_CREATE_UNIT(HashBidiMap, true, { cmc_assert_equals(size_t, 1, hbm_count(map)); - map->flag = cmc_flags.ERROR; + map->flag = CMC_FLAG_ERROR; cmc_assert(hbm_update_key(map, 1, 1)); - cmc_assert_equals(int32_t, cmc_flags.OK, hbm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, hbm_flag(map)); cmc_assert(!hbm_update_key(map, 2, 2)); - cmc_assert_equals(int32_t, cmc_flags.NOT_FOUND, hbm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_NOT_FOUND, hbm_flag(map)); cmc_assert(hbm_insert(map, 2, 2)); cmc_assert(!hbm_update_key(map, 1, 2)); - cmc_assert_equals(int32_t, cmc_flags.DUPLICATE, hbm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_DUPLICATE, hbm_flag(map)); cmc_assert(!hbm_update_key(map, 2, 1)); - cmc_assert_equals(int32_t, cmc_flags.DUPLICATE, hbm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_DUPLICATE, hbm_flag(map)); cmc_assert(hbm_update_key(map, 2, 2)); @@ -432,7 +432,7 @@ CMC_CREATE_UNIT(HashBidiMap, true, { cmc_assert(!hbm_update_val(map, 1, 1)); - cmc_assert_equals(int32_t, cmc_flags.EMPTY, hbm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, hbm_flag(map)); hbm_free(map); }); @@ -446,21 +446,21 @@ CMC_CREATE_UNIT(HashBidiMap, true, { cmc_assert_equals(size_t, 1, hbm_count(map)); - map->flag = cmc_flags.ERROR; + map->flag = CMC_FLAG_ERROR; cmc_assert(hbm_update_val(map, 1, 1)); - cmc_assert_equals(int32_t, cmc_flags.OK, hbm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, hbm_flag(map)); cmc_assert(!hbm_update_val(map, 2, 2)); - cmc_assert_equals(int32_t, cmc_flags.NOT_FOUND, hbm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_NOT_FOUND, hbm_flag(map)); cmc_assert(hbm_insert(map, 2, 2)); cmc_assert(!hbm_update_val(map, 1, 2)); - cmc_assert_equals(int32_t, cmc_flags.DUPLICATE, hbm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_DUPLICATE, hbm_flag(map)); cmc_assert(!hbm_update_val(map, 2, 1)); - cmc_assert_equals(int32_t, cmc_flags.DUPLICATE, hbm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_DUPLICATE, hbm_flag(map)); cmc_assert(hbm_update_val(map, 2, 2)); @@ -598,133 +598,133 @@ CMC_CREATE_UNIT(HashBidiMap, true, { struct hashbidimap *map = hbm_new(100, 0.7, hbm_fkey, hbm_fval); cmc_assert_not_equals(ptr, NULL, map); - cmc_assert_equals(int32_t, cmc_flags.OK, hbm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, hbm_flag(map)); // customize hbm_customize(map, &cmc_alloc_node_default, &(struct cmc_callbacks){ 0 }); - cmc_assert_equals(int32_t, cmc_flags.OK, hbm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, hbm_flag(map)); // Insert cmc_assert(hbm_insert(map, 1, 1)); - cmc_assert_equals(int32_t, cmc_flags.OK, hbm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, hbm_flag(map)); cmc_assert(!hbm_insert(map, 1, 2)); - cmc_assert_equals(int32_t, cmc_flags.DUPLICATE, hbm_flag(map)); - map->flag = cmc_flags.ERROR; + cmc_assert_equals(int32_t, CMC_FLAG_DUPLICATE, hbm_flag(map)); + map->flag = CMC_FLAG_ERROR; cmc_assert(!hbm_insert(map, 2, 1)); - cmc_assert_equals(int32_t, cmc_flags.DUPLICATE, hbm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_DUPLICATE, hbm_flag(map)); // clear hbm_clear(map); - cmc_assert_equals(int32_t, cmc_flags.OK, hbm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, hbm_flag(map)); // hbm_update_key cmc_assert(!hbm_update_key(map, 1, 1)); - cmc_assert_equals(int32_t, cmc_flags.EMPTY, hbm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, hbm_flag(map)); cmc_assert(hbm_insert(map, 1, 1)); cmc_assert(!hbm_update_key(map, 2, 1)); - cmc_assert_equals(int32_t, cmc_flags.NOT_FOUND, hbm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_NOT_FOUND, hbm_flag(map)); cmc_assert(hbm_insert(map, 2, 2)); cmc_assert(!hbm_update_key(map, 2, 1)); - cmc_assert_equals(int32_t, cmc_flags.DUPLICATE, hbm_flag(map)); - map->flag = cmc_flags.ERROR; + cmc_assert_equals(int32_t, CMC_FLAG_DUPLICATE, hbm_flag(map)); + map->flag = CMC_FLAG_ERROR; cmc_assert(!hbm_update_key(map, 1, 2)); - cmc_assert_equals(int32_t, cmc_flags.DUPLICATE, hbm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_DUPLICATE, hbm_flag(map)); // clear hbm_clear(map); - cmc_assert_equals(int32_t, cmc_flags.OK, hbm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, hbm_flag(map)); // hbm_update_val cmc_assert(!hbm_update_val(map, 1, 1)); - cmc_assert_equals(int32_t, cmc_flags.EMPTY, hbm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, hbm_flag(map)); cmc_assert(hbm_insert(map, 1, 1)); cmc_assert(!hbm_update_val(map, 2, 1)); - cmc_assert_equals(int32_t, cmc_flags.NOT_FOUND, hbm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_NOT_FOUND, hbm_flag(map)); cmc_assert(hbm_insert(map, 2, 2)); cmc_assert(!hbm_update_val(map, 2, 1)); - cmc_assert_equals(int32_t, cmc_flags.DUPLICATE, hbm_flag(map)); - map->flag = cmc_flags.ERROR; + cmc_assert_equals(int32_t, CMC_FLAG_DUPLICATE, hbm_flag(map)); + map->flag = CMC_FLAG_ERROR; cmc_assert(!hbm_update_val(map, 1, 2)); - cmc_assert_equals(int32_t, cmc_flags.DUPLICATE, hbm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_DUPLICATE, hbm_flag(map)); // remove_by_key cmc_assert(hbm_remove_by_key(map, 1, NULL, NULL)); - cmc_assert_equals(int32_t, cmc_flags.OK, hbm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, hbm_flag(map)); cmc_assert(!hbm_remove_by_key(map, 1, NULL, NULL)); - cmc_assert_equals(int32_t, cmc_flags.NOT_FOUND, hbm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_NOT_FOUND, hbm_flag(map)); cmc_assert(hbm_remove_by_key(map, 2, NULL, NULL)); cmc_assert(!hbm_remove_by_key(map, 2, NULL, NULL)); - cmc_assert_equals(int32_t, cmc_flags.EMPTY, hbm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, hbm_flag(map)); // remove_by_val cmc_assert(hbm_insert(map, 1, 1) && hbm_insert(map, 2, 2)); cmc_assert(hbm_remove_by_val(map, 1, NULL, NULL)); - cmc_assert_equals(int32_t, cmc_flags.OK, hbm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, hbm_flag(map)); cmc_assert(!hbm_remove_by_val(map, 1, NULL, NULL)); - cmc_assert_equals(int32_t, cmc_flags.NOT_FOUND, hbm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_NOT_FOUND, hbm_flag(map)); cmc_assert(hbm_remove_by_val(map, 2, NULL, NULL)); cmc_assert(!hbm_remove_by_val(map, 2, NULL, NULL)); - cmc_assert_equals(int32_t, cmc_flags.EMPTY, hbm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, hbm_flag(map)); // get_key and get_val cmc_assert(hbm_insert(map, 2, 1)); cmc_assert_equals(size_t, 2, hbm_get_key(map, 1)); - cmc_assert_equals(int32_t, cmc_flags.OK, hbm_flag(map)); - map->flag = cmc_flags.ERROR; + cmc_assert_equals(int32_t, CMC_FLAG_OK, hbm_flag(map)); + map->flag = CMC_FLAG_ERROR; cmc_assert_equals(size_t, 1, hbm_get_val(map, 2)); - cmc_assert_equals(int32_t, cmc_flags.OK, hbm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, hbm_flag(map)); cmc_assert_equals(size_t, 0, hbm_get_key(map, 2)); - cmc_assert_equals(int32_t, cmc_flags.NOT_FOUND, hbm_flag(map)); - map->flag = cmc_flags.ERROR; + cmc_assert_equals(int32_t, CMC_FLAG_NOT_FOUND, hbm_flag(map)); + map->flag = CMC_FLAG_ERROR; cmc_assert_equals(size_t, 0, hbm_get_val(map, 1)); - cmc_assert_equals(int32_t, cmc_flags.NOT_FOUND, hbm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_NOT_FOUND, hbm_flag(map)); // contains_key cmc_assert(hbm_contains_key(map, 2)); - cmc_assert_equals(int32_t, cmc_flags.OK, hbm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, hbm_flag(map)); // contains_val - map->flag = cmc_flags.ERROR; + map->flag = CMC_FLAG_ERROR; cmc_assert(hbm_contains_val(map, 1)); - cmc_assert_equals(int32_t, cmc_flags.OK, hbm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, hbm_flag(map)); // copy_of - map->flag = cmc_flags.ERROR; + map->flag = CMC_FLAG_ERROR; struct hashbidimap *map2 = hbm_copy_of(map); - cmc_assert_equals(int32_t, cmc_flags.OK, hbm_flag(map2)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, hbm_flag(map2)); size_t tmp = map->capacity; map->capacity = 0; struct hashbidimap *map3 = hbm_copy_of(map); cmc_assert_equals(ptr, NULL, map3); - cmc_assert_equals(int32_t, cmc_flags.ERROR, hbm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_ERROR, hbm_flag(map)); map->capacity = tmp; // equals hbm_get_key(map, 100); hbm_get_key(map2, 100); - cmc_assert_equals(int32_t, cmc_flags.NOT_FOUND, hbm_flag(map)); - cmc_assert_equals(int32_t, cmc_flags.NOT_FOUND, hbm_flag(map2)); - map->flag = cmc_flags.ERROR; + cmc_assert_equals(int32_t, CMC_FLAG_NOT_FOUND, hbm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_NOT_FOUND, hbm_flag(map2)); + map->flag = CMC_FLAG_ERROR; cmc_assert(hbm_equals(map, map2)); - cmc_assert_equals(int32_t, cmc_flags.OK, hbm_flag(map)); - cmc_assert_equals(int32_t, cmc_flags.OK, hbm_flag(map2)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, hbm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, hbm_flag(map2)); hbm_free(map); hbm_free(map2); diff --git a/tests/main/unt/hashmap.c b/tests/main/unt/hashmap.c index f43e576..e2406a5 100644 --- a/tests/main/unt/hashmap.c +++ b/tests/main/unt/hashmap.c @@ -44,7 +44,7 @@ CMC_CREATE_UNIT(HashMap, true, { cmc_assert_not_equals(ptr, NULL, map->buffer); cmc_assert_equals(size_t, 0, map->count); cmc_assert_equals(double, 0.6, map->load); - cmc_assert_equals(int32_t, cmc_flags.OK, map->flag); + cmc_assert_equals(int32_t, CMC_FLAG_OK, map->flag); cmc_assert_equals(ptr, hm_fkey, map->f_key); cmc_assert_equals(ptr, hm_fval, map->f_val); cmc_assert_equals(ptr, &cmc_alloc_node_default, map->alloc); @@ -78,7 +78,7 @@ CMC_CREATE_UNIT(HashMap, true, { cmc_assert_not_equals(ptr, NULL, map->buffer); cmc_assert_equals(size_t, 0, map->count); cmc_assert_equals(double, 0.6, map->load); - cmc_assert_equals(int32_t, cmc_flags.OK, map->flag); + cmc_assert_equals(int32_t, CMC_FLAG_OK, map->flag); cmc_assert_equals(ptr, hm_fkey, map->f_key); cmc_assert_equals(ptr, hm_fval, map->f_val); cmc_assert_equals(ptr, hm_alloc_node, map->alloc); @@ -104,70 +104,70 @@ CMC_CREATE_UNIT(HashMap, true, { cmc_assert_equals(ptr, NULL, map); }); - CMC_CREATE_TEST(PFX##_init(), { - struct hashmap map = hm_init(943722, 0.6, hm_fkey, hm_fval); + // CMC_CREATE_TEST(PFX##_init(), { + // struct hashmap map = hm_init(943722, 0.6, hm_fkey, hm_fval); - cmc_assert_not_equals(ptr, NULL, map.buffer); - cmc_assert_equals(size_t, 0, map.count); - cmc_assert_equals(double, 0.6, map.load); - cmc_assert_equals(int32_t, cmc_flags.OK, map.flag); - cmc_assert_equals(ptr, hm_fkey, map.f_key); - cmc_assert_equals(ptr, hm_fval, map.f_val); - cmc_assert_equals(ptr, &cmc_alloc_node_default, map.alloc); - cmc_assert_equals(ptr, NULL, map.callbacks); + // cmc_assert_not_equals(ptr, NULL, map.buffer); + // cmc_assert_equals(size_t, 0, map.count); + // cmc_assert_equals(double, 0.6, map.load); + // cmc_assert_equals(int32_t, CMC_FLAG_OK, map.flag); + // cmc_assert_equals(ptr, hm_fkey, map.f_key); + // cmc_assert_equals(ptr, hm_fval, map.f_val); + // cmc_assert_equals(ptr, &cmc_alloc_node_default, map.alloc); + // cmc_assert_equals(ptr, NULL, map.callbacks); - cmc_assert_greater_equals(size_t, (943722 / 0.6), hm_capacity(&map)); + // cmc_assert_greater_equals(size_t, (943722 / 0.6), hm_capacity(&map)); - hm_release(map); + // hm_release(map); - map = hm_init(0, 0.6, hm_fkey, hm_fval); - cmc_assert_equals(ptr, NULL, map.buffer); + // map = hm_init(0, 0.6, hm_fkey, hm_fval); + // cmc_assert_equals(ptr, NULL, map.buffer); - map = hm_init(UINT64_MAX, 0.99, hm_fkey, hm_fval); - cmc_assert_equals(ptr, NULL, map.buffer); + // map = hm_init(UINT64_MAX, 0.99, hm_fkey, hm_fval); + // cmc_assert_equals(ptr, NULL, map.buffer); - map = hm_init(1000, 0.6, hm_fkey, NULL); - cmc_assert_equals(ptr, NULL, map.buffer); + // map = hm_init(1000, 0.6, hm_fkey, NULL); + // cmc_assert_equals(ptr, NULL, map.buffer); - map = hm_init(1000, 0.6, NULL, hm_fval); - cmc_assert_equals(ptr, NULL, map.buffer); + // map = hm_init(1000, 0.6, NULL, hm_fval); + // cmc_assert_equals(ptr, NULL, map.buffer); - map = hm_init(1000, 0.6, NULL, NULL); - cmc_assert_equals(ptr, NULL, map.buffer); - }); + // map = hm_init(1000, 0.6, NULL, NULL); + // cmc_assert_equals(ptr, NULL, map.buffer); + // }); - CMC_CREATE_TEST(PFX##_init_custom(), { - struct hashmap map = hm_init_custom(943722, 0.6, hm_fkey, hm_fval, - hm_alloc_node, callbacks); + // CMC_CREATE_TEST(PFX##_init_custom(), { + // struct hashmap map = hm_init_custom(943722, 0.6, hm_fkey, hm_fval, + // hm_alloc_node, callbacks); - cmc_assert_not_equals(ptr, NULL, map.buffer); - cmc_assert_equals(size_t, 0, map.count); - cmc_assert_equals(double, 0.6, map.load); - cmc_assert_equals(int32_t, cmc_flags.OK, map.flag); - cmc_assert_equals(ptr, hm_fkey, map.f_key); - cmc_assert_equals(ptr, hm_fval, map.f_val); - cmc_assert_equals(ptr, hm_alloc_node, map.alloc); - cmc_assert_equals(ptr, callbacks, map.callbacks); + // cmc_assert_not_equals(ptr, NULL, map.buffer); + // cmc_assert_equals(size_t, 0, map.count); + // cmc_assert_equals(double, 0.6, map.load); + // cmc_assert_equals(int32_t, CMC_FLAG_OK, map.flag); + // cmc_assert_equals(ptr, hm_fkey, map.f_key); + // cmc_assert_equals(ptr, hm_fval, map.f_val); + // cmc_assert_equals(ptr, hm_alloc_node, map.alloc); + // cmc_assert_equals(ptr, callbacks, map.callbacks); - cmc_assert_greater_equals(size_t, (943722 / 0.6), hm_capacity(&map)); + // cmc_assert_greater_equals(size_t, (943722 / 0.6), hm_capacity(&map)); - hm_release(map); + // hm_release(map); - map = hm_init_custom(0, 0.6, hm_fkey, hm_fval, NULL, NULL); - cmc_assert_equals(ptr, NULL, map.buffer); + // map = hm_init_custom(0, 0.6, hm_fkey, hm_fval, NULL, NULL); + // cmc_assert_equals(ptr, NULL, map.buffer); - map = hm_init_custom(UINT64_MAX, 0.99, hm_fkey, hm_fval, NULL, NULL); - cmc_assert_equals(ptr, NULL, map.buffer); + // map = hm_init_custom(UINT64_MAX, 0.99, hm_fkey, hm_fval, NULL, NULL); + // cmc_assert_equals(ptr, NULL, map.buffer); - map = hm_init_custom(1000, 0.6, hm_fkey, NULL, NULL, NULL); - cmc_assert_equals(ptr, NULL, map.buffer); + // map = hm_init_custom(1000, 0.6, hm_fkey, NULL, NULL, NULL); + // cmc_assert_equals(ptr, NULL, map.buffer); - map = hm_init_custom(1000, 0.6, NULL, hm_fval, NULL, NULL); - cmc_assert_equals(ptr, NULL, map.buffer); + // map = hm_init_custom(1000, 0.6, NULL, hm_fval, NULL, NULL); + // cmc_assert_equals(ptr, NULL, map.buffer); - map = hm_init_custom(1000, 0.6, NULL, NULL, NULL, NULL); - cmc_assert_equals(ptr, NULL, map.buffer); - }); + // map = hm_init_custom(1000, 0.6, NULL, NULL, NULL, NULL); + // cmc_assert_equals(ptr, NULL, map.buffer); + // }); CMC_CREATE_TEST(PFX##_clear(), { k_total_free = 0; @@ -186,11 +186,11 @@ CMC_CREATE_UNIT(HashMap, true, { cmc_assert_equals(size_t, 100, *r); - map->flag = cmc_flags.ERROR; + map->flag = CMC_FLAG_ERROR; hm_clear(map); cmc_assert_equals(size_t, 0, map->count); - cmc_assert_equals(int32_t, cmc_flags.OK, map->flag); + cmc_assert_equals(int32_t, CMC_FLAG_OK, map->flag); cmc_assert_equals(int32_t, 1000, k_total_free); cmc_assert_equals(int32_t, 1000, v_total_free); @@ -233,54 +233,54 @@ CMC_CREATE_UNIT(HashMap, true, { v_total_free = 0; }); - CMC_CREATE_TEST(PFX##_release(), { - k_total_free = 0; - v_total_free = 0; - struct hashmap map = - hm_init(100, 0.6, hm_fkey_counter, hm_fval_counter); + // CMC_CREATE_TEST(PFX##_release(), { + // k_total_free = 0; + // v_total_free = 0; + // struct hashmap map = + // hm_init(100, 0.6, hm_fkey_counter, hm_fval_counter); - cmc_assert_not_equals(ptr, NULL, map.buffer); + // cmc_assert_not_equals(ptr, NULL, map.buffer); - for (size_t i = 1; i <= 1000; i++) - hm_insert(&map, i, i); + // for (size_t i = 1; i <= 1000; i++) + // hm_insert(&map, i, i); - cmc_assert_equals(size_t, 1000, map.count); + // cmc_assert_equals(size_t, 1000, map.count); - hm_release(map); + // hm_release(map); - cmc_assert_equals(int32_t, 1000, k_total_free); - cmc_assert_equals(int32_t, 1000, v_total_free); + // cmc_assert_equals(int32_t, 1000, k_total_free); + // cmc_assert_equals(int32_t, 1000, v_total_free); - map = hm_init(1000, 0.6, hm_fkey_counter, hm_fval_counter); + // map = hm_init(1000, 0.6, hm_fkey_counter, hm_fval_counter); - cmc_assert_not_equals(ptr, NULL, map.buffer); + // cmc_assert_not_equals(ptr, NULL, map.buffer); - hm_release(map); + // hm_release(map); - cmc_assert_equals(int32_t, 1000, k_total_free); - cmc_assert_equals(int32_t, 1000, v_total_free); - k_total_free = 0; - v_total_free = 0; - }); + // cmc_assert_equals(int32_t, 1000, k_total_free); + // cmc_assert_equals(int32_t, 1000, v_total_free); + // k_total_free = 0; + // v_total_free = 0; + // }); CMC_CREATE_TEST(PFX##_customize(), { struct hashmap *map = hm_new(100, 0.6, hm_fkey, hm_fval); cmc_assert_not_equals(ptr, NULL, map); - map->flag = cmc_flags.ERROR; + map->flag = CMC_FLAG_ERROR; hm_customize(map, hm_alloc_node, callbacks); cmc_assert_equals(ptr, hm_alloc_node, map->alloc); cmc_assert_equals(ptr, callbacks, map->callbacks); - cmc_assert_equals(int32_t, cmc_flags.OK, map->flag); + cmc_assert_equals(int32_t, CMC_FLAG_OK, map->flag); - map->flag = cmc_flags.ERROR; + map->flag = CMC_FLAG_ERROR; hm_customize(map, NULL, NULL); cmc_assert_equals(ptr, &cmc_alloc_node_default, map->alloc); cmc_assert_equals(ptr, NULL, map->callbacks); - cmc_assert_equals(int32_t, cmc_flags.OK, map->flag); + cmc_assert_equals(int32_t, CMC_FLAG_OK, map->flag); hm_free(map); }); @@ -290,9 +290,9 @@ CMC_CREATE_UNIT(HashMap, true, { cmc_assert_not_equals(ptr, NULL, map); - map->flag = cmc_flags.ERROR; + map->flag = CMC_FLAG_ERROR; cmc_assert(hm_insert(map, 1, 1)); - cmc_assert_equals(int32_t, cmc_flags.OK, map->flag); + cmc_assert_equals(int32_t, CMC_FLAG_OK, map->flag); cmc_assert_equals(size_t, 1, hm_count(map)); hm_free(map); @@ -705,92 +705,92 @@ CMC_CREATE_UNIT(HashMap, true, { struct hashmap *map = hm_new(100, 0.6, hm_fkey, hm_fval); cmc_assert_not_equals(ptr, NULL, map); - cmc_assert_equals(int32_t, cmc_flags.OK, hm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, hm_flag(map)); // insert cmc_assert(hm_insert(map, 1, 1)); - cmc_assert_equals(int32_t, cmc_flags.OK, hm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, hm_flag(map)); cmc_assert(!hm_insert(map, 1, 2)); - cmc_assert_equals(int32_t, cmc_flags.DUPLICATE, hm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_DUPLICATE, hm_flag(map)); // clear hm_clear(map); - cmc_assert_equals(int32_t, cmc_flags.OK, hm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, hm_flag(map)); // update cmc_assert(!hm_update(map, 1, 2, NULL)); - cmc_assert_equals(int32_t, cmc_flags.EMPTY, hm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, hm_flag(map)); cmc_assert(hm_insert(map, 1, 1)); - cmc_assert_equals(int32_t, cmc_flags.OK, hm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, hm_flag(map)); cmc_assert(!hm_update(map, 2, 1, NULL)); - cmc_assert_equals(int32_t, cmc_flags.NOT_FOUND, hm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_NOT_FOUND, hm_flag(map)); cmc_assert(hm_update(map, 1, 2, NULL)); - cmc_assert_equals(int32_t, cmc_flags.OK, hm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, hm_flag(map)); // remove cmc_assert(!hm_remove(map, 2, NULL)); - cmc_assert_equals(int32_t, cmc_flags.NOT_FOUND, hm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_NOT_FOUND, hm_flag(map)); cmc_assert(hm_remove(map, 1, NULL)); - cmc_assert_equals(int32_t, cmc_flags.OK, hm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, hm_flag(map)); cmc_assert(!hm_remove(map, 1, NULL)); - cmc_assert_equals(int32_t, cmc_flags.EMPTY, hm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, hm_flag(map)); // max cmc_assert(hm_insert(map, 1, 1)); cmc_assert(hm_max(map, NULL, NULL)); - cmc_assert_equals(int32_t, cmc_flags.OK, hm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, hm_flag(map)); cmc_assert(hm_remove(map, 1, NULL)); cmc_assert(!hm_max(map, NULL, NULL)); - cmc_assert_equals(int32_t, cmc_flags.EMPTY, hm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, hm_flag(map)); // min cmc_assert(hm_insert(map, 1, 1)); cmc_assert(hm_min(map, NULL, NULL)); - cmc_assert_equals(int32_t, cmc_flags.OK, hm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, hm_flag(map)); cmc_assert(hm_remove(map, 1, NULL)); cmc_assert(!hm_min(map, NULL, NULL)); - cmc_assert_equals(int32_t, cmc_flags.EMPTY, hm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, hm_flag(map)); // get hm_get(map, 1); - cmc_assert_equals(int32_t, cmc_flags.EMPTY, hm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, hm_flag(map)); cmc_assert(hm_insert(map, 1, 1)); hm_get(map, 1); - cmc_assert_equals(int32_t, cmc_flags.OK, hm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, hm_flag(map)); hm_get(map, 2); - cmc_assert_equals(int32_t, cmc_flags.NOT_FOUND, hm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_NOT_FOUND, hm_flag(map)); hm_clear(map); // get_ref hm_get_ref(map, 1); - cmc_assert_equals(int32_t, cmc_flags.EMPTY, hm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, hm_flag(map)); cmc_assert(hm_insert(map, 1, 1)); hm_get_ref(map, 1); - cmc_assert_equals(int32_t, cmc_flags.OK, hm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, hm_flag(map)); hm_get_ref(map, 2); - cmc_assert_equals(int32_t, cmc_flags.NOT_FOUND, hm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_NOT_FOUND, hm_flag(map)); // contains hm_contains(map, 1); - cmc_assert_equals(int32_t, cmc_flags.OK, hm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, hm_flag(map)); // copy struct hashmap *map2 = hm_copy_of(map); - cmc_assert_equals(int32_t, cmc_flags.OK, hm_flag(map)); - cmc_assert_equals(int32_t, cmc_flags.OK, hm_flag(map2)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, hm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, hm_flag(map2)); size_t tmp = map->capacity; map->capacity = 0; @@ -798,13 +798,13 @@ CMC_CREATE_UNIT(HashMap, true, { struct hashmap *map3 = hm_copy_of(map); cmc_assert_equals(ptr, NULL, map3); - cmc_assert_equals(int32_t, cmc_flags.ERROR, hm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_ERROR, hm_flag(map)); map->capacity = tmp; cmc_assert(hm_equals(map, map2)); - cmc_assert_equals(int32_t, cmc_flags.OK, hm_flag(map)); - cmc_assert_equals(int32_t, cmc_flags.OK, hm_flag(map2)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, hm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, hm_flag(map2)); hm_free(map); hm_free(map2); diff --git a/tests/main/unt/hashmultimap.c b/tests/main/unt/hashmultimap.c index dfacb6a..647d804 100644 --- a/tests/main/unt/hashmultimap.c +++ b/tests/main/unt/hashmultimap.c @@ -48,7 +48,7 @@ CMC_CREATE_UNIT(HashMultiMap, true, { cmc_assert_not_equals(ptr, NULL, map->buffer); cmc_assert_equals(size_t, 0, map->count); cmc_assert_equals(double, 0.6, map->load); - cmc_assert_equals(int32_t, cmc_flags.OK, map->flag); + cmc_assert_equals(int32_t, CMC_FLAG_OK, map->flag); cmc_assert_equals(ptr, hmm_fkey, map->f_key); cmc_assert_equals(ptr, hmm_fval, map->f_val); cmc_assert_equals(ptr, &cmc_alloc_node_default, map->alloc); @@ -94,7 +94,7 @@ CMC_CREATE_UNIT(HashMultiMap, true, { cmc_assert_not_equals(ptr, NULL, map->buffer); cmc_assert_equals(size_t, 0, map->count); cmc_assert_equals(double, 0.6, map->load); - cmc_assert_equals(int32_t, cmc_flags.OK, map->flag); + cmc_assert_equals(int32_t, CMC_FLAG_OK, map->flag); cmc_assert_equals(ptr, hmm_fkey, map->f_key); cmc_assert_equals(ptr, hmm_fval, map->f_val); cmc_assert_equals(ptr, hmm_alloc_node, map->alloc); @@ -133,11 +133,11 @@ CMC_CREATE_UNIT(HashMultiMap, true, { cmc_assert_equals(size_t, 1000, map->count); - map->flag = cmc_flags.ERROR; + map->flag = CMC_FLAG_ERROR; hmm_clear(map); cmc_assert_equals(size_t, 0, map->count); - cmc_assert_equals(int32_t, cmc_flags.OK, map->flag); + cmc_assert_equals(int32_t, CMC_FLAG_OK, map->flag); cmc_assert_equals(int32_t, 1000, k_total_free); cmc_assert_equals(int32_t, 1000, v_total_free); @@ -263,117 +263,117 @@ CMC_CREATE_UNIT(HashMultiMap, true, { struct hashmultimap *map = hmm_new(100, 0.8, hmm_fkey, hmm_fval); cmc_assert_not_equals(ptr, NULL, map); - cmc_assert_equals(int32_t, cmc_flags.OK, hmm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, hmm_flag(map)); // clear - map->flag = cmc_flags.ERROR; + map->flag = CMC_FLAG_ERROR; hmm_clear(map); - cmc_assert_equals(int32_t, cmc_flags.OK, hmm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, hmm_flag(map)); // customize - map->flag = cmc_flags.ERROR; + map->flag = CMC_FLAG_ERROR; hmm_customize(map, NULL, NULL); - cmc_assert_equals(int32_t, cmc_flags.OK, hmm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, hmm_flag(map)); // insert - map->flag = cmc_flags.ERROR; + map->flag = CMC_FLAG_ERROR; cmc_assert(hmm_insert(map, 1, 1)); - cmc_assert_equals(int32_t, cmc_flags.OK, hmm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, hmm_flag(map)); // update cmc_assert(!hmm_update(map, 9, 10, NULL)); - cmc_assert_equals(int32_t, cmc_flags.NOT_FOUND, hmm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_NOT_FOUND, hmm_flag(map)); cmc_assert(hmm_update(map, 1, 20, NULL)); - cmc_assert_equals(int32_t, cmc_flags.OK, hmm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, hmm_flag(map)); // update_all - map->flag = cmc_flags.ERROR; + map->flag = CMC_FLAG_ERROR; cmc_assert_equals(size_t, 1, hmm_update_all(map, 1, 2, NULL)); - cmc_assert_equals(int32_t, cmc_flags.OK, hmm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, hmm_flag(map)); - map->flag = cmc_flags.ERROR; + map->flag = CMC_FLAG_ERROR; cmc_assert_equals(size_t, 0, hmm_update_all(map, 2, 4, NULL)); - cmc_assert_equals(int32_t, cmc_flags.NOT_FOUND, hmm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_NOT_FOUND, hmm_flag(map)); hmm_clear(map); cmc_assert_equals(size_t, 0, hmm_update_all(map, 1, 2, NULL)); - cmc_assert_equals(int32_t, cmc_flags.EMPTY, hmm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, hmm_flag(map)); // remove - map->flag = cmc_flags.ERROR; + map->flag = CMC_FLAG_ERROR; cmc_assert(!hmm_remove(map, 1, NULL)); - cmc_assert_equals(int32_t, cmc_flags.EMPTY, hmm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, hmm_flag(map)); cmc_assert(hmm_insert(map, 1, 1)); cmc_assert(!hmm_remove(map, 2, NULL)); - cmc_assert_equals(int32_t, cmc_flags.NOT_FOUND, hmm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_NOT_FOUND, hmm_flag(map)); cmc_assert(hmm_remove(map, 1, NULL)); - cmc_assert_equals(int32_t, cmc_flags.OK, hmm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, hmm_flag(map)); // remove_all cmc_assert(!hmm_remove_all(map, 1, NULL)); - cmc_assert_equals(int32_t, cmc_flags.EMPTY, hmm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, hmm_flag(map)); cmc_assert(hmm_insert(map, 1, 1) && hmm_insert(map, 1, 1)); cmc_assert_equals(size_t, 0, hmm_remove_all(map, 2, NULL)); - cmc_assert_equals(int32_t, cmc_flags.NOT_FOUND, hmm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_NOT_FOUND, hmm_flag(map)); cmc_assert_equals(size_t, 2, hmm_remove_all(map, 1, NULL)); - cmc_assert_equals(int32_t, cmc_flags.OK, hmm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, hmm_flag(map)); // max min cmc_assert(!hmm_max(map, NULL, NULL)); - cmc_assert_equals(int32_t, cmc_flags.EMPTY, hmm_flag(map)); - map->flag = cmc_flags.ERROR; + cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, hmm_flag(map)); + map->flag = CMC_FLAG_ERROR; cmc_assert(!hmm_min(map, NULL, NULL)); - cmc_assert_equals(int32_t, cmc_flags.EMPTY, hmm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, hmm_flag(map)); cmc_assert(hmm_insert(map, 1, 1)); cmc_assert(hmm_max(map, NULL, NULL)); - cmc_assert_equals(int32_t, cmc_flags.OK, hmm_flag(map)); - map->flag = cmc_flags.ERROR; + cmc_assert_equals(int32_t, CMC_FLAG_OK, hmm_flag(map)); + map->flag = CMC_FLAG_ERROR; cmc_assert(hmm_min(map, NULL, NULL)); - cmc_assert_equals(int32_t, cmc_flags.OK, hmm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, hmm_flag(map)); // get get_ref hmm_get(map, 2); - cmc_assert_equals(int32_t, cmc_flags.NOT_FOUND, hmm_flag(map)); - map->flag = cmc_flags.ERROR; + cmc_assert_equals(int32_t, CMC_FLAG_NOT_FOUND, hmm_flag(map)); + map->flag = CMC_FLAG_ERROR; hmm_get_ref(map, 2); - cmc_assert_equals(int32_t, cmc_flags.NOT_FOUND, hmm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_NOT_FOUND, hmm_flag(map)); hmm_get(map, 1); - cmc_assert_equals(int32_t, cmc_flags.OK, hmm_flag(map)); - map->flag = cmc_flags.ERROR; + cmc_assert_equals(int32_t, CMC_FLAG_OK, hmm_flag(map)); + map->flag = CMC_FLAG_ERROR; hmm_get_ref(map, 1); - cmc_assert_equals(int32_t, cmc_flags.OK, hmm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, hmm_flag(map)); hmm_clear(map); hmm_get(map, 1); - cmc_assert_equals(int32_t, cmc_flags.EMPTY, hmm_flag(map)); - map->flag = cmc_flags.ERROR; + cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, hmm_flag(map)); + map->flag = CMC_FLAG_ERROR; hmm_get_ref(map, 1); - cmc_assert_equals(int32_t, cmc_flags.EMPTY, hmm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, hmm_flag(map)); // contains - map->flag = cmc_flags.ERROR; + map->flag = CMC_FLAG_ERROR; cmc_assert(!hmm_contains(map, 1000)); - cmc_assert_equals(int32_t, cmc_flags.OK, hmm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, hmm_flag(map)); // copy_of - map->flag = cmc_flags.ERROR; + map->flag = CMC_FLAG_ERROR; struct hashmultimap *map2 = hmm_copy_of(map); - cmc_assert_equals(int32_t, cmc_flags.OK, hmm_flag(map)); - cmc_assert_equals(int32_t, cmc_flags.OK, hmm_flag(map2)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, hmm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, hmm_flag(map2)); // equals - map->flag = cmc_flags.ERROR; - map2->flag = cmc_flags.ERROR; + map->flag = CMC_FLAG_ERROR; + map2->flag = CMC_FLAG_ERROR; cmc_assert(hmm_equals(map, map2)); - cmc_assert_equals(int32_t, cmc_flags.OK, hmm_flag(map)); - cmc_assert_equals(int32_t, cmc_flags.OK, hmm_flag(map2)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, hmm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, hmm_flag(map2)); hmm_free(map); hmm_free(map2); diff --git a/tests/main/unt/hashmultiset.c b/tests/main/unt/hashmultiset.c index 2c2bf74..cccb6d8 100644 --- a/tests/main/unt/hashmultiset.c +++ b/tests/main/unt/hashmultiset.c @@ -32,7 +32,7 @@ CMC_CREATE_UNIT(HashMultiSet, true, { cmc_assert_not_equals(ptr, NULL, set->buffer); cmc_assert_equals(size_t, 0, set->count); cmc_assert_equals(double, 0.6, set->load); - cmc_assert_equals(int32_t, cmc_flags.OK, set->flag); + cmc_assert_equals(int32_t, CMC_FLAG_OK, set->flag); cmc_assert_equals(ptr, hms_fval, set->f_val); cmc_assert_equals(ptr, &cmc_alloc_node_default, set->alloc); cmc_assert_equals(ptr, NULL, set->callbacks); @@ -62,7 +62,7 @@ CMC_CREATE_UNIT(HashMultiSet, true, { cmc_assert_not_equals(ptr, NULL, set->buffer); cmc_assert_equals(size_t, 0, set->count); cmc_assert_equals(double, 0.6, set->load); - cmc_assert_equals(int32_t, cmc_flags.OK, set->flag); + cmc_assert_equals(int32_t, CMC_FLAG_OK, set->flag); cmc_assert_equals(ptr, hms_fval, set->f_val); cmc_assert_equals(ptr, hms_alloc_node, set->alloc); cmc_assert_equals(ptr, callbacks, set->callbacks); @@ -92,11 +92,11 @@ CMC_CREATE_UNIT(HashMultiSet, true, { cmc_assert_equals(size_t, 1000, set->count); - set->flag = cmc_flags.ERROR; + set->flag = CMC_FLAG_ERROR; hms_clear(set); cmc_assert_equals(size_t, 0, set->count); - cmc_assert_equals(int32_t, cmc_flags.OK, set->flag); + cmc_assert_equals(int32_t, CMC_FLAG_OK, set->flag); cmc_assert_equals(int32_t, 1000, v_total_free); hms_free(set); @@ -236,100 +236,100 @@ CMC_CREATE_UNIT(HashMultiSet, true, { struct hashmultiset *set = hms_new(100, 0.6, hms_fval); cmc_assert_not_equals(ptr, NULL, set); - cmc_assert_equals(int32_t, cmc_flags.OK, hms_flag(set)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, hms_flag(set)); // clear - set->flag = cmc_flags.ERROR; + set->flag = CMC_FLAG_ERROR; hms_clear(set); - cmc_assert_equals(int32_t, cmc_flags.OK, hms_flag(set)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, hms_flag(set)); // customize - set->flag = cmc_flags.ERROR; + set->flag = CMC_FLAG_ERROR; hms_customize(set, NULL, NULL); - cmc_assert_equals(int32_t, cmc_flags.OK, hms_flag(set)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, hms_flag(set)); // insert - set->flag = cmc_flags.ERROR; + set->flag = CMC_FLAG_ERROR; cmc_assert(hms_insert(set, 10)); - cmc_assert_equals(int32_t, cmc_flags.OK, hms_flag(set)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, hms_flag(set)); - set->flag = cmc_flags.ERROR; + set->flag = CMC_FLAG_ERROR; cmc_assert(hms_insert(set, 10)); - cmc_assert_equals(int32_t, cmc_flags.OK, hms_flag(set)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, hms_flag(set)); // insert_many - set->flag = cmc_flags.ERROR; + set->flag = CMC_FLAG_ERROR; cmc_assert(hms_insert_many(set, 1, 0)); - cmc_assert_equals(int32_t, cmc_flags.OK, hms_flag(set)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, hms_flag(set)); - set->flag = cmc_flags.ERROR; + set->flag = CMC_FLAG_ERROR; cmc_assert(hms_insert_many(set, 1, 2)); - cmc_assert_equals(int32_t, cmc_flags.OK, hms_flag(set)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, hms_flag(set)); // update - set->flag = cmc_flags.ERROR; + set->flag = CMC_FLAG_ERROR; cmc_assert(hms_update(set, 1, 1)); - cmc_assert_equals(int32_t, cmc_flags.OK, hms_flag(set)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, hms_flag(set)); - set->flag = cmc_flags.ERROR; + set->flag = CMC_FLAG_ERROR; cmc_assert(hms_update(set, 10, 0)); - cmc_assert_equals(int32_t, cmc_flags.OK, hms_flag(set)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, hms_flag(set)); // remove cmc_assert(!hms_remove(set, 10)); - cmc_assert_equals(int32_t, cmc_flags.NOT_FOUND, hms_flag(set)); + cmc_assert_equals(int32_t, CMC_FLAG_NOT_FOUND, hms_flag(set)); cmc_assert(hms_remove(set, 1)); - cmc_assert_equals(int32_t, cmc_flags.OK, hms_flag(set)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, hms_flag(set)); // remove_all cmc_assert_equals(size_t, 0, hms_remove_all(set, 1)); - cmc_assert_equals(int32_t, cmc_flags.EMPTY, hms_flag(set)); + cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, hms_flag(set)); cmc_assert(hms_insert_many(set, 1, 10)); cmc_assert_equals(size_t, 0, hms_remove_all(set, 10)); - cmc_assert_equals(int32_t, cmc_flags.NOT_FOUND, hms_flag(set)); + cmc_assert_equals(int32_t, CMC_FLAG_NOT_FOUND, hms_flag(set)); cmc_assert_equals(size_t, 10, hms_remove_all(set, 1)); - cmc_assert_equals(int32_t, cmc_flags.OK, hms_flag(set)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, hms_flag(set)); // max min cmc_assert(!hms_max(set, NULL)); - cmc_assert_equals(int32_t, cmc_flags.EMPTY, hms_flag(set)); - set->flag = cmc_flags.ERROR; + cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, hms_flag(set)); + set->flag = CMC_FLAG_ERROR; cmc_assert(!hms_min(set, NULL)); - cmc_assert_equals(int32_t, cmc_flags.EMPTY, hms_flag(set)); + cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, hms_flag(set)); cmc_assert(hms_insert(set, 1)); - set->flag = cmc_flags.ERROR; + set->flag = CMC_FLAG_ERROR; cmc_assert(hms_max(set, NULL)); - cmc_assert_equals(int32_t, cmc_flags.OK, hms_flag(set)); - set->flag = cmc_flags.ERROR; + cmc_assert_equals(int32_t, CMC_FLAG_OK, hms_flag(set)); + set->flag = CMC_FLAG_ERROR; cmc_assert(hms_min(set, NULL)); - cmc_assert_equals(int32_t, cmc_flags.OK, hms_flag(set)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, hms_flag(set)); // multiplicity_of - set->flag = cmc_flags.ERROR; + set->flag = CMC_FLAG_ERROR; cmc_assert_equals(size_t, 0, hms_multiplicity_of(set, 10)); - cmc_assert_equals(int32_t, cmc_flags.OK, hms_flag(set)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, hms_flag(set)); // contains - set->flag = cmc_flags.ERROR; + set->flag = CMC_FLAG_ERROR; cmc_assert(!hms_contains(set, 10)); - cmc_assert_equals(int32_t, cmc_flags.OK, hms_flag(set)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, hms_flag(set)); // copy_of - set->flag = cmc_flags.ERROR; + set->flag = CMC_FLAG_ERROR; struct hashmultiset *set2 = hms_copy_of(set); - cmc_assert_equals(int32_t, cmc_flags.OK, hms_flag(set)); - cmc_assert_equals(int32_t, cmc_flags.OK, hms_flag(set2)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, hms_flag(set)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, hms_flag(set2)); // equals - set->flag = cmc_flags.ERROR; - set2->flag = cmc_flags.ERROR; + set->flag = CMC_FLAG_ERROR; + set2->flag = CMC_FLAG_ERROR; cmc_assert(hms_equals(set, set2)); - cmc_assert_equals(int32_t, cmc_flags.OK, hms_flag(set)); - cmc_assert_equals(int32_t, cmc_flags.OK, hms_flag(set2)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, hms_flag(set)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, hms_flag(set2)); hms_free(set); hms_free(set2); diff --git a/tests/main/unt/hashset.c b/tests/main/unt/hashset.c index 22bdd0e..df242d3 100644 --- a/tests/main/unt/hashset.c +++ b/tests/main/unt/hashset.c @@ -30,7 +30,7 @@ CMC_CREATE_UNIT(HashSet, true, { cmc_assert_not_equals(ptr, NULL, set->buffer); cmc_assert_equals(size_t, 0, set->count); cmc_assert_equals(double, 0.6, set->load); - cmc_assert_equals(int32_t, cmc_flags.OK, set->flag); + cmc_assert_equals(int32_t, CMC_FLAG_OK, set->flag); cmc_assert_equals(ptr, hs_fval, set->f_val); cmc_assert_equals(ptr, &cmc_alloc_node_default, set->alloc); cmc_assert_equals(ptr, NULL, set->callbacks); @@ -60,7 +60,7 @@ CMC_CREATE_UNIT(HashSet, true, { cmc_assert_not_equals(ptr, NULL, set->buffer); cmc_assert_equals(size_t, 0, set->count); cmc_assert_equals(double, 0.6, set->load); - cmc_assert_equals(int32_t, cmc_flags.OK, set->flag); + cmc_assert_equals(int32_t, CMC_FLAG_OK, set->flag); cmc_assert_equals(ptr, hs_fval, set->f_val); cmc_assert_equals(ptr, hs_alloc_node, set->alloc); cmc_assert_equals(ptr, callbacks, set->callbacks); @@ -90,11 +90,11 @@ CMC_CREATE_UNIT(HashSet, true, { cmc_assert_equals(size_t, 1000, set->count); - set->flag = cmc_flags.ERROR; + set->flag = CMC_FLAG_ERROR; hs_clear(set); cmc_assert_equals(size_t, 0, set->count); - cmc_assert_equals(int32_t, cmc_flags.OK, set->flag); + cmc_assert_equals(int32_t, CMC_FLAG_OK, set->flag); cmc_assert_equals(int32_t, 1000, v_total_free); hs_free(set); @@ -481,58 +481,58 @@ CMC_CREATE_UNIT(HashSet, true, { struct hashset *set = hs_new(1, 0.99, hs_fval); cmc_assert_not_equals(ptr, NULL, set); - cmc_assert_equals(int32_t, cmc_flags.OK, hs_flag(set)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, hs_flag(set)); // insert cmc_assert(hs_insert(set, 1)); - cmc_assert_equals(int32_t, cmc_flags.OK, hs_flag(set)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, hs_flag(set)); cmc_assert(!hs_insert(set, 1)); - cmc_assert_equals(int32_t, cmc_flags.DUPLICATE, hs_flag(set)); + cmc_assert_equals(int32_t, CMC_FLAG_DUPLICATE, hs_flag(set)); // clear hs_clear(set); - cmc_assert_equals(int32_t, cmc_flags.OK, hs_flag(set)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, hs_flag(set)); cmc_assert(hs_insert(set, 1)); // remove cmc_assert(!hs_remove(set, 2)); - cmc_assert_equals(int32_t, cmc_flags.NOT_FOUND, hs_flag(set)); + cmc_assert_equals(int32_t, CMC_FLAG_NOT_FOUND, hs_flag(set)); cmc_assert(hs_remove(set, 1)); - cmc_assert_equals(int32_t, cmc_flags.OK, hs_flag(set)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, hs_flag(set)); cmc_assert(!hs_remove(set, 1)); - cmc_assert_equals(int32_t, cmc_flags.EMPTY, hs_flag(set)); + cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, hs_flag(set)); // max cmc_assert(hs_insert(set, 1)); cmc_assert(hs_max(set, NULL)); - cmc_assert_equals(int32_t, cmc_flags.OK, hs_flag(set)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, hs_flag(set)); cmc_assert(hs_remove(set, 1)); cmc_assert(!hs_max(set, NULL)); - cmc_assert_equals(int32_t, cmc_flags.EMPTY, hs_flag(set)); + cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, hs_flag(set)); // min cmc_assert(hs_insert(set, 1)); cmc_assert(hs_min(set, NULL)); - cmc_assert_equals(int32_t, cmc_flags.OK, hs_flag(set)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, hs_flag(set)); cmc_assert(hs_remove(set, 1)); cmc_assert(!hs_min(set, NULL)); - cmc_assert_equals(int32_t, cmc_flags.EMPTY, hs_flag(set)); + cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, hs_flag(set)); // contains hs_contains(set, 1); - cmc_assert_equals(int32_t, cmc_flags.OK, hs_flag(set)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, hs_flag(set)); // copy - set->flag = cmc_flags.ERROR; + set->flag = CMC_FLAG_ERROR; struct hashset *set2 = hs_copy_of(set); - cmc_assert_equals(int32_t, cmc_flags.OK, hs_flag(set)); - cmc_assert_equals(int32_t, cmc_flags.OK, hs_flag(set2)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, hs_flag(set)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, hs_flag(set2)); size_t tmp = set->capacity; set->capacity = 0; @@ -540,13 +540,13 @@ CMC_CREATE_UNIT(HashSet, true, { struct hashset *set3 = hs_copy_of(set); cmc_assert_equals(ptr, NULL, set3); - cmc_assert_equals(int32_t, cmc_flags.ERROR, hs_flag(set)); + cmc_assert_equals(int32_t, CMC_FLAG_ERROR, hs_flag(set)); set->capacity = tmp; cmc_assert(hs_equals(set, set2)); - cmc_assert_equals(int32_t, cmc_flags.OK, hs_flag(set)); - cmc_assert_equals(int32_t, cmc_flags.OK, hs_flag(set2)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, hs_flag(set)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, hs_flag(set2)); hs_free(set); hs_free(set2); diff --git a/tests/main/unt/heap.c b/tests/main/unt/heap.c index 2a3fe60..5dbaaa7 100644 --- a/tests/main/unt/heap.c +++ b/tests/main/unt/heap.c @@ -167,55 +167,55 @@ CMC_CREATE_UNIT(Heap, true, { struct heap *h = h_new(100, cmc_max_heap, h_fval); cmc_assert_not_equals(ptr, NULL, h); - cmc_assert_equals(int32_t, cmc_flags.OK, h_flag(h)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, h_flag(h)); - h->flag = cmc_flags.ERROR; + h->flag = CMC_FLAG_ERROR; // insert cmc_assert(h_insert(h, 10)); - cmc_assert_equals(int32_t, cmc_flags.OK, h_flag(h)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, h_flag(h)); - h->flag = cmc_flags.ERROR; + h->flag = CMC_FLAG_ERROR; // remove cmc_assert(h_remove(h)); - cmc_assert_equals(int32_t, cmc_flags.OK, h_flag(h)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, h_flag(h)); cmc_assert(!h_remove(h)); - cmc_assert_equals(int32_t, cmc_flags.EMPTY, h_flag(h)); + cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, h_flag(h)); // peek cmc_assert(h_insert(h, 10)); h_peek(h); - cmc_assert_equals(int32_t, cmc_flags.OK, h_flag(h)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, h_flag(h)); cmc_assert(h_remove(h)); h_peek(h); - cmc_assert_equals(int32_t, cmc_flags.EMPTY, h_flag(h)); + cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, h_flag(h)); // clear h_clear(h); - cmc_assert_equals(int32_t, cmc_flags.OK, h_flag(h)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, h_flag(h)); - h->flag = cmc_flags.ERROR; + h->flag = CMC_FLAG_ERROR; // contains h_contains(h, 10); - cmc_assert_equals(int32_t, cmc_flags.OK, h_flag(h)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, h_flag(h)); - h->flag = cmc_flags.ERROR; + h->flag = CMC_FLAG_ERROR; // copy of struct heap *h2 = h_copy_of(h); - cmc_assert_equals(int32_t, cmc_flags.OK, h_flag(h)); - cmc_assert_equals(int32_t, cmc_flags.OK, h_flag(h2)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, h_flag(h)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, h_flag(h2)); - h->flag = cmc_flags.ERROR; - h2->flag = cmc_flags.ERROR; + h->flag = CMC_FLAG_ERROR; + h2->flag = CMC_FLAG_ERROR; // equals cmc_assert(h_equals(h, h2)); - cmc_assert_equals(int32_t, cmc_flags.OK, h_flag(h)); - cmc_assert_equals(int32_t, cmc_flags.OK, h_flag(h2)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, h_flag(h)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, h_flag(h2)); h_free(h); h_free(h2); diff --git a/tests/main/unt/intervalheap.c b/tests/main/unt/intervalheap.c index 88dea15..3a1e9b0 100644 --- a/tests/main/unt/intervalheap.c +++ b/tests/main/unt/intervalheap.c @@ -196,19 +196,19 @@ CMC_CREATE_UNIT(IntervalHeap, true, { CMC_CREATE_TEST(PFX##_customize(), { struct intervalheap *ih = ih_new(100, ih_fval); - ih->flag = cmc_flags.ERROR; + ih->flag = CMC_FLAG_ERROR; ih_customize(ih, ih_alloc_node, callbacks); cmc_assert_equals(ptr, ih_alloc_node, ih->alloc); cmc_assert_equals(ptr, callbacks, ih->callbacks); - cmc_assert_equals(int32_t, cmc_flags.OK, ih->flag); + cmc_assert_equals(int32_t, CMC_FLAG_OK, ih->flag); - ih->flag = cmc_flags.ERROR; + ih->flag = CMC_FLAG_ERROR; ih_customize(ih, NULL, NULL); cmc_assert_equals(ptr, &cmc_alloc_node_default, ih->alloc); cmc_assert_equals(ptr, NULL, ih->callbacks); - cmc_assert_equals(int32_t, cmc_flags.OK, ih->flag); + cmc_assert_equals(int32_t, CMC_FLAG_OK, ih->flag); ih_free(ih); }); @@ -299,15 +299,15 @@ CMC_CREATE_UNIT(IntervalHeap, true, { // count == 0 cmc_assert(!ih_remove_max(ih)); - cmc_assert_equals(int32_t, cmc_flags.EMPTY, ih->flag); + cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, ih->flag); // count == 1 cmc_assert(ih_insert(ih, 10)); - ih->flag = cmc_flags.ERROR; + ih->flag = CMC_FLAG_ERROR; cmc_assert(ih_remove_max(ih)); cmc_assert_equals(int32_t, 1, total_delete); - cmc_assert_equals(int32_t, cmc_flags.OK, ih->flag); + cmc_assert_equals(int32_t, CMC_FLAG_OK, ih->flag); for (size_t i = 1; i <= 1000; i++) ih_insert(ih, i); @@ -347,15 +347,15 @@ CMC_CREATE_UNIT(IntervalHeap, true, { // count == 0 cmc_assert(!ih_remove_min(ih)); - cmc_assert_equals(int32_t, cmc_flags.EMPTY, ih->flag); + cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, ih->flag); // count == 1 cmc_assert(ih_insert(ih, 10)); - ih->flag = cmc_flags.ERROR; + ih->flag = CMC_FLAG_ERROR; cmc_assert(ih_remove_min(ih)); cmc_assert_equals(int32_t, 1, total_delete); - cmc_assert_equals(int32_t, cmc_flags.OK, ih->flag); + cmc_assert_equals(int32_t, CMC_FLAG_OK, ih->flag); for (size_t i = 1000; i >= 1; i--) ih_insert(ih, i); @@ -434,89 +434,89 @@ CMC_CREATE_UNIT(IntervalHeap, true, { struct intervalheap *ih = ih_new(100, ih_fval); cmc_assert_not_equals(ptr, NULL, ih); - cmc_assert_equals(int32_t, cmc_flags.OK, ih_flag(ih)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, ih_flag(ih)); - ih->flag = cmc_flags.ERROR; + ih->flag = CMC_FLAG_ERROR; // clear ih_clear(ih); - cmc_assert_equals(int32_t, cmc_flags.OK, ih_flag(ih)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, ih_flag(ih)); // customize - ih->flag = cmc_flags.ERROR; + ih->flag = CMC_FLAG_ERROR; ih_customize(ih, NULL, NULL); - cmc_assert_equals(int32_t, cmc_flags.OK, ih_flag(ih)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, ih_flag(ih)); // insert - ih->flag = cmc_flags.ERROR; + ih->flag = CMC_FLAG_ERROR; cmc_assert(ih_insert(ih, 10)); - cmc_assert_equals(int32_t, cmc_flags.OK, ih_flag(ih)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, ih_flag(ih)); // remove_max cmc_assert(ih_remove_max(ih)); - cmc_assert_equals(int32_t, cmc_flags.OK, ih_flag(ih)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, ih_flag(ih)); cmc_assert(!ih_remove_max(ih)); - cmc_assert_equals(int32_t, cmc_flags.EMPTY, ih_flag(ih)); + cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, ih_flag(ih)); // remove min cmc_assert(ih_insert(ih, 10)); cmc_assert(ih_remove_min(ih)); - cmc_assert_equals(int32_t, cmc_flags.OK, ih_flag(ih)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, ih_flag(ih)); cmc_assert(!ih_remove_min(ih)); - cmc_assert_equals(int32_t, cmc_flags.EMPTY, ih_flag(ih)); + cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, ih_flag(ih)); // update_max cmc_assert(!ih_update_max(ih, 20)); - cmc_assert_equals(int32_t, cmc_flags.EMPTY, ih_flag(ih)); + cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, ih_flag(ih)); cmc_assert(ih_insert(ih, 10)); - ih->flag = cmc_flags.ERROR; + ih->flag = CMC_FLAG_ERROR; cmc_assert(ih_update_max(ih, 20)); - cmc_assert_equals(int32_t, cmc_flags.OK, ih_flag(ih)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, ih_flag(ih)); // update_min - ih->flag = cmc_flags.ERROR; + ih->flag = CMC_FLAG_ERROR; cmc_assert(ih_update_min(ih, 20)); - cmc_assert_equals(int32_t, cmc_flags.OK, ih_flag(ih)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, ih_flag(ih)); cmc_assert(ih_remove_min(ih)); - ih->flag = cmc_flags.ERROR; + ih->flag = CMC_FLAG_ERROR; cmc_assert(!ih_update_max(ih, 20)); - cmc_assert_equals(int32_t, cmc_flags.EMPTY, ih_flag(ih)); + cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, ih_flag(ih)); // max min - ih->flag = cmc_flags.ERROR; + ih->flag = CMC_FLAG_ERROR; cmc_assert_equals(size_t, (size_t){ 0 }, ih_max(ih)); - cmc_assert_equals(int32_t, cmc_flags.EMPTY, ih_flag(ih)); + cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, ih_flag(ih)); - ih->flag = cmc_flags.ERROR; + ih->flag = CMC_FLAG_ERROR; cmc_assert_equals(size_t, (size_t){ 0 }, ih_min(ih)); - cmc_assert_equals(int32_t, cmc_flags.EMPTY, ih_flag(ih)); + cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, ih_flag(ih)); cmc_assert(ih_insert(ih, 10)); - ih->flag = cmc_flags.ERROR; + ih->flag = CMC_FLAG_ERROR; cmc_assert_equals(size_t, 10, ih_max(ih)); - cmc_assert_equals(int32_t, cmc_flags.OK, ih_flag(ih)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, ih_flag(ih)); - ih->flag = cmc_flags.ERROR; + ih->flag = CMC_FLAG_ERROR; cmc_assert_equals(size_t, 10, ih_min(ih)); - cmc_assert_equals(int32_t, cmc_flags.OK, ih_flag(ih)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, ih_flag(ih)); // contains - ih->flag = cmc_flags.ERROR; + ih->flag = CMC_FLAG_ERROR; cmc_assert(ih_contains(ih, 10)); - cmc_assert_equals(int32_t, cmc_flags.OK, ih_flag(ih)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, ih_flag(ih)); // copy_of - ih->flag = cmc_flags.ERROR; + ih->flag = CMC_FLAG_ERROR; struct intervalheap *ih2 = ih_copy_of(ih); - cmc_assert_equals(int32_t, cmc_flags.OK, ih_flag(ih)); - cmc_assert_equals(int32_t, cmc_flags.OK, ih_flag(ih2)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, ih_flag(ih)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, ih_flag(ih2)); // equals - ih->flag = cmc_flags.ERROR; - ih2->flag = cmc_flags.ERROR; + ih->flag = CMC_FLAG_ERROR; + ih2->flag = CMC_FLAG_ERROR; cmc_assert(ih_equals(ih, ih2)); - cmc_assert_equals(int32_t, cmc_flags.OK, ih_flag(ih)); - cmc_assert_equals(int32_t, cmc_flags.OK, ih_flag(ih2)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, ih_flag(ih)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, ih_flag(ih2)); ih_free(ih); ih_free(ih2); diff --git a/tests/main/unt/linkedlist.c b/tests/main/unt/linkedlist.c index 7e5113a..8962a63 100644 --- a/tests/main/unt/linkedlist.c +++ b/tests/main/unt/linkedlist.c @@ -85,133 +85,133 @@ CMC_CREATE_UNIT(LinkedList, true, { struct linkedlist *ll = ll_new(ll_fval); cmc_assert_not_equals(ptr, NULL, ll); - cmc_assert_equals(int32_t, cmc_flags.OK, ll_flag(ll)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, ll_flag(ll)); // clear - ll->flag = cmc_flags.ERROR; + ll->flag = CMC_FLAG_ERROR; ll_clear(ll); - cmc_assert_equals(int32_t, cmc_flags.OK, ll_flag(ll)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, ll_flag(ll)); // customize - ll->flag = cmc_flags.ERROR; + ll->flag = CMC_FLAG_ERROR; ll_customize(ll, NULL, NULL); - cmc_assert_equals(int32_t, cmc_flags.OK, ll_flag(ll)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, ll_flag(ll)); // push_front - ll->flag = cmc_flags.ERROR; + ll->flag = CMC_FLAG_ERROR; cmc_assert(ll_push_front(ll, 10)); - cmc_assert_equals(int32_t, cmc_flags.OK, ll_flag(ll)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, ll_flag(ll)); // push_at - ll->flag = cmc_flags.ERROR; + ll->flag = CMC_FLAG_ERROR; cmc_assert(ll_push_at(ll, 10, 1)); - cmc_assert_equals(int32_t, cmc_flags.OK, ll_flag(ll)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, ll_flag(ll)); cmc_assert(!ll_push_at(ll, 10, 300)); - cmc_assert_equals(int32_t, cmc_flags.RANGE, ll_flag(ll)); + cmc_assert_equals(int32_t, CMC_FLAG_RANGE, ll_flag(ll)); // push_back - ll->flag = cmc_flags.ERROR; + ll->flag = CMC_FLAG_ERROR; cmc_assert(ll_push_back(ll, 10)); - cmc_assert_equals(int32_t, cmc_flags.OK, ll_flag(ll)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, ll_flag(ll)); ll_clear(ll); // pop_front - ll->flag = cmc_flags.ERROR; + ll->flag = CMC_FLAG_ERROR; cmc_assert(!ll_pop_front(ll)); - cmc_assert_equals(int32_t, cmc_flags.EMPTY, ll_flag(ll)); + cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, ll_flag(ll)); cmc_assert(ll_push_back(ll, 10)); cmc_assert(ll_pop_front(ll)); - cmc_assert_equals(int32_t, cmc_flags.OK, ll_flag(ll)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, ll_flag(ll)); // pop_at cmc_assert(!ll_pop_at(ll, 0)); - cmc_assert_equals(int32_t, cmc_flags.EMPTY, ll_flag(ll)); + cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, ll_flag(ll)); cmc_assert(ll_push_front(ll, 10)); cmc_assert(!ll_pop_at(ll, 1)); - cmc_assert_equals(int32_t, cmc_flags.RANGE, ll_flag(ll)); + cmc_assert_equals(int32_t, CMC_FLAG_RANGE, ll_flag(ll)); cmc_assert(ll_pop_at(ll, 0)); - cmc_assert_equals(int32_t, cmc_flags.OK, ll_flag(ll)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, ll_flag(ll)); // pop_back - ll->flag = cmc_flags.ERROR; + ll->flag = CMC_FLAG_ERROR; cmc_assert(!ll_pop_front(ll)); - cmc_assert_equals(int32_t, cmc_flags.EMPTY, ll_flag(ll)); + cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, ll_flag(ll)); cmc_assert(ll_push_back(ll, 10)); cmc_assert(ll_pop_front(ll)); - cmc_assert_equals(int32_t, cmc_flags.OK, ll_flag(ll)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, ll_flag(ll)); ll_clear(ll); // front ll_front(ll); - cmc_assert_equals(int32_t, cmc_flags.EMPTY, ll_flag(ll)); + cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, ll_flag(ll)); cmc_assert(ll_push_front(ll, 10)); - ll->flag = cmc_flags.ERROR; + ll->flag = CMC_FLAG_ERROR; ll_front(ll); - cmc_assert_equals(int32_t, cmc_flags.OK, ll_flag(ll)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, ll_flag(ll)); ll_clear(ll); // back ll_back(ll); - cmc_assert_equals(int32_t, cmc_flags.EMPTY, ll_flag(ll)); + cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, ll_flag(ll)); cmc_assert(ll_push_front(ll, 10)); - ll->flag = cmc_flags.ERROR; + ll->flag = CMC_FLAG_ERROR; ll_back(ll); - cmc_assert_equals(int32_t, cmc_flags.OK, ll_flag(ll)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, ll_flag(ll)); ll_clear(ll); // get get_ref ll_get(ll, 0); - cmc_assert_equals(int32_t, cmc_flags.EMPTY, ll_flag(ll)); - ll->flag = cmc_flags.ERROR; + cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, ll_flag(ll)); + ll->flag = CMC_FLAG_ERROR; ll_get_ref(ll, 0); - cmc_assert_equals(int32_t, cmc_flags.EMPTY, ll_flag(ll)); + cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, ll_flag(ll)); cmc_assert(ll_push_at(ll, 10, 0)); - ll->flag = cmc_flags.ERROR; + ll->flag = CMC_FLAG_ERROR; ll_get(ll, 0); - cmc_assert_equals(int32_t, cmc_flags.OK, ll_flag(ll)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, ll_flag(ll)); ll_get(ll, 1); - cmc_assert_equals(int32_t, cmc_flags.RANGE, ll_flag(ll)); + cmc_assert_equals(int32_t, CMC_FLAG_RANGE, ll_flag(ll)); ll_get_ref(ll, 0); - cmc_assert_equals(int32_t, cmc_flags.OK, ll_flag(ll)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, ll_flag(ll)); ll_get_ref(ll, 1); - cmc_assert_equals(int32_t, cmc_flags.RANGE, ll_flag(ll)); + cmc_assert_equals(int32_t, CMC_FLAG_RANGE, ll_flag(ll)); // contains cmc_assert(ll_contains(ll, 10)); - cmc_assert_equals(int32_t, cmc_flags.OK, ll_flag(ll)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, ll_flag(ll)); // copy_of - ll->flag = cmc_flags.ERROR; + ll->flag = CMC_FLAG_ERROR; struct linkedlist *ll2 = ll_copy_of(ll); - cmc_assert_equals(int32_t, cmc_flags.OK, ll_flag(ll)); - cmc_assert_equals(int32_t, cmc_flags.OK, ll_flag(ll2)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, ll_flag(ll)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, ll_flag(ll2)); // equals - ll->flag = cmc_flags.ERROR; - ll2->flag = cmc_flags.ERROR; + ll->flag = CMC_FLAG_ERROR; + ll2->flag = CMC_FLAG_ERROR; cmc_assert(ll_equals(ll, ll2)); - cmc_assert_equals(int32_t, cmc_flags.OK, ll_flag(ll)); - cmc_assert_equals(int32_t, cmc_flags.OK, ll_flag(ll2)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, ll_flag(ll)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, ll_flag(ll2)); ll_clear(ll); // get_node struct linkedlist_node *n = ll_get_node(ll, 0); - cmc_assert_equals(int32_t, cmc_flags.EMPTY, ll_flag(ll)); + cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, ll_flag(ll)); cmc_assert(ll_push_at(ll, 10, 0)); n = ll_get_node(ll, 0); - cmc_assert_equals(int32_t, cmc_flags.OK, ll_flag(ll)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, ll_flag(ll)); n = ll_get_node(ll, 1); - cmc_assert_equals(int32_t, cmc_flags.RANGE, ll_flag(ll)); + cmc_assert_equals(int32_t, CMC_FLAG_RANGE, ll_flag(ll)); // functions relative to node ll_clear(ll); @@ -220,35 +220,35 @@ CMC_CREATE_UNIT(LinkedList, true, { cmc_assert_not_equals(ptr, NULL, n); // add_next - ll->flag = cmc_flags.ERROR; + ll->flag = CMC_FLAG_ERROR; cmc_assert(ll_add_next(ll, n, 11)); - cmc_assert_equals(int32_t, cmc_flags.OK, ll_flag(ll)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, ll_flag(ll)); // add_prev - ll->flag = cmc_flags.ERROR; + ll->flag = CMC_FLAG_ERROR; cmc_assert(ll_add_prev(ll, n, 9)); - cmc_assert_equals(int32_t, cmc_flags.OK, ll_flag(ll)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, ll_flag(ll)); // del_next n = ll_next_node(n); cmc_assert(!ll_del_next(ll, n)); - cmc_assert_equals(int32_t, cmc_flags.INVALID, ll_flag(ll)); + cmc_assert_equals(int32_t, CMC_FLAG_INVALID, ll_flag(ll)); n = ll_prev_node(n); cmc_assert(ll_del_next(ll, n)); - cmc_assert_equals(int32_t, cmc_flags.OK, ll_flag(ll)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, ll_flag(ll)); // del_prev n = ll_prev_node(n); cmc_assert(!ll_del_prev(ll, n)); - cmc_assert_equals(int32_t, cmc_flags.INVALID, ll_flag(ll)); + cmc_assert_equals(int32_t, CMC_FLAG_INVALID, ll_flag(ll)); n = ll_next_node(n); cmc_assert(ll_del_prev(ll, n)); - cmc_assert_equals(int32_t, cmc_flags.OK, ll_flag(ll)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, ll_flag(ll)); // del_curr - ll->flag = cmc_flags.ERROR; + ll->flag = CMC_FLAG_ERROR; cmc_assert(ll_del_curr(ll, n)); - cmc_assert_equals(int32_t, cmc_flags.OK, ll_flag(ll)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, ll_flag(ll)); ll_free(ll); ll_free(ll2); diff --git a/tests/main/unt/list.c b/tests/main/unt/list.c index c98d0d2..6beae16 100644 --- a/tests/main/unt/list.c +++ b/tests/main/unt/list.c @@ -316,178 +316,178 @@ CMC_CREATE_UNIT(List, true, { struct list *l = l_new(100, l_fval); cmc_assert_not_equals(ptr, NULL, l); - cmc_assert_equals(int32_t, cmc_flags.OK, l_flag(l)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, l_flag(l)); // clear - l->flag = cmc_flags.ERROR; + l->flag = CMC_FLAG_ERROR; l_clear(l); - cmc_assert_equals(int32_t, cmc_flags.OK, l_flag(l)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, l_flag(l)); // customize - l->flag = cmc_flags.ERROR; + l->flag = CMC_FLAG_ERROR; l_customize(l, NULL, NULL); - cmc_assert_equals(int32_t, cmc_flags.OK, l_flag(l)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, l_flag(l)); // push_front - l->flag = cmc_flags.ERROR; + l->flag = CMC_FLAG_ERROR; cmc_assert(l_push_front(l, 10)); - cmc_assert_equals(int32_t, cmc_flags.OK, l_flag(l)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, l_flag(l)); // push_at cmc_assert(!l_push_at(l, 5, 2)); - cmc_assert_equals(int32_t, cmc_flags.RANGE, l_flag(l)); + cmc_assert_equals(int32_t, CMC_FLAG_RANGE, l_flag(l)); cmc_assert(l_push_at(l, 5, 1)); - cmc_assert_equals(int32_t, cmc_flags.OK, l_flag(l)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, l_flag(l)); // push_back - l->flag = cmc_flags.ERROR; + l->flag = CMC_FLAG_ERROR; cmc_assert(l_push_back(l, 0)); - cmc_assert_equals(int32_t, cmc_flags.OK, l_flag(l)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, l_flag(l)); // pop_front - l->flag = cmc_flags.ERROR; + l->flag = CMC_FLAG_ERROR; cmc_assert(l_pop_front(l)); - cmc_assert_equals(int32_t, cmc_flags.OK, l_flag(l)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, l_flag(l)); l_clear(l); cmc_assert(!l_pop_front(l)); - cmc_assert_equals(int32_t, cmc_flags.EMPTY, l_flag(l)); + cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, l_flag(l)); // pop_back cmc_assert(l_push_front(l, 10)); - l->flag = cmc_flags.ERROR; + l->flag = CMC_FLAG_ERROR; cmc_assert(l_pop_back(l)); - cmc_assert_equals(int32_t, cmc_flags.OK, l_flag(l)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, l_flag(l)); cmc_assert(!l_pop_front(l)); - cmc_assert_equals(int32_t, cmc_flags.EMPTY, l_flag(l)); + cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, l_flag(l)); // pop_at - l->flag = cmc_flags.ERROR; + l->flag = CMC_FLAG_ERROR; cmc_assert(!l_pop_at(l, 0)); - cmc_assert_equals(int32_t, cmc_flags.EMPTY, l_flag(l)); + cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, l_flag(l)); cmc_assert(l_push_back(l, 10)); cmc_assert(!l_pop_at(l, 1)); - cmc_assert_equals(int32_t, cmc_flags.RANGE, l_flag(l)); + cmc_assert_equals(int32_t, CMC_FLAG_RANGE, l_flag(l)); cmc_assert(l_pop_at(l, 0)); - cmc_assert_equals(int32_t, cmc_flags.OK, l_flag(l)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, l_flag(l)); // seq_push_front cmc_assert(!l_seq_push_front(l, NULL, 0)); - cmc_assert_equals(int32_t, cmc_flags.INVALID, l_flag(l)); + cmc_assert_equals(int32_t, CMC_FLAG_INVALID, l_flag(l)); cmc_assert(l_seq_push_front(l, (size_t[2]){ 1, 2 }, 2)); - cmc_assert_equals(int32_t, cmc_flags.OK, l_flag(l)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, l_flag(l)); // seq_push_at cmc_assert(!l_seq_push_at(l, NULL, 0, 0)); - cmc_assert_equals(int32_t, cmc_flags.INVALID, l_flag(l)); + cmc_assert_equals(int32_t, CMC_FLAG_INVALID, l_flag(l)); cmc_assert(!l_seq_push_at(l, (size_t[2]){ 1, 2 }, 2, 10)); - cmc_assert_equals(int32_t, cmc_flags.RANGE, l_flag(l)); + cmc_assert_equals(int32_t, CMC_FLAG_RANGE, l_flag(l)); cmc_assert(l_seq_push_at(l, (size_t[2]){ 1, 2 }, 2, l_count(l) - 1)); - cmc_assert_equals(int32_t, cmc_flags.OK, l_flag(l)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, l_flag(l)); // seq_push_back cmc_assert(!l_seq_push_back(l, NULL, 0)); - cmc_assert_equals(int32_t, cmc_flags.INVALID, l_flag(l)); + cmc_assert_equals(int32_t, CMC_FLAG_INVALID, l_flag(l)); cmc_assert(l_seq_push_back(l, (size_t[2]){ 1, 2 }, 2)); - cmc_assert_equals(int32_t, cmc_flags.OK, l_flag(l)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, l_flag(l)); // seq_pop_at cmc_assert(!l_seq_pop_at(l, 10, 1)); - cmc_assert_equals(int32_t, cmc_flags.INVALID, l_flag(l)); + cmc_assert_equals(int32_t, CMC_FLAG_INVALID, l_flag(l)); cmc_assert(!l_seq_pop_at(l, 100, 200)); - cmc_assert_equals(int32_t, cmc_flags.RANGE, l_flag(l)); + cmc_assert_equals(int32_t, CMC_FLAG_RANGE, l_flag(l)); cmc_assert(l_seq_pop_at(l, 1, l_count(l) - 2)); - cmc_assert_equals(int32_t, cmc_flags.OK, l_flag(l)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, l_flag(l)); // seq_sublist struct list *l2 = l_seq_sublist(l, 10, 1); cmc_assert_equals(ptr, NULL, l2); - cmc_assert_equals(int32_t, cmc_flags.INVALID, l_flag(l)); + cmc_assert_equals(int32_t, CMC_FLAG_INVALID, l_flag(l)); l2 = l_seq_sublist(l, 100, 200); cmc_assert_equals(ptr, NULL, l2); - cmc_assert_equals(int32_t, cmc_flags.RANGE, l_flag(l)); + cmc_assert_equals(int32_t, CMC_FLAG_RANGE, l_flag(l)); l2 = l_seq_sublist(l, 0, l_count(l) - 1); - cmc_assert_equals(int32_t, cmc_flags.OK, l_flag(l)); - cmc_assert_equals(int32_t, cmc_flags.OK, l_flag(l2)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, l_flag(l)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, l_flag(l2)); l_clear(l); // l_front l_front(l); - cmc_assert_equals(int32_t, cmc_flags.EMPTY, l_flag(l)); + cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, l_flag(l)); cmc_assert(l_push_back(l, 10)); - l->flag = cmc_flags.ERROR; + l->flag = CMC_FLAG_ERROR; l_front(l); - cmc_assert_equals(int32_t, cmc_flags.OK, l_flag(l)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, l_flag(l)); l_clear(l); // l_back l_back(l); - cmc_assert_equals(int32_t, cmc_flags.EMPTY, l_flag(l)); + cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, l_flag(l)); cmc_assert(l_push_back(l, 10)); - l->flag = cmc_flags.ERROR; + l->flag = CMC_FLAG_ERROR; l_back(l); - cmc_assert_equals(int32_t, cmc_flags.OK, l_flag(l)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, l_flag(l)); l_clear(l); // get, get_ref l_get(l, 0); - cmc_assert_equals(int32_t, cmc_flags.EMPTY, l_flag(l)); - l->flag = cmc_flags.ERROR; + cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, l_flag(l)); + l->flag = CMC_FLAG_ERROR; l_get_ref(l, 0); - cmc_assert_equals(int32_t, cmc_flags.EMPTY, l_flag(l)); + cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, l_flag(l)); cmc_assert(l_push_back(l, 10)); l_get(l, 1); - cmc_assert_equals(int32_t, cmc_flags.RANGE, l_flag(l)); - l->flag = cmc_flags.ERROR; + cmc_assert_equals(int32_t, CMC_FLAG_RANGE, l_flag(l)); + l->flag = CMC_FLAG_ERROR; l_get_ref(l, 1); - cmc_assert_equals(int32_t, cmc_flags.RANGE, l_flag(l)); + cmc_assert_equals(int32_t, CMC_FLAG_RANGE, l_flag(l)); l_get(l, 0); - cmc_assert_equals(int32_t, cmc_flags.OK, l_flag(l)); - l->flag = cmc_flags.ERROR; + cmc_assert_equals(int32_t, CMC_FLAG_OK, l_flag(l)); + l->flag = CMC_FLAG_ERROR; l_get_ref(l, 0); - cmc_assert_equals(int32_t, cmc_flags.OK, l_flag(l)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, l_flag(l)); // index_of - l->flag = cmc_flags.ERROR; + l->flag = CMC_FLAG_ERROR; l_index_of(l, 10, false); - cmc_assert_equals(int32_t, cmc_flags.OK, l_flag(l)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, l_flag(l)); // contains - l->flag = cmc_flags.ERROR; + l->flag = CMC_FLAG_ERROR; cmc_assert(l_contains(l, 10)); - cmc_assert_equals(int32_t, cmc_flags.OK, l_flag(l)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, l_flag(l)); // copy_of - l->flag = cmc_flags.ERROR; + l->flag = CMC_FLAG_ERROR; struct list *l3 = l_copy_of(l); - cmc_assert_equals(int32_t, cmc_flags.OK, l_flag(l)); - cmc_assert_equals(int32_t, cmc_flags.OK, l_flag(l3)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, l_flag(l)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, l_flag(l3)); // equals - l->flag = cmc_flags.ERROR; - l3->flag = cmc_flags.ERROR; + l->flag = CMC_FLAG_ERROR; + l3->flag = CMC_FLAG_ERROR; cmc_assert(l_equals(l, l3)); - cmc_assert_equals(int32_t, cmc_flags.OK, l_flag(l)); - cmc_assert_equals(int32_t, cmc_flags.OK, l_flag(l3)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, l_flag(l)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, l_flag(l3)); l_free(l); l_free(l2); diff --git a/tests/main/unt/queue.c b/tests/main/unt/queue.c index f988730..4fd0e3f 100644 --- a/tests/main/unt/queue.c +++ b/tests/main/unt/queue.c @@ -420,57 +420,57 @@ CMC_CREATE_UNIT(Queue, true, { struct queue *q = q_new(100, q_fval); cmc_assert_not_equals(ptr, NULL, q); - cmc_assert_equals(int32_t, cmc_flags.OK, q_flag(q)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, q_flag(q)); // clear - q->flag = cmc_flags.ERROR; + q->flag = CMC_FLAG_ERROR; q_clear(q); - cmc_assert_equals(int32_t, cmc_flags.OK, q_flag(q)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, q_flag(q)); // customize - q->flag = cmc_flags.ERROR; + q->flag = CMC_FLAG_ERROR; q_customize(q, NULL, NULL); - cmc_assert_equals(int32_t, cmc_flags.OK, q_flag(q)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, q_flag(q)); // enqueue - q->flag = cmc_flags.ERROR; + q->flag = CMC_FLAG_ERROR; q_enqueue(q, 10); - cmc_assert_equals(int32_t, cmc_flags.OK, q_flag(q)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, q_flag(q)); // dequeue - q->flag = cmc_flags.ERROR; + q->flag = CMC_FLAG_ERROR; q_dequeue(q); - cmc_assert_equals(int32_t, cmc_flags.OK, q_flag(q)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, q_flag(q)); q_dequeue(q); - cmc_assert_equals(int32_t, cmc_flags.EMPTY, q_flag(q)); + cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, q_flag(q)); // peek - q->flag = cmc_flags.ERROR; + q->flag = CMC_FLAG_ERROR; q_peek(q); - cmc_assert_equals(int32_t, cmc_flags.EMPTY, q_flag(q)); + cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, q_flag(q)); cmc_assert(q_enqueue(q, 10)); q_peek(q); - cmc_assert_equals(int32_t, cmc_flags.OK, q_flag(q)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, q_flag(q)); // contains - q->flag = cmc_flags.ERROR; + q->flag = CMC_FLAG_ERROR; cmc_assert(q_contains(q, 10)); - cmc_assert_equals(int32_t, cmc_flags.OK, q_flag(q)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, q_flag(q)); // copy_of - q->flag = cmc_flags.OK; + q->flag = CMC_FLAG_OK; struct queue *q2 = q_copy_of(q); - cmc_assert_equals(int32_t, cmc_flags.OK, q_flag(q)); - cmc_assert_equals(int32_t, cmc_flags.OK, q_flag(q2)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, q_flag(q)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, q_flag(q2)); // equals - q->flag = cmc_flags.OK; - q2->flag = cmc_flags.OK; + q->flag = CMC_FLAG_OK; + q2->flag = CMC_FLAG_OK; cmc_assert(q_equals(q, q2)); - cmc_assert_equals(int32_t, cmc_flags.OK, q_flag(q)); - cmc_assert_equals(int32_t, cmc_flags.OK, q_flag(q2)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, q_flag(q)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, q_flag(q2)); q_free(q); q_free(q2); diff --git a/tests/main/unt/sortedlist.c b/tests/main/unt/sortedlist.c index 68e23dc..58b967e 100644 --- a/tests/main/unt/sortedlist.c +++ b/tests/main/unt/sortedlist.c @@ -148,87 +148,87 @@ CMC_CREATE_UNIT(SortedList, true, { struct sortedlist *sl = sl_new(100, sl_fval); cmc_assert_not_equals(ptr, NULL, sl); - cmc_assert_equals(int32_t, cmc_flags.OK, sl_flag(sl)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, sl_flag(sl)); // clear - sl->flag = cmc_flags.ERROR; + sl->flag = CMC_FLAG_ERROR; sl_clear(sl); - cmc_assert_equals(int32_t, cmc_flags.OK, sl_flag(sl)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, sl_flag(sl)); // customize - sl->flag = cmc_flags.ERROR; + sl->flag = CMC_FLAG_ERROR; sl_customize(sl, NULL, NULL); - cmc_assert_equals(int32_t, cmc_flags.OK, sl_flag(sl)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, sl_flag(sl)); // insert - sl->flag = cmc_flags.ERROR; + sl->flag = CMC_FLAG_ERROR; cmc_assert(sl_insert(sl, 10)); - cmc_assert_equals(int32_t, cmc_flags.OK, sl_flag(sl)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, sl_flag(sl)); // remove cmc_assert(!sl_remove(sl, 2)); - cmc_assert_equals(int32_t, cmc_flags.RANGE, sl_flag(sl)); + cmc_assert_equals(int32_t, CMC_FLAG_RANGE, sl_flag(sl)); cmc_assert(sl_remove(sl, 0)); - cmc_assert_equals(int32_t, cmc_flags.OK, sl_flag(sl)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, sl_flag(sl)); cmc_assert(!sl_remove(sl, 0)); - cmc_assert_equals(int32_t, cmc_flags.EMPTY, sl_flag(sl)); + cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, sl_flag(sl)); // max min - sl->flag = cmc_flags.ERROR; + sl->flag = CMC_FLAG_ERROR; cmc_assert_equals(size_t, (size_t){ 0 }, sl_max(sl)); - cmc_assert_equals(int32_t, cmc_flags.EMPTY, sl_flag(sl)); - sl->flag = cmc_flags.ERROR; + cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, sl_flag(sl)); + sl->flag = CMC_FLAG_ERROR; cmc_assert_equals(size_t, (size_t){ 0 }, sl_min(sl)); - cmc_assert_equals(int32_t, cmc_flags.EMPTY, sl_flag(sl)); + cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, sl_flag(sl)); cmc_assert(sl_insert(sl, 1)); - sl->flag = cmc_flags.ERROR; + sl->flag = CMC_FLAG_ERROR; cmc_assert_equals(size_t, 1, sl_max(sl)); - cmc_assert_equals(int32_t, cmc_flags.OK, sl_flag(sl)); - sl->flag = cmc_flags.ERROR; + cmc_assert_equals(int32_t, CMC_FLAG_OK, sl_flag(sl)); + sl->flag = CMC_FLAG_ERROR; cmc_assert_equals(size_t, 1, sl_min(sl)); - cmc_assert_equals(int32_t, cmc_flags.OK, sl_flag(sl)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, sl_flag(sl)); // get - sl->flag = cmc_flags.ERROR; + sl->flag = CMC_FLAG_ERROR; sl_get(sl, 1); - cmc_assert_equals(int32_t, cmc_flags.RANGE, sl_flag(sl)); + cmc_assert_equals(int32_t, CMC_FLAG_RANGE, sl_flag(sl)); sl_get(sl, 0); - cmc_assert_equals(int32_t, cmc_flags.OK, sl_flag(sl)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, sl_flag(sl)); cmc_assert(sl_remove(sl, 0)); sl_get(sl, 0); - cmc_assert_equals(int32_t, cmc_flags.EMPTY, sl_flag(sl)); + cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, sl_flag(sl)); // index_of cmc_assert(sl_insert(sl, 1)); sl_index_of(sl, 1, false); - cmc_assert_equals(int32_t, cmc_flags.OK, sl_flag(sl)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, sl_flag(sl)); // contains cmc_assert(sl_contains(sl, 1)); - cmc_assert_equals(int32_t, cmc_flags.OK, sl_flag(sl)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, sl_flag(sl)); // sort - sl->flag = cmc_flags.ERROR; + sl->flag = CMC_FLAG_ERROR; sl_sort(sl); - cmc_assert_equals(int32_t, cmc_flags.OK, sl_flag(sl)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, sl_flag(sl)); // copy_of - sl->flag = cmc_flags.ERROR; + sl->flag = CMC_FLAG_ERROR; struct sortedlist *sl2 = sl_copy_of(sl); - cmc_assert_equals(int32_t, cmc_flags.OK, sl_flag(sl)); - cmc_assert_equals(int32_t, cmc_flags.OK, sl_flag(sl2)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, sl_flag(sl)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, sl_flag(sl2)); // equals - sl->flag = cmc_flags.ERROR; - sl2->flag = cmc_flags.ERROR; + sl->flag = CMC_FLAG_ERROR; + sl2->flag = CMC_FLAG_ERROR; cmc_assert(sl_equals(sl, sl2)); - cmc_assert_equals(int32_t, cmc_flags.OK, sl_flag(sl)); - cmc_assert_equals(int32_t, cmc_flags.OK, sl_flag(sl2)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, sl_flag(sl)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, sl_flag(sl2)); sl_free(sl); sl_free(sl2); diff --git a/tests/main/unt/stack.c b/tests/main/unt/stack.c index 8537d58..298773a 100644 --- a/tests/main/unt/stack.c +++ b/tests/main/unt/stack.c @@ -282,57 +282,57 @@ CMC_CREATE_UNIT(Stack, true, { struct stack *s = s_new(100, s_fval); cmc_assert_not_equals(ptr, NULL, s); - cmc_assert_equals(int32_t, cmc_flags.OK, s_flag(s)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, s_flag(s)); // clear - s->flag = cmc_flags.ERROR; + s->flag = CMC_FLAG_ERROR; s_clear(s); - cmc_assert_equals(int32_t, cmc_flags.OK, s_flag(s)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, s_flag(s)); // customize - s->flag = cmc_flags.ERROR; + s->flag = CMC_FLAG_ERROR; s_customize(s, NULL, NULL); - cmc_assert_equals(int32_t, cmc_flags.OK, s_flag(s)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, s_flag(s)); // push - s->flag = cmc_flags.ERROR; + s->flag = CMC_FLAG_ERROR; cmc_assert(s_push(s, 1)); - cmc_assert_equals(int32_t, cmc_flags.OK, s_flag(s)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, s_flag(s)); // pop - s->flag = cmc_flags.ERROR; + s->flag = CMC_FLAG_ERROR; cmc_assert(s_pop(s)); - cmc_assert_equals(int32_t, cmc_flags.OK, s_flag(s)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, s_flag(s)); cmc_assert(!s_pop(s)); - cmc_assert_equals(int32_t, cmc_flags.EMPTY, s_flag(s)); + cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, s_flag(s)); // top - s->flag = cmc_flags.ERROR; + s->flag = CMC_FLAG_ERROR; s_top(s); - cmc_assert_equals(int32_t, cmc_flags.EMPTY, s_flag(s)); + cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, s_flag(s)); cmc_assert(s_push(s, 1)); s_top(s); - cmc_assert_equals(int32_t, cmc_flags.OK, s_flag(s)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, s_flag(s)); // contains - s->flag = cmc_flags.ERROR; + s->flag = CMC_FLAG_ERROR; cmc_assert(s_contains(s, 1)); - cmc_assert_equals(int32_t, cmc_flags.OK, s_flag(s)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, s_flag(s)); // copy_of - s->flag = cmc_flags.ERROR; + s->flag = CMC_FLAG_ERROR; struct stack *s2 = s_copy_of(s); - cmc_assert_equals(int32_t, cmc_flags.OK, s_flag(s)); - cmc_assert_equals(int32_t, cmc_flags.OK, s_flag(s2)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, s_flag(s)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, s_flag(s2)); // equals - s->flag = cmc_flags.ERROR; - s2->flag = cmc_flags.ERROR; + s->flag = CMC_FLAG_ERROR; + s2->flag = CMC_FLAG_ERROR; cmc_assert(s_equals(s, s2)); - cmc_assert_equals(int32_t, cmc_flags.OK, s_flag(s)); - cmc_assert_equals(int32_t, cmc_flags.OK, s_flag(s2)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, s_flag(s)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, s_flag(s2)); s_free(s); s_free(s2); diff --git a/tests/main/unt/treemap.c b/tests/main/unt/treemap.c index 909224b..9ce8b79 100644 --- a/tests/main/unt/treemap.c +++ b/tests/main/unt/treemap.c @@ -49,90 +49,90 @@ CMC_CREATE_UNIT(TreeMap, true, { struct treemap *map = tm_new(tm_fkey, tm_fval); cmc_assert_not_equals(ptr, NULL, map); - cmc_assert_equals(int32_t, cmc_flags.OK, tm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, tm_flag(map)); // clear - map->flag = cmc_flags.ERROR; + map->flag = CMC_FLAG_ERROR; tm_clear(map); - cmc_assert_equals(int32_t, cmc_flags.OK, tm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, tm_flag(map)); // insert - map->flag = cmc_flags.ERROR; + map->flag = CMC_FLAG_ERROR; cmc_assert(tm_insert(map, 1, 1)); - cmc_assert_equals(int32_t, cmc_flags.OK, tm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, tm_flag(map)); cmc_assert(!tm_insert(map, 1, 2)); - cmc_assert_equals(int32_t, cmc_flags.DUPLICATE, tm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_DUPLICATE, tm_flag(map)); // update cmc_assert(!tm_update(map, 2, 2, NULL)); - cmc_assert_equals(int32_t, cmc_flags.NOT_FOUND, tm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_NOT_FOUND, tm_flag(map)); cmc_assert(tm_update(map, 1, 2, NULL)); - cmc_assert_equals(int32_t, cmc_flags.OK, tm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, tm_flag(map)); // remove cmc_assert(!tm_remove(map, 2, NULL)); - cmc_assert_equals(int32_t, cmc_flags.NOT_FOUND, tm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_NOT_FOUND, tm_flag(map)); cmc_assert(tm_remove(map, 1, NULL)); - cmc_assert_equals(int32_t, cmc_flags.OK, tm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, tm_flag(map)); cmc_assert(!tm_remove(map, 1, NULL)); - cmc_assert_equals(int32_t, cmc_flags.EMPTY, tm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, tm_flag(map)); // max min - map->flag = cmc_flags.ERROR; + map->flag = CMC_FLAG_ERROR; cmc_assert(!tm_max(map, NULL, NULL)); - cmc_assert_equals(int32_t, cmc_flags.EMPTY, tm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, tm_flag(map)); - map->flag = cmc_flags.ERROR; + map->flag = CMC_FLAG_ERROR; cmc_assert(!tm_min(map, NULL, NULL)); - cmc_assert_equals(int32_t, cmc_flags.EMPTY, tm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, tm_flag(map)); cmc_assert(tm_insert(map, 1, 1)); - map->flag = cmc_flags.ERROR; + map->flag = CMC_FLAG_ERROR; cmc_assert(tm_max(map, NULL, NULL)); - cmc_assert_equals(int32_t, cmc_flags.OK, tm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, tm_flag(map)); - map->flag = cmc_flags.ERROR; + map->flag = CMC_FLAG_ERROR; cmc_assert(tm_min(map, NULL, NULL)); - cmc_assert_equals(int32_t, cmc_flags.OK, tm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, tm_flag(map)); // get get_ref tm_get(map, 2); - cmc_assert_equals(int32_t, cmc_flags.NOT_FOUND, tm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_NOT_FOUND, tm_flag(map)); tm_get(map, 1); - cmc_assert_equals(int32_t, cmc_flags.OK, tm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, tm_flag(map)); tm_get_ref(map, 2); - cmc_assert_equals(int32_t, cmc_flags.NOT_FOUND, tm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_NOT_FOUND, tm_flag(map)); tm_get_ref(map, 1); - cmc_assert_equals(int32_t, cmc_flags.OK, tm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, tm_flag(map)); cmc_assert(tm_remove(map, 1, NULL)); - map->flag = cmc_flags.ERROR; + map->flag = CMC_FLAG_ERROR; tm_get(map, 1); - cmc_assert_equals(int32_t, cmc_flags.EMPTY, tm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, tm_flag(map)); - map->flag = cmc_flags.ERROR; + map->flag = CMC_FLAG_ERROR; tm_get_ref(map, 1); - cmc_assert_equals(int32_t, cmc_flags.EMPTY, tm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, tm_flag(map)); // copy_of - map->flag = cmc_flags.ERROR; + map->flag = CMC_FLAG_ERROR; struct treemap *map2 = tm_copy_of(map); - cmc_assert_equals(int32_t, cmc_flags.OK, tm_flag(map)); - cmc_assert_equals(int32_t, cmc_flags.OK, tm_flag(map2)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, tm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, tm_flag(map2)); // equals - map->flag = cmc_flags.ERROR; - map2->flag = cmc_flags.ERROR; + map->flag = CMC_FLAG_ERROR; + map2->flag = CMC_FLAG_ERROR; cmc_assert(tm_equals(map, map2)); - cmc_assert_equals(int32_t, cmc_flags.OK, tm_flag(map)); - cmc_assert_equals(int32_t, cmc_flags.OK, tm_flag(map2)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, tm_flag(map)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, tm_flag(map2)); tm_free(map); tm_free(map2); diff --git a/tests/main/unt/treeset.c b/tests/main/unt/treeset.c index 46bc04e..eef1667 100644 --- a/tests/main/unt/treeset.c +++ b/tests/main/unt/treeset.c @@ -42,61 +42,61 @@ CMC_CREATE_UNIT(TreeSet, true, { struct treeset *set = ts_new(ts_fval); cmc_assert_not_equals(ptr, NULL, set); - cmc_assert_equals(int32_t, cmc_flags.OK, ts_flag(set)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, ts_flag(set)); // clear - set->flag = cmc_flags.ERROR; + set->flag = CMC_FLAG_ERROR; ts_clear(set); - cmc_assert_equals(int32_t, cmc_flags.OK, ts_flag(set)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, ts_flag(set)); // insert - set->flag = cmc_flags.ERROR; + set->flag = CMC_FLAG_ERROR; cmc_assert(ts_insert(set, 1)); - cmc_assert_equals(int32_t, cmc_flags.OK, ts_flag(set)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, ts_flag(set)); cmc_assert(!ts_insert(set, 1)); - cmc_assert_equals(int32_t, cmc_flags.DUPLICATE, ts_flag(set)); + cmc_assert_equals(int32_t, CMC_FLAG_DUPLICATE, ts_flag(set)); // remove cmc_assert(!ts_remove(set, 2)); - cmc_assert_equals(int32_t, cmc_flags.NOT_FOUND, ts_flag(set)); + cmc_assert_equals(int32_t, CMC_FLAG_NOT_FOUND, ts_flag(set)); cmc_assert(ts_remove(set, 1)); - cmc_assert_equals(int32_t, cmc_flags.OK, ts_flag(set)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, ts_flag(set)); cmc_assert(!ts_remove(set, 1)); - cmc_assert_equals(int32_t, cmc_flags.EMPTY, ts_flag(set)); + cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, ts_flag(set)); // max min - set->flag = cmc_flags.ERROR; + set->flag = CMC_FLAG_ERROR; cmc_assert(!ts_max(set, NULL)); - cmc_assert_equals(int32_t, cmc_flags.EMPTY, ts_flag(set)); + cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, ts_flag(set)); - set->flag = cmc_flags.ERROR; + set->flag = CMC_FLAG_ERROR; cmc_assert(!ts_min(set, NULL)); - cmc_assert_equals(int32_t, cmc_flags.EMPTY, ts_flag(set)); + cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, ts_flag(set)); cmc_assert(ts_insert(set, 1)); - set->flag = cmc_flags.ERROR; + set->flag = CMC_FLAG_ERROR; cmc_assert(ts_max(set, NULL)); - cmc_assert_equals(int32_t, cmc_flags.OK, ts_flag(set)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, ts_flag(set)); - set->flag = cmc_flags.ERROR; + set->flag = CMC_FLAG_ERROR; cmc_assert(ts_min(set, NULL)); - cmc_assert_equals(int32_t, cmc_flags.OK, ts_flag(set)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, ts_flag(set)); // copy_of - set->flag = cmc_flags.ERROR; + set->flag = CMC_FLAG_ERROR; struct treeset *set2 = ts_copy_of(set); - cmc_assert_equals(int32_t, cmc_flags.OK, ts_flag(set)); - cmc_assert_equals(int32_t, cmc_flags.OK, ts_flag(set2)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, ts_flag(set)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, ts_flag(set2)); // equals - set->flag = cmc_flags.ERROR; - set2->flag = cmc_flags.ERROR; + set->flag = CMC_FLAG_ERROR; + set2->flag = CMC_FLAG_ERROR; cmc_assert(ts_equals(set, set2)); - cmc_assert_equals(int32_t, cmc_flags.OK, ts_flag(set)); - cmc_assert_equals(int32_t, cmc_flags.OK, ts_flag(set2)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, ts_flag(set)); + cmc_assert_equals(int32_t, CMC_FLAG_OK, ts_flag(set2)); ts_free(set); ts_free(set2);