diff options
author | Campbell Barton <ideasman42@gmail.com> | 2019-04-17 07:17:24 +0300 |
---|---|---|
committer | Campbell Barton <ideasman42@gmail.com> | 2019-04-17 07:21:24 +0300 |
commit | e12c08e8d170b7ca40f204a5b0423c23a9fbc2c1 (patch) | |
tree | 8cf3453d12edb177a218ef8009357518ec6cab6a /source/blender/blenlib/intern/BLI_memiter.c | |
parent | b3dabc200a4b0399ec6b81f2ff2730d07b44fcaa (diff) |
ClangFormat: apply to source, most of intern
Apply clang format as proposed in T53211.
For details on usage and instructions for migrating branches
without conflicts, see:
https://wiki.blender.org/wiki/Tools/ClangFormat
Diffstat (limited to 'source/blender/blenlib/intern/BLI_memiter.c')
-rw-r--r-- | source/blender/blenlib/intern/BLI_memiter.c | 307 |
1 files changed, 151 insertions, 156 deletions
diff --git a/source/blender/blenlib/intern/BLI_memiter.c b/source/blender/blenlib/intern/BLI_memiter.c index df8a1de84e4..c7df7d5fdd4 100644 --- a/source/blender/blenlib/intern/BLI_memiter.c +++ b/source/blender/blenlib/intern/BLI_memiter.c @@ -69,66 +69,65 @@ typedef intptr_t offset_t; // #define USE_TERMINATE_PARANOID /* Currently totalloc isnt used. */ - // #define USE_TOTALLOC +// #define USE_TOTALLOC /* pad must be power of two */ -#define PADUP(num, pad) (((num) + ((pad) - 1)) & ~((pad) - 1)) +#define PADUP(num, pad) (((num) + ((pad)-1)) & ~((pad)-1)) typedef struct BLI_memiter_elem { - offset_t size; - data_t data[0]; + offset_t size; + data_t data[0]; } BLI_memiter_elem; typedef struct BLI_memiter_chunk { - struct BLI_memiter_chunk *next; - /** - * internal format is: - * ``[next_pointer, size:data, size:data, ..., negative_offset]`` - * - * Where negative offset rewinds to the start. - */ - data_t data[0]; + struct BLI_memiter_chunk *next; + /** + * internal format is: + * ``[next_pointer, size:data, size:data, ..., negative_offset]`` + * + * Where negative offset rewinds to the start. + */ + data_t data[0]; } BLI_memiter_chunk; typedef struct BLI_memiter { - /* A pointer to 'head' is needed so we can iterate in the order allocated. */ - struct BLI_memiter_chunk *head, *tail; - data_t *data_curr; - data_t *data_last; - /* Used unless a large element is requested. - * (which should be very rare!). */ - uint chunk_size_in_bytes_min; - uint count; + /* A pointer to 'head' is needed so we can iterate in the order allocated. */ + struct BLI_memiter_chunk *head, *tail; + data_t *data_curr; + data_t *data_last; + /* Used unless a large element is requested. + * (which should be very rare!). */ + uint chunk_size_in_bytes_min; + uint count; #ifdef USE_TOTALLOC - uint totalloc; + uint totalloc; #endif } BLI_memiter; - BLI_INLINE uint data_offset_from_size(uint size) { - return (PADUP(size, (uint)sizeof(data_t))) / (uint)sizeof(data_t); + return (PADUP(size, (uint)sizeof(data_t))) / (uint)sizeof(data_t); } static void memiter_set_rewind_offset(BLI_memiter *mi) { - BLI_memiter_elem *elem = (BLI_memiter_elem *)mi->data_curr; + BLI_memiter_elem *elem = (BLI_memiter_elem *)mi->data_curr; - ASAN_UNPOISON_MEMORY_REGION(elem, sizeof(BLI_memiter_elem)); + ASAN_UNPOISON_MEMORY_REGION(elem, sizeof(BLI_memiter_elem)); - elem->size = (offset_t)(((data_t *)mi->tail) - mi->data_curr); - BLI_assert(elem->size < 0); + elem->size = (offset_t)(((data_t *)mi->tail) - mi->data_curr); + BLI_assert(elem->size < 0); } static void memiter_init(BLI_memiter *mi) { - mi->head = NULL; - mi->tail = NULL; - mi->data_curr = NULL; - mi->data_last = NULL; - mi->count = 0; + mi->head = NULL; + mi->tail = NULL; + mi->data_curr = NULL; + mi->data_last = NULL; + mi->count = 0; #ifdef USE_TOTALLOC - mi->totalloc = 0; + mi->totalloc = 0; #endif } @@ -147,126 +146,123 @@ static void memiter_init(BLI_memiter *mi) */ BLI_memiter *BLI_memiter_create(uint chunk_size_min) { - BLI_memiter *mi = MEM_mallocN(sizeof(BLI_memiter), "BLI_memiter"); - memiter_init(mi); - - /* Small values are used for tests to check for correctness, - * but otherwise not that useful. */ - const uint slop_space = (sizeof(BLI_memiter_chunk) + MEM_SIZE_OVERHEAD); - if (chunk_size_min >= 1024) { - /* As long as the input is a power of 2, this will give efficient sizes. */ - chunk_size_min -= slop_space; - } - - mi->chunk_size_in_bytes_min = chunk_size_min; - return mi; + BLI_memiter *mi = MEM_mallocN(sizeof(BLI_memiter), "BLI_memiter"); + memiter_init(mi); + + /* Small values are used for tests to check for correctness, + * but otherwise not that useful. */ + const uint slop_space = (sizeof(BLI_memiter_chunk) + MEM_SIZE_OVERHEAD); + if (chunk_size_min >= 1024) { + /* As long as the input is a power of 2, this will give efficient sizes. */ + chunk_size_min -= slop_space; + } + + mi->chunk_size_in_bytes_min = chunk_size_min; + return mi; } void *BLI_memiter_alloc(BLI_memiter *mi, uint elem_size) { - const uint data_offset = data_offset_from_size(elem_size); - data_t *data_curr_next = mi->data_curr + (1 + data_offset); + const uint data_offset = data_offset_from_size(elem_size); + data_t *data_curr_next = mi->data_curr + (1 + data_offset); - if (UNLIKELY(mi->data_curr == NULL) || (data_curr_next > mi->data_last)) { + if (UNLIKELY(mi->data_curr == NULL) || (data_curr_next > mi->data_last)) { #ifndef USE_TERMINATE_PARANOID - if (mi->data_curr != NULL) { - memiter_set_rewind_offset(mi); - } + if (mi->data_curr != NULL) { + memiter_set_rewind_offset(mi); + } #endif - uint chunk_size_in_bytes = mi->chunk_size_in_bytes_min; - if (UNLIKELY(chunk_size_in_bytes < elem_size + (uint)sizeof(data_t[2]))) { - chunk_size_in_bytes = elem_size + (uint)sizeof(data_t[2]); - } - uint chunk_size = data_offset_from_size(chunk_size_in_bytes); - BLI_memiter_chunk *chunk = MEM_mallocN( - sizeof(BLI_memiter_chunk) + - (chunk_size * sizeof(data_t)), - "BLI_memiter_chunk"); + uint chunk_size_in_bytes = mi->chunk_size_in_bytes_min; + if (UNLIKELY(chunk_size_in_bytes < elem_size + (uint)sizeof(data_t[2]))) { + chunk_size_in_bytes = elem_size + (uint)sizeof(data_t[2]); + } + uint chunk_size = data_offset_from_size(chunk_size_in_bytes); + BLI_memiter_chunk *chunk = MEM_mallocN( + sizeof(BLI_memiter_chunk) + (chunk_size * sizeof(data_t)), "BLI_memiter_chunk"); - if (mi->head == NULL) { - BLI_assert(mi->tail == NULL); - mi->head = chunk; - } - else { - mi->tail->next = chunk; - } - mi->tail = chunk; - chunk->next = NULL; + if (mi->head == NULL) { + BLI_assert(mi->tail == NULL); + mi->head = chunk; + } + else { + mi->tail->next = chunk; + } + mi->tail = chunk; + chunk->next = NULL; - mi->data_curr = chunk->data; - mi->data_last = chunk->data + (chunk_size - 1); - data_curr_next = mi->data_curr + (1 + data_offset); + mi->data_curr = chunk->data; + mi->data_last = chunk->data + (chunk_size - 1); + data_curr_next = mi->data_curr + (1 + data_offset); - ASAN_POISON_MEMORY_REGION(chunk->data, chunk_size * sizeof(data_t)); - } + ASAN_POISON_MEMORY_REGION(chunk->data, chunk_size * sizeof(data_t)); + } - BLI_assert(data_curr_next <= mi->data_last); + BLI_assert(data_curr_next <= mi->data_last); - BLI_memiter_elem *elem = (BLI_memiter_elem *)mi->data_curr; + BLI_memiter_elem *elem = (BLI_memiter_elem *)mi->data_curr; - ASAN_UNPOISON_MEMORY_REGION(elem, sizeof(BLI_memiter_elem) + elem_size); + ASAN_UNPOISON_MEMORY_REGION(elem, sizeof(BLI_memiter_elem) + elem_size); - elem->size = (offset_t)elem_size; - mi->data_curr = data_curr_next; + elem->size = (offset_t)elem_size; + mi->data_curr = data_curr_next; #ifdef USE_TERMINATE_PARANOID - memiter_set_rewind_offset(mi); + memiter_set_rewind_offset(mi); #endif - mi->count += 1; + mi->count += 1; #ifdef USE_TOTALLOC - mi->totalloc += elem_size; + mi->totalloc += elem_size; #endif - return elem->data; + return elem->data; } void *BLI_memiter_calloc(BLI_memiter *mi, uint elem_size) { - void *data = BLI_memiter_alloc(mi, elem_size); - memset(data, 0, elem_size); - return data; + void *data = BLI_memiter_alloc(mi, elem_size); + memset(data, 0, elem_size); + return data; } void BLI_memiter_alloc_from(BLI_memiter *mi, uint elem_size, const void *data_from) { - void *data = BLI_memiter_alloc(mi, elem_size); - memcpy(data, data_from, elem_size); + void *data = BLI_memiter_alloc(mi, elem_size); + memcpy(data, data_from, elem_size); } static void memiter_free_data(BLI_memiter *mi) { - BLI_memiter_chunk *chunk = mi->head; - while (chunk) { - BLI_memiter_chunk *chunk_next = chunk->next; - MEM_freeN(chunk); - chunk = chunk_next; - } + BLI_memiter_chunk *chunk = mi->head; + while (chunk) { + BLI_memiter_chunk *chunk_next = chunk->next; + MEM_freeN(chunk); + chunk = chunk_next; + } } void BLI_memiter_destroy(BLI_memiter *mi) { - memiter_free_data(mi); - MEM_freeN(mi); + memiter_free_data(mi); + MEM_freeN(mi); } void BLI_memiter_clear(BLI_memiter *mi) { - memiter_free_data(mi); - memiter_init(mi); + memiter_free_data(mi); + memiter_init(mi); } uint BLI_memiter_count(const BLI_memiter *mi) { - return mi->count; + return mi->count; } /** \} */ - /* -------------------------------------------------------------------- */ /** \name Helper API's * \{ */ @@ -274,32 +270,31 @@ uint BLI_memiter_count(const BLI_memiter *mi) /* Support direct lookup for first. */ void *BLI_memiter_elem_first(BLI_memiter *mi) { - if (mi->head != NULL) { - BLI_memiter_chunk *chunk = mi->head; - BLI_memiter_elem *elem = (BLI_memiter_elem *)chunk->data; - return elem->data; - } - else { - return NULL; - } + if (mi->head != NULL) { + BLI_memiter_chunk *chunk = mi->head; + BLI_memiter_elem *elem = (BLI_memiter_elem *)chunk->data; + return elem->data; + } + else { + return NULL; + } } void *BLI_memiter_elem_first_size(BLI_memiter *mi, uint *r_size) { - if (mi->head != NULL) { - BLI_memiter_chunk *chunk = mi->head; - BLI_memiter_elem *elem = (BLI_memiter_elem *)chunk->data; - *r_size = (uint)elem->size; - return elem->data; - } - else { - return NULL; - } + if (mi->head != NULL) { + BLI_memiter_chunk *chunk = mi->head; + BLI_memiter_elem *elem = (BLI_memiter_elem *)chunk->data; + *r_size = (uint)elem->size; + return elem->data; + } + else { + return NULL; + } } /** \} */ - /* -------------------------------------------------------------------- */ /** \name Iterator API's * @@ -313,59 +308,59 @@ void *BLI_memiter_elem_first_size(BLI_memiter *mi, uint *r_size) void BLI_memiter_iter_init(BLI_memiter *mi, BLI_memiter_handle *iter) { - iter->elem = mi->head ? (BLI_memiter_elem *)mi->head->data : NULL; - iter->elem_left = mi->count; + iter->elem = mi->head ? (BLI_memiter_elem *)mi->head->data : NULL; + iter->elem_left = mi->count; } bool BLI_memiter_iter_done(const BLI_memiter_handle *iter) { - return iter->elem_left != 0; + return iter->elem_left != 0; } BLI_INLINE void memiter_chunk_step(BLI_memiter_handle *iter) { - BLI_assert(iter->elem->size < 0); - BLI_memiter_chunk *chunk = (BLI_memiter_chunk *)(((data_t *)iter->elem) + iter->elem->size); - chunk = chunk->next; - iter->elem = chunk ? (BLI_memiter_elem *)chunk->data : NULL; - BLI_assert(iter->elem == NULL || iter->elem->size >= 0); + BLI_assert(iter->elem->size < 0); + BLI_memiter_chunk *chunk = (BLI_memiter_chunk *)(((data_t *)iter->elem) + iter->elem->size); + chunk = chunk->next; + iter->elem = chunk ? (BLI_memiter_elem *)chunk->data : NULL; + BLI_assert(iter->elem == NULL || iter->elem->size >= 0); } void *BLI_memiter_iter_step_size(BLI_memiter_handle *iter, uint *r_size) { - if (iter->elem_left != 0) { - iter->elem_left -= 1; - if (UNLIKELY(iter->elem->size < 0)) { - memiter_chunk_step(iter); - } - BLI_assert(iter->elem->size >= 0); - uint size = (uint)iter->elem->size; - *r_size = size; /* <-- only difference */ - data_t *data = iter->elem->data; - iter->elem = (BLI_memiter_elem *)&data[data_offset_from_size(size)]; - return (void *)data; - } - else { - return NULL; - } + if (iter->elem_left != 0) { + iter->elem_left -= 1; + if (UNLIKELY(iter->elem->size < 0)) { + memiter_chunk_step(iter); + } + BLI_assert(iter->elem->size >= 0); + uint size = (uint)iter->elem->size; + *r_size = size; /* <-- only difference */ + data_t *data = iter->elem->data; + iter->elem = (BLI_memiter_elem *)&data[data_offset_from_size(size)]; + return (void *)data; + } + else { + return NULL; + } } void *BLI_memiter_iter_step(BLI_memiter_handle *iter) { - if (iter->elem_left != 0) { - iter->elem_left -= 1; - if (UNLIKELY(iter->elem->size < 0)) { - memiter_chunk_step(iter); - } - BLI_assert(iter->elem->size >= 0); - uint size = (uint)iter->elem->size; - data_t *data = iter->elem->data; - iter->elem = (BLI_memiter_elem *)&data[data_offset_from_size(size)]; - return (void *)data; - } - else { - return NULL; - } + if (iter->elem_left != 0) { + iter->elem_left -= 1; + if (UNLIKELY(iter->elem->size < 0)) { + memiter_chunk_step(iter); + } + BLI_assert(iter->elem->size >= 0); + uint size = (uint)iter->elem->size; + data_t *data = iter->elem->data; + iter->elem = (BLI_memiter_elem *)&data[data_offset_from_size(size)]; + return (void *)data; + } + else { + return NULL; + } } /** \} */ |