feat: added ability to redefine ARR_INIT_CAP and MAX_ALLOC_ATTEMPTS

8 files changed, 85 insertions, 84 deletions

diff --git a/include/moslib/ds/array.h b/include/moslib/ds/array.h
index 65b729f..92dacbd 100644
--- a/include/moslib/ds/array.h
+++ b/include/moslib/ds/array.h
@@ -150,9 +150,13 @@
 #ifndef MOSLIB_DS_ARRAY_H
 #define MOSLIB_DS_ARRAY_H
 
-#ifndef MOSLIB_FORCE_PREFIXES
+// Initial capacity to use in the array
+#ifndef MOS_ARR_INIT_CAP
+#define MOS_ARR_INIT_CAP 16
+#endif // MOS_ARR_INIT_CAP
+
+#ifndef MOS_FORCE_PREFIXES
 
-#define ARR_INIT_CAP MOS_ARR_INIT_CAP
 #define arr_get mos_arr_get
 #define arr_first mos_arr_first
 #define arr_last mos_arr_last
@@ -178,10 +182,7 @@
 #define arr_set_cap mos_arr_set_cap
 #define arr_free mos_arr_free
 
-#endif // MOSLIB_FORCE_PREFIXES
-
-// Initial capacity to use in the array
-#define MOS_ARR_INIT_CAP 16
+#endif // MOS_FORCE_PREFIXES
 
 // Get a pointer to an item at specific index in array
 //
@@ -231,10 +232,10 @@
 // Returns:
 //   index of the appended item
 #define mos_arr_push mos_arr_append
-#define mos_arr_append(arr, ...) (             \
-    mos_arr_append_fn(&(arr), sizeof(*(arr))), \
-    (arr)[mos_arr_len(arr) - 1] = __VA_ARGS__, \
-    mos_arr_len(arr) - 1                       \
+#define mos_arr_append(arr, ...) (                               \
+    mos_arr_append_fn(&(arr), sizeof(*(arr)), MOS_ARR_INIT_CAP), \
+    (arr)[mos_arr_len(arr) - 1] = __VA_ARGS__,                   \
+    mos_arr_len(arr) - 1                                         \
 )
 
 // Insert a given item at the specific position in the array
@@ -254,14 +255,14 @@
 //
 // Returns:
 //   index of the inserted item
-#define mos_arr_insert(arr, i, ...) (                 \
-    (size_t)(i) >= mos_arr_len(arr) ? (               \
-        mos_arr_append(arr, __VA_ARGS__)              \
-    ) : (                                             \
-        mos_arr_insert_fn(&(arr), i, sizeof(*(arr))), \
-        (arr)[(size_t)(i)] = __VA_ARGS__,             \
-        (size_t)(i)                                   \
-    )                                                 \
+#define mos_arr_insert(arr, i, ...) (                                   \
+    (size_t)(i) >= mos_arr_len(arr) ? (                                 \
+        mos_arr_append(arr, __VA_ARGS__)                                \
+    ) : (                                                               \
+        mos_arr_insert_fn(&(arr), i, sizeof(*(arr)), MOS_ARR_INIT_CAP), \
+        (arr)[(size_t)(i)] = __VA_ARGS__,                               \
+        (size_t)(i)                                                     \
+    )                                                                   \
 )
 
 // Put a given item at the specific position in the array
@@ -282,10 +283,10 @@
 //
 // Returns:
 //   index of the put item
-#define mos_arr_put(arr, i, ...) (             \
-    mos_arr_put_fn(&(arr), i, sizeof(*(arr))), \
-    (arr)[(size_t)(i)] = __VA_ARGS__,          \
-    (size_t)(i)                                \
+#define mos_arr_put(arr, i, ...) (                               \
+    mos_arr_put_fn(&(arr), i, sizeof(*(arr)), MOS_ARR_INIT_CAP), \
+    (arr)[(size_t)(i)] = __VA_ARGS__,                            \
+    (size_t)(i)                                                  \
 )
 
 // clang-format on
@@ -305,7 +306,7 @@
 // Returns:
 //   index of the first appended item
 #define mos_arr_push_n mos_arr_append_n
-#define mos_arr_append_n(arr, items, n) mos_arr_append_n_fn(&(arr), items, n, sizeof(*(arr)))
+#define mos_arr_append_n(arr, items, n) mos_arr_append_n_fn(&(arr), items, n, sizeof(*(arr)), MOS_ARR_INIT_CAP)
 
 // Insert n given items at the specific position in the array
 // Move everything after them to the right
@@ -326,7 +327,7 @@
 //
 // Returns:
 //   index of the first inserted item
-#define mos_arr_insert_n(arr, i, items, n) mos_arr_insert_n_fn(&(arr), i, items, n, sizeof(*(arr)))
+#define mos_arr_insert_n(arr, i, items, n) mos_arr_insert_n_fn(&(arr), i, items, n, sizeof(*(arr)), MOS_ARR_INIT_CAP)
 
 // Put n given items at the specific position in the array
 // If index is within array bounds - it overwrites the items at given spots
@@ -348,7 +349,7 @@
 //
 // Returns:
 //   index of the first put item
-#define mos_arr_put_n(arr, i, items, n) mos_arr_put_n_fn(&(arr), i, items, n, sizeof(*(arr)))
+#define mos_arr_put_n(arr, i, items, n) mos_arr_put_n_fn(&(arr), i, items, n, sizeof(*(arr)), MOS_ARR_INIT_CAP)
 
 // Concatenate two dynamic arrays of the same type
 //
@@ -361,7 +362,7 @@
 //
 // Returns:
 //   index of the first new item in arr1 or (size_t)-1 if arr2 is NULL or has length 0
-#define mos_arr_concat(arr1, arr2) mos_arr_concat_fn(&(arr1), arr2, sizeof(*(arr1)))
+#define mos_arr_concat(arr1, arr2) mos_arr_concat_fn(&(arr1), arr2, sizeof(*(arr1)), MOS_ARR_INIT_CAP)
 
 // Delete and retrieve the last item from the array
 // No bounds checking
@@ -483,7 +484,7 @@ extern size_t mos_arr_len(void *arr);
 //
 // Returns:
 //   count of the deleted items
-#define mos_arr_set_len(arr, len) mos_arr_set_len_fn(&(arr), len, sizeof(*(arr)))
+#define mos_arr_set_len(arr, len) mos_arr_set_len_fn(&(arr), len, sizeof(*(arr)), MOS_ARR_INIT_CAP)
 
 // Get the capacity of the array
 //
@@ -524,18 +525,18 @@ typedef struct {
 #define mos_arr_p_diff(p1, p2) (((char *)(p1) - (char*)(p2)) / sizeof(*(p2)))
 
 // Function prototypes for macros
-extern void mos_arr_append_fn(void *p_arr, size_t el_size);
-extern void mos_arr_insert_fn(void *p_arr, size_t i, size_t el_size);
-extern void mos_arr_put_fn(void *p_arr, size_t i, size_t el_size);
-extern size_t mos_arr_append_n_fn(void *p_arr, void *items, size_t n, size_t el_size);
-extern size_t mos_arr_insert_n_fn(void *p_arr, size_t i, void *items, size_t n, size_t el_size);
-extern size_t mos_arr_put_n_fn(void *p_arr, size_t i, void *items, size_t n, size_t el_size);
-extern size_t mos_arr_concat_fn(void *p_arr, void *arr2, size_t el_size);
+extern void mos_arr_append_fn(void *p_arr, size_t el_size, size_t init_cap);
+extern void mos_arr_insert_fn(void *p_arr, size_t i, size_t el_size, size_t init_cap);
+extern void mos_arr_put_fn(void *p_arr, size_t i, size_t el_size, size_t init_cap);
+extern size_t mos_arr_append_n_fn(void *p_arr, void *items, size_t n, size_t el_size, size_t init_cap);
+extern size_t mos_arr_insert_n_fn(void *p_arr, size_t i, void *items, size_t n, size_t el_size, size_t init_cap);
+extern size_t mos_arr_put_n_fn(void *p_arr, size_t i, void *items, size_t n, size_t el_size, size_t init_cap);
+extern size_t mos_arr_concat_fn(void *p_arr, void *arr2, size_t el_size, size_t init_cap);
 extern size_t mos_arr_del_fn(void *arr, size_t i, size_t el_size);
 extern size_t mos_arr_del_n_fn(void *arr, size_t i, size_t n, size_t el_size);
 extern size_t mos_arr_del_front_fn(void *arr, size_t n, size_t el_size);
 extern size_t mos_arr_del_back_fn(void *arr, size_t n);
-extern size_t mos_arr_set_len_fn(void *p_arr, size_t len, size_t el_size);
+extern size_t mos_arr_set_len_fn(void *p_arr, size_t len, size_t el_size, size_t init_cap);
 extern size_t mos_arr_set_cap_fn(void *p_arr, size_t cap, size_t el_size);
 
 #endif // MOSLIB_DS_ARRAY_H
diff --git a/include/moslib/mem/alloc.h b/include/moslib/mem/alloc.h
index eb557e5..564c70f 100644
--- a/include/moslib/mem/alloc.h
+++ b/include/moslib/mem/alloc.h
@@ -6,17 +6,19 @@
 #ifndef MOSLIB_MEM_ALLOC_H
 #define MOSLIB_MEM_ALLOC_H
 
-#ifndef MOSLIB_FORCE_PREFIXES
+// Attempt count for alloc functions
+#ifndef MOS_MAX_ALLOC_ATTEMPTS
+#define MOS_MAX_ALLOC_ATTEMPTS 3
+#endif // MOS_MAX_ALLOC_ATTEMPTS
+
+#ifndef MOS_FORCE_PREFIXES
 
-#define MAX_ALLOC_ATTEMPTS MOS_MAX_ALLOC_ATTEMPTS
 #define safe_malloc mos_safe_malloc
 #define safe_realloc mos_safe_realloc
 
-#endif // MOSLIB_FORCE_PREFIXES
-
-#define MOS_MAX_ALLOC_ATTEMPTS 3
+#endif // MOS_FORCE_PREFIXES
 
-// Tries to malloc MOSLIB_MAX_ALLOC_ATTEMPTS times
+// Tries to malloc MOS_MAX_ALLOC_ATTEMPTS times
 // If all attempts fail - exits with EXIT_FAILURE code
 //
 // Arguments:
@@ -25,9 +27,9 @@
 //
 // Returns:
 //   pointer to the allocated memory
-#define mos_safe_malloc(size) mos_safe_malloc_fn(size, __FILE__, __LINE__, __func__)
+#define mos_safe_malloc(size) mos_safe_malloc_fn(size, MOS_MAX_ALLOC_ATTEMPTS, __FILE__, __LINE__, __func__)
 
-// Tries to realloc MOSLIB_MAX_ALLOC_ATTEMPTS times
+// Tries to realloc MOS_MAX_ALLOC_ATTEMPTS times
 // If all attempts fail - exits with EXIT_FAILURE code
 //
 // Arguments:
@@ -39,10 +41,10 @@
 //
 // Returns:
 //   pointer to the reallocated memory
-#define mos_safe_realloc(ptr, size) mos_safe_realloc_fn(ptr, size, __FILE__, __LINE__, __func__)
+#define mos_safe_realloc(ptr, size) mos_safe_realloc_fn(ptr, size, MOS_MAX_ALLOC_ATTEMPTS, __FILE__, __LINE__, __func__)
 
 // Function prototypes for macros
-extern void *mos_safe_malloc_fn(size_t size, const char *file, int line, const char *func);
-extern void *mos_safe_realloc_fn(void *ptr, size_t size, const char *file, int line, const char *func);
+extern void *mos_safe_malloc_fn(size_t size, size_t att, const char *file, int line, const char *func);
+extern void *mos_safe_realloc_fn(void *ptr, size_t size, size_t att, const char *file, int line, const char *func);
 
 #endif // MOSLIB_MEM_ALLOC_H
diff --git a/include/moslib/tester.h b/include/moslib/tester.h
index ae41629..1d50473 100644
--- a/include/moslib/tester.h
+++ b/include/moslib/tester.h
@@ -83,7 +83,7 @@
 #ifndef MOSLIB_TESTER_H
 #define MOSLIB_TESTER_H
 
-#ifndef MOSLIB_FORCE_PREFIXES
+#ifndef MOS_FORCE_PREFIXES
 
 #define Test MosTest
 #define Tester MosTester
@@ -99,7 +99,7 @@
 #define run_tests mos_run_tests
 #define free_tester mos_free_tester
 
-#endif // MOSLIB_FORCE_PREFIXES
+#endif // MOS_FORCE_PREFIXES
 
 typedef void MosTest; // this is just for nice indication that a function is a test
 typedef struct MosTester MosTester;
diff --git a/src/ds/array.c b/src/ds/array.c
index e17e1fe..a817d80 100644
--- a/src/ds/array.c
+++ b/src/ds/array.c
@@ -1,4 +1,4 @@
-#define MOSLIB_FORCE_PREFIXES
+#define MOS_FORCE_PREFIXES
 #include "moslib/ds/array.h"
 
 #include <stdio.h>
@@ -15,16 +15,12 @@ void *hdr2arr(MosArrHeader *hdr) {
     return hdr + 1;
 }
 
-void *init_cap(size_t cap, size_t el_size) {
+void *init(size_t cap, size_t el_size) {
     MosArrHeader *hdr = mos_safe_malloc(sizeof(MosArrHeader) + cap * el_size);
     *hdr = (MosArrHeader){.len = 0, .cap = cap};
     return hdr2arr(hdr);
 }
 
-void *init(size_t el_size) {
-    return init_cap(MOS_ARR_INIT_CAP, el_size);
-}
-
 void *expand(void *arr, size_t min_cap, size_t el_size) {
     MosArrHeader *hdr = arr2hdr(arr);
     if (hdr->cap >= min_cap)
@@ -43,25 +39,25 @@ void *expand(void *arr, size_t min_cap, size_t el_size) {
 // clang-format off
 // init array if it's not, define arr, hdr vars and expand to fit min_cap
 #define ini(min_cap)                                                    \
-    !*(void**)p_arr ? *(void **)p_arr = init(el_size) : 0;              \
+    !*(void**)p_arr ? *(void **)p_arr = init(init_cap, el_size) : 0;    \
     MosArrHeader *hdr = arr2hdr(*(void**)p_arr);                        \
     *(void **)p_arr = expand(*(void**)p_arr, min_cap, el_size);         \
     void *arr = *(void **)p_arr;                                        \
     hdr = arr2hdr(arr)
 // clang-format on
 
-void mos_arr_append_fn(void *p_arr, size_t el_size) {
+void mos_arr_append_fn(void *p_arr, size_t el_size, size_t init_cap) {
     ini(hdr->len + 1);
     hdr->len++;
     (void)arr;
 }
 
-void mos_arr_insert_fn(void *p_arr, size_t i, size_t el_size) {
+void mos_arr_insert_fn(void *p_arr, size_t i, size_t el_size, size_t init_cap) {
     ini(hdr->len + 1);
     memmove((char *)arr + (i + 1) * el_size, (char *)arr + i * el_size, (hdr->len++ - i) * el_size);
 }
 
-void mos_arr_put_fn(void *p_arr, size_t i, size_t el_size) {
+void mos_arr_put_fn(void *p_arr, size_t i, size_t el_size, size_t init_cap) {
     ini(i + 1);
     if (i > hdr->len) {
         memset((char *)arr + hdr->len * el_size, 0, (i - hdr->len) * el_size);
@@ -69,7 +65,7 @@ void mos_arr_put_fn(void *p_arr, size_t i, size_t el_size) {
     }
 }
 
-size_t mos_arr_append_n_fn(void *p_arr, void *items, size_t n, size_t el_size) {
+size_t mos_arr_append_n_fn(void *p_arr, void *items, size_t n, size_t el_size, size_t init_cap) {
     ini(hdr->len + n);
     size_t i = hdr->len;
 
@@ -78,10 +74,10 @@ size_t mos_arr_append_n_fn(void *p_arr, void *items, size_t n, size_t el_size) {
     return i;
 }
 
-size_t mos_arr_insert_n_fn(void *p_arr, size_t i, void *items, size_t n, size_t el_size) {
+size_t mos_arr_insert_n_fn(void *p_arr, size_t i, void *items, size_t n, size_t el_size, size_t init_cap) {
     ini(hdr->len + n);
     if (i >= hdr->len)
-        return mos_arr_append_n_fn(p_arr, items, n, el_size);
+        return mos_arr_append_n_fn(p_arr, items, n, el_size, init_cap);
 
     memmove((char *)arr + (i + n) * el_size, (char *)arr + i * el_size, (hdr->len - i) * el_size);
     memmove((char *)arr + i * el_size, items, n * el_size);
@@ -89,7 +85,7 @@ size_t mos_arr_insert_n_fn(void *p_arr, size_t i, void *items, size_t n, size_t
     return i;
 }
 
-size_t mos_arr_put_n_fn(void *p_arr, size_t i, void *items, size_t n, size_t el_size) {
+size_t mos_arr_put_n_fn(void *p_arr, size_t i, void *items, size_t n, size_t el_size, size_t init_cap) {
     ini(i + n + 1);
     if (i > hdr->len) {
         memset((char *)arr + hdr->len * el_size, 0, (i - hdr->len) * el_size);
@@ -101,12 +97,12 @@ size_t mos_arr_put_n_fn(void *p_arr, size_t i, void *items, size_t n, size_t el_
     return i;
 }
 
-size_t mos_arr_concat_fn(void *p_arr, void *arr2, size_t el_size) {
+size_t mos_arr_concat_fn(void *p_arr, void *arr2, size_t el_size, size_t init_cap) {
     size_t arr2_len = mos_arr_len(arr2);
     if (arr2_len == 0)
         return -1;
 
-    return mos_arr_append_n_fn(p_arr, arr2, arr2_len, el_size);
+    return mos_arr_append_n_fn(p_arr, arr2, arr2_len, el_size, init_cap);
 }
 
 size_t mos_arr_del_fn(void *arr, size_t i, size_t el_size) {
@@ -147,7 +143,7 @@ size_t mos_arr_len(void *arr) {
     return arr2hdr(arr)->len;
 }
 
-size_t mos_arr_set_len_fn(void *p_arr, size_t len, size_t el_size) {
+size_t mos_arr_set_len_fn(void *p_arr, size_t len, size_t el_size, size_t init_cap) {
     ini(len);
 
     size_t del = hdr->len > len ? hdr->len - len : 0;
@@ -167,7 +163,7 @@ size_t mos_arr_cap(void *arr) {
 size_t mos_arr_set_cap_fn(void *p_arr, size_t cap, size_t el_size) {
     void *arr = *(void **)p_arr;
     if (!arr) {
-        *(void **)p_arr = init_cap(cap, el_size);
+        *(void **)p_arr = init(cap, el_size);
         return cap;
     }
 
diff --git a/src/mem/alloc.c b/src/mem/alloc.c
index 7a85d2d..60da131 100644
--- a/src/mem/alloc.c
+++ b/src/mem/alloc.c
@@ -1,4 +1,4 @@
-#define MOSLIB_FORCE_PREFIXES
+#define MOS_FORCE_PREFIXES
 #include "moslib/mem/alloc.h"
 
 #include <stdio.h>
@@ -7,39 +7,39 @@
 
 #define ERR_MESS(fl, ln, fn, msg) "%s:%d - error in function %s:\n%s\n", fl, ln, fn, msg
 
-void *mos_safe_malloc_fn(size_t size, const char *file, int line, const char *func) {
-    for (size_t i = 0; i < MOS_MAX_ALLOC_ATTEMPTS; i++) {
+void *mos_safe_malloc_fn(size_t size, size_t att, const char *file, int line, const char *func) {
+    for (size_t i = 0; i < att; i++) {
         void *p = malloc(size);
         if (p)
             return p;
-        if (i < MOS_MAX_ALLOC_ATTEMPTS - 1) {
+        if (i < att - 1) {
             fprintf(stderr, ERR_MESS(file, line, func, "malloc failed - retrying in 1s..."));
             sleep(1);
         }
     }
 
     char errmes[64];
-    sprintf(errmes, "FATAL: malloc failed %d times - exiting...", MOS_MAX_ALLOC_ATTEMPTS);
+    sprintf(errmes, "FATAL: malloc failed %zu times - exiting...", att);
     fprintf(stderr, ERR_MESS(file, line, func, errmes));
     exit(EXIT_FAILURE);
 }
 
-void *mos_safe_realloc_fn(void *ptr, size_t size, const char *file, int line, const char *func) {
+void *mos_safe_realloc_fn(void *ptr, size_t size, size_t att, const char *file, int line, const char *func) {
     if (!ptr)
-        return mos_safe_malloc_fn(size, file, line, func);
+        return mos_safe_malloc_fn(size, att, file, line, func);
 
-    for (size_t i = 0; i < MOS_MAX_ALLOC_ATTEMPTS; i++) {
+    for (size_t i = 0; i < att; i++) {
         void *p = realloc(ptr, size);
         if (p)
             return p;
-        if (i < MOS_MAX_ALLOC_ATTEMPTS - 1) {
+        if (i < att - 1) {
             fprintf(stderr, ERR_MESS(file, line, func, "realloc failed - retrying in 1s..."));
             sleep(1);
         }
     }
 
     char errmes[64];
-    sprintf(errmes, "FATAL: realloc failed %d times - exiting...", MOS_MAX_ALLOC_ATTEMPTS);
+    sprintf(errmes, "FATAL: realloc failed %zu times - exiting...", att);
     fprintf(stderr, ERR_MESS(file, line, func, errmes));
     exit(EXIT_FAILURE);
 }
diff --git a/src/tester.c b/src/tester.c
index 280eed1..eca4c1a 100644
--- a/src/tester.c
+++ b/src/tester.c
@@ -1,4 +1,4 @@
-#define MOSLIB_FORCE_PREFIXES
+#define MOS_FORCE_PREFIXES
 #include "moslib/tester.h"
 
 #include <setjmp.h>
diff --git a/tests/ds/array_tests.c b/tests/ds/array_tests.c
index 1a9234d..619772a 100644
--- a/tests/ds/array_tests.c
+++ b/tests/ds/array_tests.c
@@ -1,4 +1,5 @@
 #include "array_tests.h"
+#define MOS_ARR_INIT_CAP 8
 #include "moslib/ds/array.h"
 
 #include <string.h>
@@ -8,17 +9,17 @@ Test cap_test() {
     test_assert(arr_cap(arr) == 0, "uninitialized array has capacity different than 0");
 
     arr_append(arr, 0.0);
-    test_assert(arr_cap(arr) == ARR_INIT_CAP, "initial arr capacity is incorrect");
+    test_assert(arr_cap(arr) == MOS_ARR_INIT_CAP, "initial arr capacity is incorrect");
 
-    float items[ARR_INIT_CAP] = {0};
-    arr_append_n(arr, items, ARR_INIT_CAP);
-    test_assert(arr_cap(arr) == 2 * ARR_INIT_CAP, "capacity didn't increase 2 times");
+    float items[MOS_ARR_INIT_CAP] = {0};
+    arr_append_n(arr, items, MOS_ARR_INIT_CAP);
+    test_assert(arr_cap(arr) == 2 * MOS_ARR_INIT_CAP, "capacity didn't increase 2 times");
 
-    size_t new_cap = arr_set_cap(arr, 3 * ARR_INIT_CAP);
-    test_assert(new_cap == arr_cap(arr) && new_cap == 3 * ARR_INIT_CAP, "set cap didn't set correct capacity (cap >= len)");
+    size_t new_cap = arr_set_cap(arr, 3 * MOS_ARR_INIT_CAP);
+    test_assert(new_cap == arr_cap(arr) && new_cap == 3 * MOS_ARR_INIT_CAP, "set cap didn't set correct capacity (cap >= len)");
 
     new_cap = arr_set_cap(arr, 0);
-    test_assert(new_cap == arr_cap(arr) && new_cap == ARR_INIT_CAP + 1, "set cap didn't set correct capacity (cap < len)");
+    test_assert(new_cap == arr_cap(arr) && new_cap == MOS_ARR_INIT_CAP + 1, "set cap didn't set correct capacity (cap < len)");
 }
 
 Test len_test() {
diff --git a/tests/mem/alloc_tests.c b/tests/mem/alloc_tests.c
index 41feb3e..5b71887 100644
--- a/tests/mem/alloc_tests.c
+++ b/tests/mem/alloc_tests.c
@@ -1,4 +1,5 @@
 #include "alloc_tests.h"
+#define MOS_MAX_ALLOC_ATTEMPTS 1
 #include "moslib/mem/alloc.h"
 
 #include <limits.h>