all: Revert and add some style changes

Signed-off-by: Andrew Opalach <andrew@akon.city>

3 files changed, 102 insertions, 176 deletions

diff --git a/src/array.c b/src/array.c
index 0019a63..46d7951 100644
--- a/src/array.c
+++ b/src/array.c
@@ -14,118 +14,91 @@
 
 #define al_array_init(array) ((array).count = 0, (array).alloc = 0, (array).data = NULL)
 
-#define al_array_offset(array, n) ((array).data + (n))
 #define al_array_at(array, i) ((array).data[i])
 #define al_array_last(array) al_array_at(array, (array).count - 1)
+#define al_array_offset(array, n) ((array).data + (n))
 
 #define al_array_item_size(array) sizeof(*(array).data) // NOLINT(bugprone-sizeof-expression)
 #define al_array_reserve(array, count) \
     ((array).alloc = _al_array_reserve((void **)&(array).data, (array).alloc, ((count) * al_array_item_size(array))))
 
-#define al_array_clone(dest, src)                                 \
-AL_MACRO_WRAP                                                     \
-{                                                                 \
-    al_array_init(dest);                                          \
-    al_array_reserve(dest, (src).count);                          \
-    (dest).count = (src).count;                                   \
-    al_memcpy(al_array_offset(dest, 0), al_array_offset(src, 0),  \
-        al_array_item_size(dest) * (dest).count);                 \
-} AL_MACRO_END
+#define al_array_copy(dest, src)                                      \
+    do {                                                              \
+        al_array_reserve(dest, (src).count);                          \
+        (dest).count = (src).count;                                   \
+        al_memcpy(al_array_offset(dest, 0), al_array_offset(src, 0),  \
+            al_array_item_size(dest) * (dest).count);                 \
+    } while (0)
 
-#define al_array_copy(dest, src)                                  \
-AL_MACRO_WRAP                                                     \
-{                                                                 \
-    al_array_reserve(dest, (src).count);                          \
-    (dest).count = (src).count;                                   \
-    al_memcpy(al_array_offset(dest, 0), al_array_offset(src, 0),  \
-        al_array_item_size(dest) * (dest).count);                 \
-} AL_MACRO_END
+#define al_array_push(array, item)                   \
+    do {                                             \
+        al_array_reserve(array, (array).count + 1);  \
+        al_array_at(array, (array).count++) = item;  \
+    } while (0)
 
-#define al_array_push(array, item)               \
-AL_MACRO_WRAP                                    \
-{                                                \
-    al_array_reserve(array, (array).count + 1);  \
-    __typeof__(item) v = item;                   \
-    (void)((array).data == &v);                  \
-    al_array_at(array, (array).count++) = v;     \
-} AL_MACRO_END
-
-#define al_array_insert(array, i, item)                                       \
-AL_MACRO_WRAP                                                                 \
-{                                                                             \
-    al_array_reserve(array, (array).count + 1);                               \
-    if (i != (array).count - 1) {                                             \
-        al_memmove(al_array_offset(array, i + 1), al_array_offset(array, i),  \
-            al_array_item_size(array) * ((array).count - i));                 \
-    }                                                                         \
-    (array).count++;                                                          \
-    __typeof__(item) v = item;                                                \
-    (void)((array).data == &v);                                               \
-    al_array_at(array, i) = v;                                                \
-} AL_MACRO_END
+#define al_array_insert(array, i, item)                                           \
+    do {                                                                          \
+        al_array_reserve(array, (array).count + 1);                               \
+        if (i != (array).count - 1) {                                             \
+            al_memmove(al_array_offset(array, i + 1), al_array_offset(array, i),  \
+                al_array_item_size(array) * ((array).count - i));                 \
+        }                                                                         \
+        (array).count++;                                                          \
+        al_array_at(array, i) = item;                                             \
+    } while (0)
 
 #define al_array_pop(array) al_array_at(array, --(array).count)
-#define al_array_pop_at(array, i, r) \
-AL_MACRO_WRAP                      \
-{                                  \
-    r = al_array_at(array, i);     \
-    al_array_remove_at(array, i);  \
-} AL_MACRO_END
-
-#define al_array_remove(array, elem)           \
-AL_MACRO_WRAP                                  \
-{                                              \
-    for (u32 i = 0; i < (array).count; i++) {  \
-        if (al_array_at(array, i) == elem) {   \
-            al_array_remove_at(array, i);      \
-            break;                             \
-        }                                      \
-    }                                          \
-} AL_MACRO_END
+#define al_array_pop_at(array, i, r)   \
+    do {                               \
+        r = al_array_at(array, i);     \
+        al_array_remove_at(array, i);  \
+    } while (0)
 
-#define al_array_remove_checked(array, elem, removed) \
-AL_MACRO_WRAP                                  \
-{                                              \
-    removed = false;                           \
-    for (u32 i = 0; i < (array).count; i++) {  \
-        if (al_array_at(array, i) == elem) {   \
-            al_array_remove_at(array, i);      \
-            removed = true;                    \
-            break;                             \
-        }                                      \
-    }                                          \
-} AL_MACRO_END
+#define al_array_remove_at(array, i)                                              \
+    do {                                                                          \
+        if (i == (array).count - 1) {                                             \
+            (array).count--;                                                      \
+        } else {                                                                  \
+            al_memmove(al_array_offset(array, i), al_array_offset(array, i + 1),  \
+                al_array_item_size(array) * (--(array).count - i));               \
+        }                                                                         \
+    } while (0)
 
-#define al_array_remove_all(array, elem)      \
-AL_MACRO_WRAP                                 \
-{                                             \
-    for (u32 i = (array).count; i-- > 0;) {   \
-        if (al_array_at(array, i) == elem) {  \
-            al_array_remove_at(array, i);     \
-        }                                     \
-    }                                         \
-} AL_MACRO_END
+#define al_array_remove_range(array, start, end)                                    \
+    do {                                                                            \
+        if (end != (array).count) {                                                 \
+            al_memmove(al_array_offset(array, start), al_array_offset(array, end),  \
+                al_array_item_size(array) * ((array).count - end));                 \
+        }                                                                           \
+        (array).count -= end - start;                                               \
+    } while (0)
 
-#define al_array_remove_at(array, i)                                          \
-AL_MACRO_WRAP                                                                 \
-{                                                                             \
-    if (i == (array).count - 1) {                                             \
-        (array).count--;                                                      \
-    } else {                                                                  \
-        al_memmove(al_array_offset(array, i), al_array_offset(array, i + 1),  \
-            al_array_item_size(array) * (--(array).count - i));               \
-    }                                                                         \
-} AL_MACRO_END
+#ifdef AL_HAVE_GNU_EXTENSIONS
+#define al_array_remove(array, elem)               \
+    ({                                             \
+        bool removed = false;                      \
+        for (u32 i = 0; i < (array).count; i++) {  \
+            if (al_array_at(array, i) == elem) {   \
+                al_array_remove_at(array, i);      \
+                removed = true;                    \
+                break;                             \
+            }                                      \
+        }                                          \
+        removed;                                   \
+    })
 
-#define al_array_remove_range(array, start, end)                                \
-AL_MACRO_WRAP                                                                   \
-{                                                                               \
-    if (end != (array).count) {                                                 \
-        al_memmove(al_array_offset(array, start), al_array_offset(array, end),  \
-            al_array_item_size(array) * ((array).count - end));                 \
-    }                                                                           \
-    (array).count -= end - start;                                               \
-} AL_MACRO_END
+#define al_array_remove_all(array, elem)          \
+    ({                                            \
+        bool removed = false;                     \
+        for (u32 i = (array).count; i-- > 0;) {   \
+            if (al_array_at(array, i) == elem) {  \
+                al_array_remove_at(array, i);     \
+                removed = true;                   \
+            }                                     \
+        }                                         \
+        removed;                                  \
+    })
+#endif
 
 #ifdef AL_USE_STDLIB
 #define al_array_sort(array, type, cmp) AL_STDLIB_QSORT((array).data, type, (array).count, cmp)
@@ -149,17 +122,12 @@ AL_MACRO_WRAP
     for (u32 i = (array).count; (i-- > 0 && (item = al_array_offset(array, i), 1));)
 
 #define al_array_remove_at_iter(array, i) \
-AL_MACRO_WRAP                      \
-{                                  \
-    al_array_remove_at(array, i);  \
-    i--;                           \
-} AL_MACRO_END
-
-AL_UNUSED_FUNCTION_PUSH
+    do {                               \
+        al_array_remove_at(array, i);  \
+        i--;                           \
+    } while (0)
 
 static inline u32 _al_array_reserve(void **ptr, u32 prev_size, u32 size)
 {
-    return al_default_growing_allocation(ptr, prev_size, size, AL_ARRAY_MALLOC, AL_ARRAY_REALLOC);
+    return al_growing_allocation(ptr, prev_size, size, AL_ARRAY_MALLOC, AL_ARRAY_REALLOC);
 }
-
-AL_UNUSED_FUNCTION_POP
diff --git a/src/lib.c b/src/lib.c
index 9641976..96a43fe 100644
--- a/src/lib.c
+++ b/src/lib.c
@@ -1,11 +1,13 @@
 #include "../include/al/lib.h"
 
-// https://forum.vcfed.org/index.php?threads/c-item-size-check-at-compile-time.1244920/
-#define AL_ASSERT_TYPE_SIZE(type, size) \
-    typedef char type##__size_test[(!!(sizeof(type) == size)) * 2 - 1]
-
 AL_ASSERT_TYPE_SIZE(int, 4);
 AL_ASSERT_TYPE_SIZE(unsigned, 4);
+#if defined AL_WE_64BIT
+AL_ASSERT_TYPE_SIZE(intptr_t, 8);
+#elif defined AL_WE_32BIT
+AL_ASSERT_TYPE_SIZE(long, 4);
+AL_ASSERT_TYPE_SIZE(intptr_t, 4);
+#endif
 
 #ifdef AL_MEMORY_TRACKING
 static void *(*_al_malloc)(size_t) = NULL;
@@ -61,51 +63,34 @@ void al_malloc_close(void)
 void *al_malloc(size_t n)
 {
     al_printf("**al_malloc(%zu)\n", n);
-
     void *ptr = _al_malloc(n);
-
     _al_malloc_lock();
-
     total_changed_by(n);
     current_changed_by(n);
-
     al_array_push(allocations, ((struct al_alloc_t){ ptr, n }));
-
     _al_malloc_unlock();
-
     return ptr;
 }
 
 void *al_calloc(size_t n, size_t size)
 {
     al_printf("**al_calloc(%zu, %zu)\n", n, size);
-
     void *ptr = _al_calloc(n, size);
-
     size_t real_size = n * size;
-
     _al_malloc_lock();
-
     total_changed_by(real_size);
     current_changed_by(real_size);
-
     al_array_push(allocations, ((struct al_alloc_t){ ptr, real_size }));
-
     _al_malloc_unlock();
-
     return ptr;
 }
 
 void *al_realloc(void *ptr, size_t n)
 {
     al_printf("**al_realloc(%p, %zu)\n", ptr, n);
-
     void *new_ptr = _al_realloc(ptr, n);
-
     _al_malloc_lock();
-
     total_changed_by(n);
-
     if (!ptr) {
         current_changed_by(n);
         al_array_push(allocations, ((struct al_alloc_t){ ptr, n }));
@@ -121,18 +106,14 @@ void *al_realloc(void *ptr, size_t n)
             }
         }
     }
-
     _al_malloc_unlock();
-
     return new_ptr;
 }
 
 void al_free(void *ptr)
 {
     al_printf("**al_free(%p)\n", ptr);
-
     _al_malloc_lock();
-
     bool found = false;
     struct al_alloc_t *alloc;
     al_array_foreach_ptr(allocations, i, alloc) {
@@ -144,9 +125,7 @@ void al_free(void *ptr)
         }
     }
     al_assert(found);
-
     _al_malloc_unlock();
-
     _al_free(ptr);
 }
 
@@ -155,18 +134,12 @@ s32 al_posix_memalign(void **ptr, size_t alignment, size_t n)
 {
     size_t real_size = (n + alignment) - ((n + alignment) % alignment);
     al_printf("**al_posix_memalign(%zu, %zu(%zu))\n", alignment, n, real_size);
-
     s32 result = _al_posix_memalign(ptr, alignment, n);
-
     _al_malloc_lock();
-
     total_changed_by(real_size);
     current_changed_by(real_size);
-
     al_array_push(allocations, ((struct al_alloc_t){ *ptr, real_size }));
-
     _al_malloc_unlock();
-
     return result;
 }
 #endif
@@ -174,11 +147,9 @@ s32 al_posix_memalign(void **ptr, size_t alignment, size_t n)
 void al_malloc_stats(size_t *current, size_t *peak, size_t *total)
 {
     _al_malloc_lock();
-
     *current = current_alloc;
     *peak = peak_alloc;
     *total = total_alloc;
-
     _al_malloc_unlock();
 }
 
@@ -203,15 +174,18 @@ void al_set_alloc(void *(*malloc_func)(size_t), void *(*calloc_func)(size_t, siz
 
 u32 al_grow_step = 0x3fff; // 0b11111111111111
 
-u32 al_default_growing_allocation(void **ptr, u32 prev_size, u32 size,
+u32 al_growing_allocation(void **ptr, u32 prev_size, u32 size,
     void *(*malloc_func)(size_t), void *(*realloc_func)(void *, size_t))
 {
     if (size <= prev_size) return prev_size;
-    al_assert(size > 0);
 
-    size = size < al_grow_step ? al_next_power_of_two(size) :
-        al_add_wrap(size, al_grow_step, MAX_ALLOC_32) & ~al_grow_step;
-    // This should only happen after wrapping around MAX_ALLOC_32 (zero all possible bits).
+    al_assert(size > 0);
+    if (size < al_grow_step) {
+        size = al_next_power_of_two(size);
+    } else {
+        size = al_u32_add_wrap(size, al_grow_step, MAX_ALLOC_32) & ~al_grow_step;
+    }
+    // size can only be 0 after wrapping around MAX_ALLOC_32 (zero all possible bits).
     if (size == 0) size = MAX_ALLOC_32;
 
     *ptr = (!*ptr) ? malloc_func(size) : realloc_func(*ptr, size);
@@ -220,7 +194,7 @@ u32 al_default_growing_allocation(void **ptr, u32 prev_size, u32 size,
     return size;
 }
 
-size_t al_page_size = 0x1000;
+size_t al_page_size = 0x1000; // 4096
 void al_set_page_size(size_t size)
 {
     al_assert(size > 0);
diff --git a/src/ring_buffer.c b/src/ring_buffer.c
index ded0138..b1c2fe5 100644
--- a/src/ring_buffer.c
+++ b/src/ring_buffer.c
@@ -3,7 +3,6 @@
 #include "../include/al/macros.h"
 
 // https://github.com/MusicPlayerDaemon/MPD/blob/master/src/util/RingBuffer.hxx
-//
 // This is no longer an implementation of a "contiguous" ring buffer but I used this as reference.
 // Wrapping is handled in read() and write().
 // https://andrea.lattuada.me/blog/2019/the-design-and-implementation-of-a-lock-free-ring-buffer-with-contiguous-reservations.html
@@ -17,9 +16,7 @@ void al_ring_buffer_init(struct al_ring_buffer *buf, u8 *data, ptrdiff_t length)
 
 static inline u8 *previous(struct al_ring_buffer *buf, u8 *ptr)
 {
-    if (ptr == buf->start) {
-        ptr = buf->end;
-    }
+    if (ptr == buf->start) ptr = buf->end;
     return --ptr;
 }
 
@@ -42,7 +39,7 @@ u8 *al_ring_buffer_write_chunk(struct al_ring_buffer *buf, ptrdiff_t *size)
 {
     u8 *wp = al_atomic_load(void)(&buf->write, AL_ATOMIC_ACQUIRE);
     u8 *rp = previous(buf, al_atomic_load(void)(&buf->read, AL_ATOMIC_RELAXED));
-    *size = (wp <= rp ? rp : buf->end) - wp;
+    *size = ((wp <= rp) ? rp : buf->end) - wp;
     return wp;
 }
 
@@ -62,7 +59,7 @@ u8 *al_ring_buffer_read_chunk(struct al_ring_buffer *buf, ptrdiff_t *size)
 {
     u8 *rp = al_atomic_load(void)(&buf->read, AL_ATOMIC_ACQUIRE);
     u8 *wp = al_atomic_load(void)(&buf->write, AL_ATOMIC_RELAXED);
-    *size = (rp <= wp ? wp : buf->end) - rp;
+    *size = ((rp <= wp) ? wp : buf->end) - rp;
     return rp;
 }
 
@@ -76,14 +73,12 @@ ptrdiff_t al_ring_buffer_write(struct al_ring_buffer *buf, u8 *data, ptrdiff_t n
     u8 *wp = al_atomic_load(void)(&buf->write, AL_ATOMIC_ACQUIRE);
     u8 *rp = previous(buf, al_atomic_load(void)(&buf->read, AL_ATOMIC_RELAXED));
 
-    ptrdiff_t size, wrap;
-
-    size = MIN((wp <= rp ? rp : buf->end) - wp, n);
+    ptrdiff_t size = MIN(((wp <= rp) ? rp : buf->end) - wp, n);
     al_memcpy(wp, data, (size_t)size);
     wp += size;
 
     if (wp >= buf->end) {
-        wrap = MIN(rp - buf->start, n - size);
+        ptrdiff_t wrap = MIN(rp - buf->start, n - size);
         al_memcpy(buf->start, data + size, (size_t)wrap);
         wp = buf->start + wrap;
         size += wrap;
@@ -99,14 +94,12 @@ ptrdiff_t al_ring_buffer_read(struct al_ring_buffer *buf, u8 *ptr, ptrdiff_t n)
     u8 *rp = al_atomic_load(void)(&buf->read, AL_ATOMIC_ACQUIRE);
     u8 *wp = al_atomic_load(void)(&buf->write, AL_ATOMIC_RELAXED);
 
-    ptrdiff_t size, wrap;
-
-    size = MIN((rp <= wp ? wp : buf->end) - rp, n);
+    ptrdiff_t size = MIN(((rp <= wp) ? wp : buf->end) - rp, n);
     al_memcpy(ptr, rp, (size_t)size);
     rp += size;
 
     if (rp >= buf->end) {
-        wrap = MIN(wp - buf->start, n - size);
+        ptrdiff_t wrap = MIN(wp - buf->start, n - size);
         al_memcpy(ptr + size, buf->start, (size_t)wrap);
         rp = buf->start + wrap;
         size += wrap;
@@ -122,20 +115,14 @@ ptrdiff_t al_ring_buffer_peek(struct al_ring_buffer *buf, u8 *ptr, ptrdiff_t off
     u8 *rp = al_atomic_load(void)(&buf->read, AL_ATOMIC_RELAXED);
     u8 *wp = al_atomic_load(void)(&buf->write, AL_ATOMIC_RELAXED);
 
-    ptrdiff_t size, wrap;
-
+    ptrdiff_t size;
     if (rp <= wp) {
         rp += offset;
-
         size = MIN(wp - rp, n);
-        if (size < 0) {
-            return 0;
-        }
-
+        if (size < 0) return 0;
         al_memcpy(ptr, rp, (size_t)size);
     } else {
         rp += offset;
-
         size = MIN(buf->end - rp, n);
         if (size > 0) {
             al_memcpy(ptr, rp, (size_t)size);
@@ -145,8 +132,7 @@ ptrdiff_t al_ring_buffer_peek(struct al_ring_buffer *buf, u8 *ptr, ptrdiff_t off
             rp = buf->start - size;
             size = 0;
         }
-
-        wrap = MIN(wp - rp, n);
+        ptrdiff_t wrap = MIN(wp - rp, n);
         if (wrap > 0) {
             al_memcpy(ptr + size, rp, (size_t)wrap);
             size += wrap;
@@ -161,13 +147,11 @@ ptrdiff_t al_ring_buffer_discard(struct al_ring_buffer *buf, ptrdiff_t n)
     u8 *rp = al_atomic_load(void)(&buf->read, AL_ATOMIC_ACQUIRE);
     u8 *wp = al_atomic_load(void)(&buf->write, AL_ATOMIC_RELAXED);
 
-    ptrdiff_t discard, wrap;
-
-    discard = MIN((rp <= wp ? wp : buf->end) - rp, n);
+    ptrdiff_t discard = MIN(((rp <= wp) ? wp : buf->end) - rp, n);
     rp += discard;
 
     if (rp >= buf->end) {
-        wrap = MIN(wp - buf->start, n - discard);
+        ptrdiff_t wrap = MIN(wp - buf->start, n - discard);
         rp = buf->start + wrap;
         discard += wrap;
     }