admin/C-Macro-Collections
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Reordering functions

Browse Source 
All implementation detail functions are at the end of source their source file
This commit is contained in:
Leonardo committed 2019-04-09 23:52:02 -03:00
1 parent ad93db4203
commit 1741e77c33
9 files changed
+608 -585
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

src/deque.h
+28 -25
View File
@@ -267,31 +267,6 @@
return _deque_->capacity; \
} \
\
FMOD bool PFX##_grow(SNAME *_deque_) \
{ \
\
size_t new_capacity = _deque_->capacity * 2; \
\
V *new_buffer = malloc(sizeof(V) * new_capacity); \
\
if (!new_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_->rear = _deque_->count; \
\
return true; \
} \
\
FMOD void PFX##_iter_new(SNAME##_iter *iter, SNAME *target) \
{ \
iter->target = target; \
@@ -309,6 +284,7 @@
FMOD bool PFX##_iter_end(SNAME##_iter *iter) \
{ \
size_t real_rear = iter->target->rear == 0 ? iter->target->capacity - 1 : iter->target->rear - 1; \
\
return iter->cursor == real_rear && iter->end; \
} \
\
@@ -339,6 +315,7 @@
\
*index = iter->index; \
*result = iter->target->buffer[iter->cursor]; \
\
iter->start = false; \
\
if (iter->index == iter->target->count - 1) \
@@ -359,6 +336,7 @@
\
*index = iter->index; \
*result = iter->target->buffer[iter->cursor]; \
\
iter->end = false; \
\
if (iter->index == 0) \
@@ -370,6 +348,31 @@
} \
\
return true; \
} \
\
FMOD bool PFX##_grow(SNAME *_deque_) \
{ \
\
size_t new_capacity = _deque_->capacity * 2; \
\
V *new_buffer = malloc(sizeof(V) * new_capacity); \
\
if (!new_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_->rear = _deque_->count; \
\
return true; \
}
#endif /* CMC_DEQUE_H */
src/hashmap.h
+73 -70
View File
@@ -204,6 +204,7 @@ static const size_t cmc_hashtable_primes[] = {53, 97, 193, 389, 769, 1543, 3079,
target->value = value; \
target->dist = pos - original_pos; \
target->state = ES_FILLED; \
\
break; \
} \
else if (target->dist < original_pos - pos) \
@@ -344,76 +345,6 @@ static const size_t cmc_hashtable_primes[] = {53, 97, 193, 389, 769, 1543, 3079,
return _map_->count; \
} \
\
FMOD bool PFX##_grow(SNAME *_map_) \
{ \
size_t new_size = PFX##_calculate_size((size_t)((double)_map_->capacity * 1.5)); \
\
SNAME *_new_map_ = PFX##_new(new_size, _map_->load, _map_->cmp, _map_->hash); \
\
if (!_new_map_) \
return false; \
\
SNAME##_iter iter; \
K key; \
V value; \
size_t index; \
\
for (PFX##_iter_new(&iter, _map_); !PFX##_iter_end(&iter);) \
{ \
PFX##_iter_next(&iter, &key, &value, &index); \
PFX##_insert(_new_map_, key, value); \
} \
\
if (_map_->count != _new_map_->count) \
{ \
PFX##_free(_new_map_); \
return false; \
} \
\
SNAME##_entry *tmp = _map_->buffer; \
_map_->buffer = _new_map_->buffer; \
_new_map_->buffer = tmp; \
\
_map_->capacity = _new_map_->capacity; \
\
PFX##_free(_new_map_); \
\
return true; \
} \
\
FMOD SNAME##_entry *PFX##_get_entry(SNAME *_map_, K key) \
{ \
size_t hash = _map_->hash(key); \
size_t pos = hash % _map_->capacity; \
\
SNAME##_entry *target = &(_map_->buffer[pos % _map_->capacity]); \
\
while (target->state == ES_FILLED || target->state == ES_DELETED) \
{ \
if (_map_->cmp(target->key, key) == 0) \
return target; \
\
pos++; \
target = &(_map_->buffer[pos % _map_->capacity]); \
} \
\
return NULL; \
} \
\
FMOD size_t PFX##_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]; \
} \
\
FMOD void PFX##_iter_new(SNAME##_iter *iter, SNAME *target) \
{ \
iter->target = target; \
@@ -488,6 +419,7 @@ static const size_t cmc_hashtable_primes[] = {53, 97, 193, 389, 769, 1543, 3079,
else \
{ \
iter->index++; \
\
while (1) \
{ \
iter->cursor++; \
@@ -519,6 +451,7 @@ static const size_t cmc_hashtable_primes[] = {53, 97, 193, 389, 769, 1543, 3079,
else \
{ \
iter->index--; \
\
while (1) \
{ \
iter->cursor--; \
@@ -532,6 +465,76 @@ static const size_t cmc_hashtable_primes[] = {53, 97, 193, 389, 769, 1543, 3079,
iter->end = PFX##_empty(iter->target); \
\
return true; \
} \
\
FMOD bool PFX##_grow(SNAME *_map_) \
{ \
size_t new_size = PFX##_calculate_size((size_t)((double)_map_->capacity * 1.5)); \
\
SNAME *_new_map_ = PFX##_new(new_size, _map_->load, _map_->cmp, _map_->hash); \
\
if (!_new_map_) \
return false; \
\
K key; \
V value; \
size_t index; \
SNAME##_iter iter; \
\
for (PFX##_iter_new(&iter, _map_); !PFX##_iter_end(&iter);) \
{ \
PFX##_iter_next(&iter, &key, &value, &index); \
PFX##_insert(_new_map_, key, value); \
} \
\
if (_map_->count != _new_map_->count) \
{ \
PFX##_free(_new_map_); \
return false; \
} \
\
SNAME##_entry *tmp = _map_->buffer; \
_map_->buffer = _new_map_->buffer; \
_new_map_->buffer = tmp; \
\
_map_->capacity = _new_map_->capacity; \
\
PFX##_free(_new_map_); \
\
return true; \
} \
\
FMOD SNAME##_entry *PFX##_get_entry(SNAME *_map_, K key) \
{ \
size_t hash = _map_->hash(key); \
size_t pos = hash % _map_->capacity; \
\
SNAME##_entry *target = &(_map_->buffer[pos % _map_->capacity]); \
\
while (target->state == ES_FILLED || target->state == ES_DELETED) \
{ \
if (_map_->cmp(target->key, key) == 0) \
return target; \
\
pos++; \
target = &(_map_->buffer[pos % _map_->capacity]); \
} \
\
return NULL; \
} \
\
FMOD size_t PFX##_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 */
src/hashset.h
+87 -79
View File
@@ -205,6 +205,7 @@ static const size_t cmc_hashtable_primes[] = {53, 97, 193, 389, 769, 1543, 3079,
target->value = element; \
target->dist = pos - original_pos; \
target->state = ES_FILLED; \
\
break; \
} \
else if (target->dist < pos - original_pos) \
@@ -263,9 +264,9 @@ static const size_t cmc_hashtable_primes[] = {53, 97, 193, 389, 769, 1543, 3079,
if (PFX##_empty(_set_)) \
return 0; \
\
SNAME##_iter iter; \
V result, max; \
size_t index; \
SNAME##_iter iter; \
\
for (PFX##_iter_new(&iter, _set_); !PFX##_iter_end(&iter);) \
{ \
@@ -285,9 +286,9 @@ static const size_t cmc_hashtable_primes[] = {53, 97, 193, 389, 769, 1543, 3079,
if (PFX##_empty(_set_)) \
return 0; \
\
SNAME##_iter iter; \
V result, min; \
size_t index; \
SNAME##_iter iter; \
\
for (PFX##_iter_new(&iter, _set_); !PFX##_iter_end(&iter);) \
{ \
@@ -312,80 +313,11 @@ static const size_t cmc_hashtable_primes[] = {53, 97, 193, 389, 769, 1543, 3079,
return _set_->count; \
} \
\
FMOD bool PFX##_grow(SNAME *_set_) \
{ \
size_t new_size = PFX##_calculate_size((size_t)((double)_set_->capacity * 1.5)); \
\
SNAME *_new_set_ = PFX##_new(new_size, _set_->load, _set_->cmp, _set_->hash); \
\
if (!_new_set_) \
return false; \
\
SNAME##_iter iter; \
V value; \
size_t index; \
\
for (PFX##_iter_new(&iter, _set_); !PFX##_iter_end(&iter);) \
{ \
PFX##_iter_next(&iter, &value, &index); \
PFX##_insert(_new_set_, value); \
} \
\
if (_set_->count != _new_set_->count) \
{ \
PFX##_free(_new_set_); \
return false; \
} \
\
SNAME##_entry *tmp = _set_->buffer; \
_set_->buffer = _new_set_->buffer; \
_new_set_->buffer = tmp; \
\
_set_->capacity = _new_set_->capacity; \
\
PFX##_free(_new_set_); \
\
return true; \
} \
\
FMOD SNAME##_entry *PFX##_get_entry(SNAME *_set_, V element) \
{ \
size_t hash = _set_->hash(element); \
size_t pos = hash % _set_->capacity; \
\
SNAME##_entry *target = &(_set_->buffer[pos % _set_->capacity]); \
\
while (target->state == ES_FILLED || target->state == ES_DELETED) \
{ \
if (_set_->cmp(target->value, element) == 0) \
return target; \
\
pos++; \
target = &(_set_->buffer[pos % _set_->capacity]); \
} \
\
return NULL; \
} \
\
FMOD size_t PFX##_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]; \
} \
\
FMOD SNAME *PFX##_union(SNAME *_set1_, SNAME *_set2_) \
{ \
SNAME##_iter iter1, iter2; \
size_t index; \
V value; \
size_t index; \
SNAME##_iter iter1, iter2; \
\
SNAME *_set_r_ = PFX##_new(_set1_->capacity, _set1_->load, _set1_->cmp, _set1_->hash); \
\
@@ -412,9 +344,9 @@ static const size_t cmc_hashtable_primes[] = {53, 97, 193, 389, 769, 1543, 3079,
\
FMOD SNAME *PFX##_intersection(SNAME *_set1_, SNAME *_set2_) \
{ \
SNAME##_iter iter; \
size_t index; \
V value; \
size_t index; \
SNAME##_iter iter; \
\
SNAME *_set_r_ = PFX##_new(_set1_->capacity, _set1_->load, _set1_->cmp, _set1_->hash); \
\
@@ -429,6 +361,7 @@ static const size_t cmc_hashtable_primes[] = {53, 97, 193, 389, 769, 1543, 3079,
for (PFX##_iter_tostart(&iter); !PFX##_iter_end(&iter);) \
{ \
PFX##_iter_next(&iter, &value, &index); \
\
if (PFX##_get_entry(_set_B_, value) != NULL) \
PFX##_insert(_set_r_, value); \
} \
@@ -438,9 +371,9 @@ static const size_t cmc_hashtable_primes[] = {53, 97, 193, 389, 769, 1543, 3079,
\
FMOD SNAME *PFX##_difference(SNAME *_set1_, SNAME *_set2_) \
{ \
SNAME##_iter iter; \
size_t index; \
V value; \
size_t index; \
SNAME##_iter iter; \
\
SNAME *_set_r_ = PFX##_new(_set1_->capacity, _set1_->load, _set1_->cmp, _set1_->hash); \
\
@@ -452,6 +385,7 @@ static const size_t cmc_hashtable_primes[] = {53, 97, 193, 389, 769, 1543, 3079,
for (PFX##_iter_tostart(&iter); !PFX##_iter_end(&iter);) \
{ \
PFX##_iter_next(&iter, &value, &index); \
\
if (PFX##_get_entry(_set2_, value) == NULL) \
PFX##_insert(_set_r_, value); \
} \
@@ -461,9 +395,9 @@ static const size_t cmc_hashtable_primes[] = {53, 97, 193, 389, 769, 1543, 3079,
\
FMOD SNAME *PFX##_symmetric_difference(SNAME *_set1_, SNAME *_set2_) \
{ \
SNAME##_iter iter1, iter2; \
size_t index; \
V value; \
size_t index; \
SNAME##_iter iter1, iter2; \
\
SNAME *_set_r_ = PFX##_new(_set1_->capacity, _set1_->load, _set1_->cmp, _set1_->hash); \
\
@@ -476,6 +410,7 @@ static const size_t cmc_hashtable_primes[] = {53, 97, 193, 389, 769, 1543, 3079,
for (PFX##_iter_tostart(&iter1); !PFX##_iter_end(&iter1);) \
{ \
PFX##_iter_next(&iter1, &value, &index); \
\
if (PFX##_get_entry(_set2_, value) == NULL) \
PFX##_insert(_set_r_, value); \
} \
@@ -483,6 +418,7 @@ static const size_t cmc_hashtable_primes[] = {53, 97, 193, 389, 769, 1543, 3079,
for (PFX##_iter_tostart(&iter2); !PFX##_iter_end(&iter2);) \
{ \
PFX##_iter_next(&iter2, &value, &index); \
\
if (PFX##_get_entry(_set1_, value) == NULL) \
PFX##_insert(_set_r_, value); \
} \
@@ -563,6 +499,7 @@ static const size_t cmc_hashtable_primes[] = {53, 97, 193, 389, 769, 1543, 3079,
else \
{ \
iter->index++; \
\
while (1) \
{ \
iter->cursor++; \
@@ -593,6 +530,7 @@ static const size_t cmc_hashtable_primes[] = {53, 97, 193, 389, 769, 1543, 3079,
else \
{ \
iter->index--; \
\
while (1) \
{ \
iter->cursor--; \
@@ -606,6 +544,76 @@ static const size_t cmc_hashtable_primes[] = {53, 97, 193, 389, 769, 1543, 3079,
iter->end = PFX##_empty(iter->target); \
\
return true; \
} \
\
FMOD bool PFX##_grow(SNAME *_set_) \
{ \
size_t new_size = PFX##_calculate_size((size_t)((double)_set_->capacity * 1.5)); \
\
SNAME *_new_set_ = PFX##_new(new_size, _set_->load, _set_->cmp, _set_->hash); \
\
if (!_new_set_) \
return false; \
\
V value; \
size_t index; \
SNAME##_iter iter; \
\
for (PFX##_iter_new(&iter, _set_); !PFX##_iter_end(&iter);) \
{ \
PFX##_iter_next(&iter, &value, &index); \
PFX##_insert(_new_set_, value); \
} \
\
if (_set_->count != _new_set_->count) \
{ \
PFX##_free(_new_set_); \
\
return false; \
} \
\
SNAME##_entry *tmp = _set_->buffer; \
_set_->buffer = _new_set_->buffer; \
_new_set_->buffer = tmp; \
\
_set_->capacity = _new_set_->capacity; \
\
PFX##_free(_new_set_); \
\
return true; \
} \
\
FMOD SNAME##_entry *PFX##_get_entry(SNAME *_set_, V element) \
{ \
size_t hash = _set_->hash(element); \
size_t pos = hash % _set_->capacity; \
\
SNAME##_entry *target = &(_set_->buffer[pos % _set_->capacity]); \
\
while (target->state == ES_FILLED || target->state == ES_DELETED) \
{ \
if (_set_->cmp(target->value, element) == 0) \
return target; \
\
pos++; \
target = &(_set_->buffer[pos % _set_->capacity]); \
} \
\
return NULL; \
} \
\
FMOD size_t PFX##_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_HASHSET_H */
src/heap.h
+68 -66
View File
@@ -226,6 +226,74 @@ typedef enum HeapOrder
return _heap_->capacity; \
} \
\
FMOD void PFX##_iter_new(SNAME##_iter *iter, SNAME *target) \
{ \
iter->target = target; \
iter->cursor = 0; \
iter->start = true; \
iter->end = PFX##_empty(target); \
} \
\
FMOD bool PFX##_iter_start(SNAME##_iter *iter) \
{ \
return iter->cursor == 0 && iter->start; \
} \
\
FMOD bool PFX##_iter_end(SNAME##_iter *iter) \
{ \
return iter->cursor == iter->target->count - 1 && iter->end; \
} \
\
FMOD void PFX##_iter_tostart(SNAME##_iter *iter) \
{ \
iter->cursor = 0; \
iter->start = true; \
iter->end = PFX##_empty(iter->target); \
} \
\
FMOD void PFX##_iter_toend(SNAME##_iter *iter) \
{ \
iter->cursor = iter->target->count - 1; \
iter->start = PFX##_empty(iter->target); \
iter->end = true; \
} \
\
FMOD bool PFX##_iter_next(SNAME##_iter *iter, V *result, size_t *index) \
{ \
if (iter->end) \
return false; \
\
*index = iter->cursor; \
*result = iter->target->buffer[iter->cursor]; \
\
iter->start = false; \
\
if (iter->cursor == iter->target->count - 1) \
iter->end = true; \
else \
iter->cursor++; \
\
return true; \
} \
\
FMOD bool PFX##_iter_prev(SNAME##_iter *iter, V *result, size_t *index) \
{ \
if (iter->start) \
return false; \
\
*index = iter->cursor; \
*result = iter->target->buffer[iter->cursor]; \
\
iter->end = false; \
\
if (iter->cursor == 0) \
iter->start = true; \
else \
iter->cursor--; \
\
return true; \
} \
\
FMOD bool PFX##_grow(SNAME *_heap_) \
{ \
size_t new_capacity = _heap_->capacity * 2; \
@@ -315,72 +383,6 @@ typedef enum HeapOrder
} \
\
return true; \
} \
\
FMOD void PFX##_iter_new(SNAME##_iter *iter, SNAME *target) \
{ \
iter->target = target; \
iter->cursor = 0; \
iter->start = true; \
iter->end = PFX##_empty(target); \
} \
\
FMOD bool PFX##_iter_start(SNAME##_iter *iter) \
{ \
return iter->cursor == 0 && iter->start; \
} \
\
FMOD bool PFX##_iter_end(SNAME##_iter *iter) \
{ \
return iter->cursor == iter->target->count - 1 && iter->end; \
} \
\
FMOD void PFX##_iter_tostart(SNAME##_iter *iter) \
{ \
iter->cursor = 0; \
iter->start = true; \
iter->end = PFX##_empty(iter->target); \
} \
\
FMOD void PFX##_iter_toend(SNAME##_iter *iter) \
{ \
iter->cursor = iter->target->count - 1; \
iter->start = PFX##_empty(iter->target); \
iter->end = true; \
} \
\
FMOD bool PFX##_iter_next(SNAME##_iter *iter, V *result, size_t *index) \
{ \
if (iter->end) \
return false; \
\
*index = iter->cursor; \
*result = iter->target->buffer[iter->cursor]; \
iter->start = false; \
\
if (iter->cursor == iter->target->count - 1) \
iter->end = true; \
else \
iter->cursor++; \
\
return true; \
} \
\
FMOD bool PFX##_iter_prev(SNAME##_iter *iter, V *result, size_t *index) \
{ \
if (iter->start) \
return false; \
\
*index = iter->cursor; \
*result = iter->target->buffer[iter->cursor]; \
iter->end = false; \
\
if (iter->cursor == 0) \
iter->start = true; \
else \
iter->cursor--; \
\
return true; \
}
#endif /* CMC_HEAP_H */
src/list.h
+18 -18
View File
@@ -447,24 +447,6 @@
return _list_->capacity; \
} \
\
FMOD bool PFX##_grow(SNAME *_list_, size_t required) \
{ \
size_t new_capacity = _list_->capacity * 2; \
\
if (new_capacity < required) \
new_capacity = required; \
\
V *new_buffer = realloc(_list_->buffer, sizeof(V) * new_capacity); \
\
if (!new_buffer) \
return false; \
\
_list_->buffer = new_buffer; \
_list_->capacity = new_capacity; \
\
return true; \
} \
\
FMOD void PFX##_iter_new(SNAME##_iter *iter, SNAME *target) \
{ \
iter->target = target; \
@@ -529,6 +511,24 @@
iter->cursor--; \
\
return true; \
} \
\
FMOD bool PFX##_grow(SNAME *_list_, size_t required) \
{ \
size_t new_capacity = _list_->capacity * 2; \
\
if (new_capacity < required) \
new_capacity = required; \
\
V *new_buffer = realloc(_list_->buffer, sizeof(V) * new_capacity); \
\
if (!new_buffer) \
return false; \
\
_list_->buffer = new_buffer; \
_list_->capacity = new_capacity; \
\
return true; \
}
#endif /* CMC_LIST_H */
src/queue.h
+27 -25
View File
@@ -205,31 +205,6 @@
return _queue_->capacity; \
} \
\
FMOD bool PFX##_grow(SNAME *_queue_) \
{ \
\
size_t new_capacity = _queue_->capacity * 2; \
\
V *new_buffer = malloc(sizeof(V) * new_capacity); \
\
if (!new_buffer) \
return false; \
\
for (size_t i = _queue_->front, j = 0; j < _queue_->count; i = (i + 1) % _queue_->capacity, j++) \
{ \
new_buffer[j] = _queue_->buffer[i]; \
} \
\
free(_queue_->buffer); \
\
_queue_->buffer = new_buffer; \
_queue_->capacity = new_capacity; \
_queue_->front = 0; \
_queue_->rear = _queue_->count; \
\
return true; \
} \
\
FMOD void PFX##_iter_new(SNAME##_iter *iter, SNAME *target) \
{ \
iter->target = target; \
@@ -277,6 +252,7 @@
\
*index = iter->index; \
*result = iter->target->buffer[iter->cursor]; \
\
iter->start = false; \
\
if (iter->index == iter->target->count - 1) \
@@ -297,6 +273,7 @@
\
*index = iter->index; \
*result = iter->target->buffer[iter->cursor]; \
\
iter->end = false; \
\
if (iter->index == 0) \
@@ -308,6 +285,31 @@
} \
\
return true; \
} \
\
FMOD bool PFX##_grow(SNAME *_queue_) \
{ \
\
size_t new_capacity = _queue_->capacity * 2; \
\
V *new_buffer = malloc(sizeof(V) * new_capacity); \
\
if (!new_buffer) \
return false; \
\
for (size_t i = _queue_->front, j = 0; j < _queue_->count; i = (i + 1) % _queue_->capacity, j++) \
{ \
new_buffer[j] = _queue_->buffer[i]; \
} \
\
free(_queue_->buffer); \
\
_queue_->buffer = new_buffer; \
_queue_->capacity = new_capacity; \
_queue_->front = 0; \
_queue_->rear = _queue_->count; \
\
return true; \
}
#endif /* CMC_QUEUE_H */
src/stack.h
+15 -15
View File
@@ -192,21 +192,6 @@
return _stack_->capacity; \
} \
\
FMOD bool PFX##_grow(SNAME *_stack_) \
{ \
size_t new_capacity = _stack_->capacity * 2; \
\
V *new_buffer = realloc(_stack_->buffer, sizeof(V) * new_capacity); \
\
if (!new_buffer) \
return false; \
\
_stack_->buffer = new_buffer; \
_stack_->capacity = new_capacity; \
\
return true; \
} \
\
FMOD void PFX##_iter_new(SNAME##_iter *iter, SNAME *target) \
{ \
iter->target = target; \
@@ -271,6 +256,21 @@
iter->cursor++; \
\
return true; \
} \
\
FMOD bool PFX##_grow(SNAME *_stack_) \
{ \
size_t new_capacity = _stack_->capacity * 2; \
\
V *new_buffer = realloc(_stack_->buffer, sizeof(V) * new_capacity); \
\
if (!new_buffer) \
return false; \
\
_stack_->buffer = new_buffer; \
_stack_->capacity = new_capacity; \
\
return true; \
}
#endif /* CMC_STACK_H */
src/treemap.h
+134 -130
View File
@@ -186,6 +186,7 @@
if (PFX##_empty(_map_)) \
{ \
_map_->root = PFX##_new_node(key, value); \
\
if (!_map_->root) \
return false; \
} \
@@ -427,6 +428,139 @@
return _map_->count; \
} \
\
FMOD void PFX##_iter_new(SNAME##_iter *iter, SNAME *target) \
{ \
iter->target = target; \
iter->index = 0; \
iter->start = true; \
iter->end = PFX##_empty(target); \
\
iter->cursor = target->root; \
while (iter->cursor->left != NULL) \
iter->cursor = iter->cursor->left; \
\
iter->first = iter->cursor; \
\
iter->last = target->root; \
while (iter->last->right != NULL) \
iter->last = iter->last->right; \
} \
\
FMOD bool PFX##_iter_start(SNAME##_iter *iter) \
{ \
return iter->start && iter->cursor == iter->first; \
} \
\
FMOD bool PFX##_iter_end(SNAME##_iter *iter) \
{ \
return iter->end && iter->cursor == iter->last; \
} \
\
FMOD void PFX##_iter_tostart(SNAME##_iter *iter) \
{ \
iter->index = 0; \
iter->start = true; \
iter->end = PFX##_empty(iter->target); \
\
iter->cursor = iter->first; \
} \
\
FMOD void PFX##_iter_toend(SNAME##_iter *iter) \
{ \
iter->index = iter->target->count - 1; \
iter->start = PFX##_empty(iter->target); \
iter->end = true; \
\
iter->cursor = iter->last; \
} \
\
FMOD bool PFX##_iter_next(SNAME##_iter *iter, K *key, V *value, size_t *index) \
{ \
if (iter->end) \
return false; \
\
*key = iter->cursor->key; \
*value = iter->cursor->value; \
*index = iter->index; \
\
iter->start = false; \
\
if (iter->cursor->right != NULL) \
{ \
iter->cursor = iter->cursor->right; \
while (iter->cursor->left != NULL) \
iter->cursor = iter->cursor->left; \
\
iter->index++; \
\
return true; \
} \
\
while (true) \
{ \
if (iter->cursor == iter->last) \
{ \
iter->end = true; \
\
return true; \
} \
if (iter->cursor->parent->left == iter->cursor) \
{ \
iter->cursor = iter->cursor->parent; \
\
iter->index++; \
\
return true; \
} \
\
iter->cursor = iter->cursor->parent; \
} \
} \
\
FMOD bool PFX##_iter_prev(SNAME##_iter *iter, K *key, V *value, size_t *index) \
{ \
if (iter->start) \
return false; \
\
*key = iter->cursor->key; \
*value = iter->cursor->value; \
*index = iter->index; \
\
iter->end = false; \
\
if (iter->cursor->left != NULL) \
{ \
iter->cursor = iter->cursor->left; \
\
while (iter->cursor->right != NULL) \
iter->cursor = iter->cursor->right; \
\
iter->index--; \
\
return true; \
} \
\
while (true) \
{ \
if (iter->cursor == iter->first) \
{ \
iter->start = true; \
\
return true; \
} \
if (iter->cursor->parent->right == iter->cursor) \
{ \
iter->cursor = iter->cursor->parent; \
\
iter->index--; \
\
return true; \
} \
\
iter->cursor = iter->cursor->parent; \
} \
} \
\
FMOD SNAME##_node *PFX##_new_node(K key, V value) \
{ \
SNAME##_node *node = malloc(sizeof(SNAME##_node)); \
@@ -583,136 +717,6 @@
\
scan = scan->parent; \
} \
} \
\
FMOD void PFX##_iter_new(SNAME##_iter *iter, SNAME *target) \
{ \
iter->target = target; \
iter->index = 0; \
iter->start = true; \
iter->end = PFX##_empty(target); \
\
iter->cursor = target->root; \
while (iter->cursor->left != NULL) \
iter->cursor = iter->cursor->left; \
\
iter->first = iter->cursor; \
\
iter->last = target->root; \
while (iter->last->right != NULL) \
iter->last = iter->last->right; \
} \
\
FMOD bool PFX##_iter_start(SNAME##_iter *iter) \
{ \
return iter->start && iter->cursor == iter->first; \
} \
\
FMOD bool PFX##_iter_end(SNAME##_iter *iter) \
{ \
return iter->end && iter->cursor == iter->last; \
} \
\
FMOD void PFX##_iter_tostart(SNAME##_iter *iter) \
{ \
iter->index = 0; \
iter->start = true; \
iter->end = PFX##_empty(iter->target); \
\
iter->cursor = iter->first; \
} \
\
FMOD void PFX##_iter_toend(SNAME##_iter *iter) \
{ \
iter->index = iter->target->count - 1; \
iter->start = PFX##_empty(iter->target); \
iter->end = true; \
\
iter->cursor = iter->last; \
} \
\
FMOD bool PFX##_iter_next(SNAME##_iter *iter, K *key, V *value, size_t *index) \
{ \
if (iter->end) \
return false; \
\
*key = iter->cursor->key; \
*value = iter->cursor->value; \
*index = iter->index; \
iter->start = false; \
\
if (iter->cursor->right != NULL) \
{ \
iter->cursor = iter->cursor->right; \
while (iter->cursor->left != NULL) \
iter->cursor = iter->cursor->left; \
\
iter->index++; \
\
return true; \
} \
\
while (true) \
{ \
if (iter->cursor == iter->last) \
{ \
iter->end = true; \
\
return true; \
} \
if (iter->cursor->parent->left == iter->cursor) \
{ \
iter->cursor = iter->cursor->parent; \
\
iter->index++; \
\
return true; \
} \
\
iter->cursor = iter->cursor->parent; \
} \
} \
\
FMOD bool PFX##_iter_prev(SNAME##_iter *iter, K *key, V *value, size_t *index) \
{ \
if (iter->start) \
return false; \
\
*key = iter->cursor->key; \
*value = iter->cursor->value; \
*index = iter->index; \
iter->end = false; \
\
if (iter->cursor->left != NULL) \
{ \
iter->cursor = iter->cursor->left; \
while (iter->cursor->right != NULL) \
iter->cursor = iter->cursor->right; \
\
iter->index--; \
\
return true; \
} \
\
while (true) \
{ \
if (iter->cursor == iter->first) \
{ \
iter->start = true; \
\
return true; \
} \
if (iter->cursor->parent->right == iter->cursor) \
{ \
iter->cursor = iter->cursor->parent; \
\
iter->index--; \
\
return true; \
} \
\
iter->cursor = iter->cursor->parent; \
} \
}
#endif /* CMC_TREEMAP_H */
src/treeset.h
+158 -157
View File
@@ -189,6 +189,7 @@
if (PFX##_empty(_set_)) \
{ \
_set_->root = PFX##_new_node(element); \
\
if (!_set_->root) \
return false; \
} \
@@ -410,163 +411,6 @@
return _set_->count; \
} \
\
FMOD SNAME##_node *PFX##_new_node(V element) \
{ \
SNAME##_node *node = malloc(sizeof(SNAME##_node)); \
\
if (!node) \
return NULL; \
\
node->key = element; \
node->right = NULL; \
node->left = NULL; \
node->parent = NULL; \
node->height = 0; \
\
return node; \
} \
\
FMOD SNAME##_node *PFX##_get_node(SNAME *_set_, V element) \
{ \
if (PFX##_empty(_set_)) \
return NULL; \
\
SNAME##_node *scan = _set_->root; \
\
while (scan != NULL) \
{ \
if (_set_->cmp(scan->key, element) > 0) \
scan = scan->left; \
else if (_set_->cmp(scan->key, element) < 0) \
scan = scan->right; \
else \
return scan; \
} \
\
return NULL; \
} \
\
FMOD unsigned char PFX##_h(SNAME##_node *node) \
{ \
if (node == NULL) \
return 0; \
\
return node->height; \
} \
\
FMOD unsigned char PFX##_hupdate(SNAME##_node *node) \
{ \
if (node == NULL) \
return 0; \
\
unsigned char h_l = PFX##_h(node->left); \
unsigned char h_r = PFX##_h(node->right); \
\
return 1 + (h_l > h_r ? h_l : h_r); \
} \
\
FMOD void PFX##_rotate_right(SNAME##_node **Z) \
{ \
SNAME##_node *root = *Z; \
SNAME##_node *new_root = root->left; \
\
if (root->parent != NULL) \
{ \
if (root->parent->left == root) \
root->parent->left = new_root; \
else \
root->parent->right = new_root; \
} \
\
new_root->parent = root->parent; \
\
root->parent = new_root; \
root->left = new_root->right; \
\
if (root->left) \
root->left->parent = root; \
\
new_root->right = root; \
\
root->height = PFX##_hupdate(root); \
new_root->height = PFX##_hupdate(new_root); \
\
*Z = new_root; \
} \
\
FMOD void PFX##_rotate_left(SNAME##_node **Z) \
{ \
SNAME##_node *root = *Z; \
SNAME##_node *new_root = root->right; \
\
if (root->parent != NULL) \
{ \
if (root->parent->right == root) \
root->parent->right = new_root; \
else \
root->parent->left = new_root; \
} \
\
new_root->parent = root->parent; \
\
root->parent = new_root; \
root->right = new_root->left; \
\
if (root->right) \
root->right->parent = root; \
\
new_root->left = root; \
\
root->height = PFX##_hupdate(root); \
new_root->height = PFX##_hupdate(new_root); \
\
*Z = new_root; \
} \
\
FMOD void PFX##_rebalance(SNAME *_set_, SNAME##_node *node) \
{ \
SNAME##_node *scan = node, *child = NULL; \
\
int balance; \
bool is_root = false; \
\
while (scan != NULL) \
{ \
if (scan->parent == NULL) \
is_root = true; \
\
scan->height = PFX##_hupdate(scan); \
balance = PFX##_h(scan->right) - PFX##_h(scan->left); \
\
if (balance >= 2) \
{ \
child = scan->right; \
\
if (PFX##_h(child->right) < PFX##_h(child->left)) \
PFX##_rotate_right(&(scan->right)); \
\
PFX##_rotate_left(&scan); \
} \
else if (balance <= -2) \
{ \
child = scan->left; \
\
if (PFX##_h(child->left) < PFX##_h(child->right)) \
PFX##_rotate_left(&(scan->left)); \
\
PFX##_rotate_right(&scan); \
} \
\
if (is_root) \
{ \
_set_->root = scan; \
is_root = false; \
} \
\
scan = scan->parent; \
} \
} \
\
FMOD SNAME *PFX##_union(SNAME *_set1_, SNAME *_set2_) \
{ \
SNAME##_iter iter1, iter2; \
@@ -802,6 +646,163 @@
\
iter->cursor = iter->cursor->parent; \
} \
} \
\
FMOD SNAME##_node *PFX##_new_node(V element) \
{ \
SNAME##_node *node = malloc(sizeof(SNAME##_node)); \
\
if (!node) \
return NULL; \
\
node->key = element; \
node->right = NULL; \
node->left = NULL; \
node->parent = NULL; \
node->height = 0; \
\
return node; \
} \
\
FMOD SNAME##_node *PFX##_get_node(SNAME *_set_, V element) \
{ \
if (PFX##_empty(_set_)) \
return NULL; \
\
SNAME##_node *scan = _set_->root; \
\
while (scan != NULL) \
{ \
if (_set_->cmp(scan->key, element) > 0) \
scan = scan->left; \
else if (_set_->cmp(scan->key, element) < 0) \
scan = scan->right; \
else \
return scan; \
} \
\
return NULL; \
} \
\
FMOD unsigned char PFX##_h(SNAME##_node *node) \
{ \
if (node == NULL) \
return 0; \
\
return node->height; \
} \
\
FMOD unsigned char PFX##_hupdate(SNAME##_node *node) \
{ \
if (node == NULL) \
return 0; \
\
unsigned char h_l = PFX##_h(node->left); \
unsigned char h_r = PFX##_h(node->right); \
\
return 1 + (h_l > h_r ? h_l : h_r); \
} \
\
FMOD void PFX##_rotate_right(SNAME##_node **Z) \
{ \
SNAME##_node *root = *Z; \
SNAME##_node *new_root = root->left; \
\
if (root->parent != NULL) \
{ \
if (root->parent->left == root) \
root->parent->left = new_root; \
else \
root->parent->right = new_root; \
} \
\
new_root->parent = root->parent; \
\
root->parent = new_root; \
root->left = new_root->right; \
\
if (root->left) \
root->left->parent = root; \
\
new_root->right = root; \
\
root->height = PFX##_hupdate(root); \
new_root->height = PFX##_hupdate(new_root); \
\
*Z = new_root; \
} \
\
FMOD void PFX##_rotate_left(SNAME##_node **Z) \
{ \
SNAME##_node *root = *Z; \
SNAME##_node *new_root = root->right; \
\
if (root->parent != NULL) \
{ \
if (root->parent->right == root) \
root->parent->right = new_root; \
else \
root->parent->left = new_root; \
} \
\
new_root->parent = root->parent; \
\
root->parent = new_root; \
root->right = new_root->left; \
\
if (root->right) \
root->right->parent = root; \
\
new_root->left = root; \
\
root->height = PFX##_hupdate(root); \
new_root->height = PFX##_hupdate(new_root); \
\
*Z = new_root; \
} \
\
FMOD void PFX##_rebalance(SNAME *_set_, SNAME##_node *node) \
{ \
SNAME##_node *scan = node, *child = NULL; \
\
int balance; \
bool is_root = false; \
\
while (scan != NULL) \
{ \
if (scan->parent == NULL) \
is_root = true; \
\
scan->height = PFX##_hupdate(scan); \
balance = PFX##_h(scan->right) - PFX##_h(scan->left); \
\
if (balance >= 2) \
{ \
child = scan->right; \
\
if (PFX##_h(child->right) < PFX##_h(child->left)) \
PFX##_rotate_right(&(scan->right)); \
\
PFX##_rotate_left(&scan); \
} \
else if (balance <= -2) \
{ \
child = scan->left; \
\
if (PFX##_h(child->left) < PFX##_h(child->right)) \
PFX##_rotate_left(&(scan->left)); \
\
PFX##_rotate_right(&scan); \
} \
\
if (is_root) \
{ \
_set_->root = scan; \
is_root = false; \
} \
\
scan = scan->parent; \
} \
}
#endif /* CMC_TREESET_H */