foundational_lib 1.0 → 1.0.1

data/foundationallib.h

@@ -114,7 +114,7 @@ FOUNDATIONAL_LIB_STATIC_ASSERT_MSG((sizeof(size_t) <= 8 && FOUNDATIONAL_LIB_SIZE
 
 #endif
 #ifndef FOUNDATIONAL_LIB_UNSAFE_FUNCTIONS_ENABLED
-// Default true
+/* Default true */
 #define FOUNDATIONAL_LIB_UNSAFE_FUNCTIONS_ENABLED 1
 #endif
 
@@ -330,7 +330,7 @@ FOUNDATIONAL_LIB_STATIC_ASSERT_MSG((sizeof(size_t) <= 8 && FOUNDATIONAL_LIB_SIZE
 #endif
 
 #ifndef FOUNDATIONAL_LIB_FPUTC
-#define FOUNDATIONAL_LIB_FPUTC putc
+#define FOUNDATIONAL_LIB_FPUTC fputc
 #endif
 
 #ifndef FOUNDATIONAL_LIB_STRPBRK
@@ -417,10 +417,10 @@ FOUNDATIONAL_LIB_STATIC_ASSERT_MSG((sizeof(size_t) <= 8 && FOUNDATIONAL_LIB_SIZE
 #endif
 
 #if defined(__GNUC__) || defined(__clang__)
-#define FOUNDATIONAL_LIB_likely(x) __builtin_expect(!!(x), 1)
+#define FOUNDATIONAL_LIB_LIKELY(x) __builtin_expect(!!(x), 1)
 #define FOUNDATIONAL_LIB_UNLIKELY(x) __builtin_expect(!!(x), 0)
 #else
-#define FOUNDATIONAL_LIB_likely(x) (x)
+#define FOUNDATIONAL_LIB_LIKELY(x) (x)
 #define FOUNDATIONAL_LIB_UNLIKELY(x) (x)
 #endif
 
@@ -437,9 +437,13 @@ FOUNDATIONAL_LIB_STATIC_ASSERT_MSG((sizeof(size_t) <= 8 && FOUNDATIONAL_LIB_SIZE
 #endif /* assert checking. */
 
 #ifdef __GNUC__
-/** @brief Safely multiply 2 numbers to avoid unsigned integer overflows and security and stability issues. We never, NEVER want any of those things. Ever. */
+/**
+ * @brief
+ * Safely multiply 2 numbers to avoid unsigned integer overflows and security
+ * and stability issues. We never, NEVER want any of those things. Ever.
+ */
 FOUNDATIONAL_LIB_NOTHROW
-FOUNDATIONAL_LIB_CONST
+FOUNDATIONAL_LIB_PURE
 static inline size_t FOUNDATIONAL_LIB_safe_mul(size_t a, size_t b)
 {
     size_t result;
@@ -525,9 +529,13 @@ static inline int FOUNDATIONAL_LIB_safe_add_2_ptr(size_t a, size_t b, size_t *ou
 }
 
 #else  /* GNUC */
-/** @brief Safely multiply 2 numbers to avoid unsigned integer overflows and security and stability issues. We never, NEVER want any of those things. Ever. */
+/**
+ * @brief
+ * Safely multiply 2 numbers to avoid unsigned integer overflows and security
+ * and stability issues. We never, NEVER want any of those things. Ever.
+ */
 FOUNDATIONAL_LIB_NOTHROW
-FOUNDATIONAL_LIB_CONST
+FOUNDATIONAL_LIB_PURE
 static inline size_t FOUNDATIONAL_LIB_safe_mul(size_t a, size_t b)
 {
     size_t result;
@@ -625,7 +633,6 @@ static inline int FOUNDATIONAL_LIB_safe_add_3_ptr(size_t a, size_t b, size_t c,
 
 // Adjust as needed. On embedded platforms or low memory systems, you might want to change the algorithm to be somewhat lower than 1.5x
 // new len calculations need to be checked, before and after this, for overflow.
-
 #ifndef FOUNDATIONAL_LIB_LOW_MEMORY_USAGE
 #define FOUNDATIONAL_LIB_LOW_MEMORY_USAGE 12
 #endif
@@ -2207,7 +2214,7 @@ FOUNDATIONAL_LIB_FUNC void print_short_ptr_array_to_stream(const short **array,
 {
     FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
     FOUNDATIONAL_LIB_FPUTC('[', stream);
-    for (size_t i = 0; i < size; i++)
+    for (size_t i = 0; i < size; ++i)
     {
         FOUNDATIONAL_LIB_FPRINTF(stream, "%d", *array[i]);
         if (i < size - 1)
@@ -2235,7 +2242,7 @@ FOUNDATIONAL_LIB_FUNC void print_ulong_array_to_stream(const unsigned long *arra
 {
     FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
     FOUNDATIONAL_LIB_FPUTC('[', stream);
-    for (size_t i = 0; i < size; i++)
+    for (size_t i = 0; i < size; ++i)
     {
         FOUNDATIONAL_LIB_FPRINTF(stream, "%lu", array[i]);
         if (i < size - 1)
@@ -2264,7 +2271,7 @@ FOUNDATIONAL_LIB_FUNC void print_ulong_ptr_array_to_stream(const unsigned long *
 {
     FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
     FOUNDATIONAL_LIB_FPUTC('[', stream);
-    for (size_t i = 0; i < size; i++)
+    for (size_t i = 0; i < size; ++i)
     {
         FOUNDATIONAL_LIB_FPRINTF(stream, "%lu", *array[i]);
         if (i < size - 1)
@@ -2291,7 +2298,7 @@ FOUNDATIONAL_LIB_FUNC void print_long_array_to_stream(const long *array, size_t
 {
     FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
     FOUNDATIONAL_LIB_FPUTC('[', stream);
-    for (size_t i = 0; i < size; i++)
+    for (size_t i = 0; i < size; ++i)
     {
         FOUNDATIONAL_LIB_FPRINTF(stream, "%ld", array[i]);
         if (i < size - 1)
@@ -2320,7 +2327,7 @@ FOUNDATIONAL_LIB_FUNC void print_long_ptr_array_to_stream(const long **array, si
 {
     FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
     FOUNDATIONAL_LIB_FPUTC('[', stream);
-    for (size_t i = 0; i < size; i++)
+    for (size_t i = 0; i < size; ++i)
     {
         FOUNDATIONAL_LIB_FPRINTF(stream, "%ld", *array[i]);
         if (i < size - 1)
@@ -2349,7 +2356,7 @@ FOUNDATIONAL_LIB_FUNC void print_ulong_long_array_to_stream(const unsigned long
 {
     FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
     FOUNDATIONAL_LIB_FPUTC('[', stream);
-    for (size_t i = 0; i < size; i++)
+    for (size_t i = 0; i < size; ++i)
     {
         const unsigned long long value = array[i];
         char buffer[FOUNDATIONAL_LIB_SIZE_STRING_OF_NUMBER_SIZE_PLUS_ZERO_TERMINATOR];
@@ -2382,7 +2389,7 @@ FOUNDATIONAL_LIB_FUNC void print_ulong_long_ptr_array_to_stream(const unsigned l
 {
     FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
     FOUNDATIONAL_LIB_FPUTC('[', stream);
-    for (size_t i = 0; i < size; i++)
+    for (size_t i = 0; i < size; ++i)
     {
         const unsigned long long value = *(array[i]);
         char buffer[FOUNDATIONAL_LIB_SIZE_STRING_OF_NUMBER_SIZE_PLUS_ZERO_TERMINATOR];
@@ -2414,7 +2421,7 @@ FOUNDATIONAL_LIB_FUNC void print_long_long_array_to_stream(const long long *arra
 {
     FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
     FOUNDATIONAL_LIB_FPUTC('[', stream);
-    for (size_t i = 0; i < size; i++)
+    for (size_t i = 0; i < size; ++i)
     {
         const unsigned long long value = array[i];
         char buffer[FOUNDATIONAL_LIB_SIZE_STRING_OF_NUMBER_SIZE_PLUS_ZERO_TERMINATOR];
@@ -2449,7 +2456,7 @@ FOUNDATIONAL_LIB_FUNC void print_long_long_ptr_array_to_stream(const long long *
 {
     FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
     FOUNDATIONAL_LIB_FPUTC('[', stream);
-    for (size_t i = 0; i < size; i++)
+    for (size_t i = 0; i < size; ++i)
     {
         const long long value = *(array[i]);
 
@@ -2482,7 +2489,7 @@ FOUNDATIONAL_LIB_FUNC void print_float_array_to_stream(const float *array, size_
 {
     FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
     FOUNDATIONAL_LIB_FPUTC('[', stream);
-    for (size_t i = 0; i < size; i++)
+    for (size_t i = 0; i < size; ++i)
     {
         FOUNDATIONAL_LIB_FPRINTF(stream, "%f", array[i]);
         if (i < size - 1)
@@ -2511,7 +2518,7 @@ FOUNDATIONAL_LIB_FUNC void print_float_ptr_array_to_stream(const float **array,
 {
     FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
     FOUNDATIONAL_LIB_FPUTC('[', stream);
-    for (size_t i = 0; i < size; i++)
+    for (size_t i = 0; i < size; ++i)
     {
         FOUNDATIONAL_LIB_FPRINTF(stream, "%f", *array[i]);
         if (i < size - 1)
@@ -2539,7 +2546,7 @@ FOUNDATIONAL_LIB_FUNC void print_double_array_to_stream(const double *array, siz
 {
     FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
     FOUNDATIONAL_LIB_FPUTC('[', stream);
-    for (size_t i = 0; i < size; i++)
+    for (size_t i = 0; i < size; ++i)
     {
         FOUNDATIONAL_LIB_FPRINTF(stream, "%lf", array[i]);
         if (i < size - 1)
@@ -2568,7 +2575,7 @@ FOUNDATIONAL_LIB_FUNC void print_double_ptr_array_to_stream(const double **array
 {
     FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
     FOUNDATIONAL_LIB_FPUTC('[', stream);
-    for (size_t i = 0; i < size; i++)
+    for (size_t i = 0; i < size; ++i)
     {
         FOUNDATIONAL_LIB_FPRINTF(stream, "%lf", *array[i]);
         if (i < size - 1)
@@ -2596,7 +2603,7 @@ FOUNDATIONAL_LIB_FUNC void print_size_t_array_to_stream(const size_t *array, siz
 {
     FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
     FOUNDATIONAL_LIB_FPUTC('[', stream);
-    for (size_t i = 0; i < size; i++)
+    for (size_t i = 0; i < size; ++i)
     {
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wpragmas"
@@ -2631,7 +2638,7 @@ FOUNDATIONAL_LIB_FUNC void print_size_t_ptr_array_to_stream(const size_t **array
 {
     FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
     FOUNDATIONAL_LIB_FPUTC('[', stream);
-    for (size_t i = 0; i < size; i++)
+    for (size_t i = 0; i < size; ++i)
     {
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wpragmas"
@@ -2686,7 +2693,7 @@ FOUNDATIONAL_LIB_FUNC void *arraydup(const void *array, size_t num_mem, size_t s
         return NULL;
     }
 
-    for (size_t i = 0; i < tot_size; i++)
+    for (size_t i = 0; i < tot_size; ++i)
     {
         duplicate[i] = ((char *)array)[i];
     }
@@ -3659,7 +3666,7 @@ FOUNDATIONAL_LIB_FUNC char **split(const char *str, size_t *output_size, const c
     const char *ptr;
 
     /* Split the string into tokens */
-    for (size_t i = 0; i < *output_size; i++)
+    for (size_t i = 0; i < *output_size; ++i)
     {
         ptr = FOUNDATIONAL_LIB_STRSTR(token_start, delim);
 
@@ -3763,7 +3770,7 @@ FOUNDATIONAL_LIB_FUNC char *join(const char **array, size_t count, const char *d
     size_t total_length;
 
     total_length = 1; // NUL byte
-    for (size_t i = 0; i < count; i++)
+    for (size_t i = 0; i < count; ++i)
     {
         const size_t new_len = FOUNDATIONAL_LIB_STRLEN(array[i]);
         lens[i] = new_len;
@@ -4394,7 +4401,7 @@ FOUNDATIONAL_LIB_FUNC size_t array_total_string_length(char **array, size_t coun
     FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
     size_t length = 0;
 
-    for (size_t i = 0; i < count; i++)
+    for (size_t i = 0; i < count; ++i)
     {
         // NOTE: Do not check for overflows here.
         length += FOUNDATIONAL_LIB_STRLEN(array[i]);
@@ -4501,7 +4508,7 @@ FOUNDATIONAL_LIB_FUNC char *reverse_string(const char *str)
     size_t length = FOUNDATIONAL_LIB_STRLEN(new_str);
     size_t i, j;
 
-    for (i = 0, j = length - 1; i < j; i++, j--)
+    for (i = 0, j = length - 1; i < j; ++i, j--)
     {
         char temp = new_str[i];
         new_str[i] = new_str[j];
@@ -4854,7 +4861,7 @@ FOUNDATIONAL_LIB_FUNC int is_string_numeric(const char *str)
 
     const size_t len = FOUNDATIONAL_LIB_STRLEN(str);
 
-    for (size_t i = 0; i < len; i++)
+    for (size_t i = 0; i < len; ++i)
     {
         if (!FOUNDATIONAL_LIB_ISDIGIT(str[i]))
         {
@@ -4889,7 +4896,7 @@ FOUNDATIONAL_LIB_FUNC int is_string_alphanumeric(const char *str)
 
     size_t len = FOUNDATIONAL_LIB_STRLEN(str);
 
-    for (size_t i = 0; i < len; i++)
+    for (size_t i = 0; i < len; ++i)
     {
         if (!FOUNDATIONAL_LIB_ISALNUM(str[i]))
         {
@@ -5113,7 +5120,7 @@ FOUNDATIONAL_LIB_FUNC ssize_t find_first_of(const char *str, const char *char_se
 
     const char *result = strpbrk(str, char_set);
 
-    return FOUNDATIONAL_LIB_likely(result != NULL) ? result - str : -1;
+    return FOUNDATIONAL_LIB_LIKELY(result != NULL) ? result - str : -1;
 }
 
 /**
@@ -5245,7 +5252,7 @@ FOUNDATIONAL_LIB_FUNC size_t common_prefix_length(const char *str1, const char *
 
     const size_t min_len = (len1 < len2) ? len1 : len2;
 
-    for (size_t i = 0; i < min_len; i++)
+    for (size_t i = 0; i < min_len; ++i)
     {
         if (str1[i] != str2[i])
         {
@@ -5279,7 +5286,7 @@ FOUNDATIONAL_LIB_FUNC size_t common_suffix_length(const char *str1, const char *
 
     const size_t min_len = (len1 < len2) ? len1 : len2;
 
-    for (size_t i = 1; i <= min_len; i++)
+    for (size_t i = 1; i <= min_len; ++i)
     {
         if (str1[len1 - i] != str2[len2 - i])
         {
@@ -5325,7 +5332,7 @@ FOUNDATIONAL_LIB_FUNC char *string_to_title_case(const char *str)
 
     int make_upper = 1; // Start with the first character as uppercase
 
-    for (size_t i = 0; i < len; i++)
+    for (size_t i = 0; i < len; ++i)
     {
         if (FOUNDATIONAL_LIB_ISSPACE(str[i]))
         {
@@ -5368,7 +5375,7 @@ FOUNDATIONAL_LIB_FUNC int find_max_int_in_array(const int *array, size_t size)
 
     int max = array[0];
 
-    for (size_t i = 1; i < size; i++)
+    for (size_t i = 1; i < size; ++i)
     {
         if (array[i] > max)
         {
@@ -5403,7 +5410,7 @@ FOUNDATIONAL_LIB_FUNC int find_min_int_in_array(const int *array, size_t size)
 
     int min = array[0];
 
-    for (size_t i = 1; i < size; i++)
+    for (size_t i = 1; i < size; ++i)
     {
         if (array[i] < min)
         {
@@ -8372,7 +8379,7 @@ FOUNDATIONAL_LIB_FUNC char *concatenate_strings(const char *str1, const char *st
  *
  *        If should_free_after_use is non-zero, a new dynamically allocated array with the replacements made.
  *        If should_free_after_use is zero, output aliases source, and they refer to the same memory.
- * @param should_free_after_use A pointer to a int indicating whether
+ * @param should_free_after_use A pointer to a int indicating whether one should free the memory after using the function.
  * @param num_matches A pointer to a variable to store the number of replacements made.
  * @param matches_max A pointer to the maximum number of replacements to make. If zero, there is no maximum.
  *
@@ -8902,7 +8909,7 @@ FOUNDATIONAL_LIB_FUNC void map_ints(int *array, size_t size, int (*transform)(in
     FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
     FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(transform);
 
-    for (size_t i = 0; i < size; i++)
+    for (size_t i = 0; i < size; ++i)
     {
         array[i] = transform(array[i]);
     }
@@ -8948,7 +8955,7 @@ FOUNDATIONAL_LIB_FUNC int reduce_ints(int *array, size_t size, int (*operation)(
     FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(operation);
 
     int result = array[0];
-    for (size_t i = 1; i < size; i++)
+    for (size_t i = 1; i < size; ++i)
     {
         result = operation(result, array[i]);
     }
@@ -9004,7 +9011,7 @@ FOUNDATIONAL_LIB_FUNC int filter_ints(int *source, size_t source_size, int *dest
     FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(condition);
 
     size_t count = 0;
-    for (size_t i = 0; i < source_size; i++)
+    for (size_t i = 0; i < source_size; ++i)
     {
         if (condition(source[i]))
         {
@@ -9051,7 +9058,7 @@ FOUNDATIONAL_LIB_FUNC void map(void *array, size_t size, size_t elem_size, void
     FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
     FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(transform);
 
-    for (size_t i = 0; i < size; i++)
+    for (size_t i = 0; i < size; ++i)
     {
         transform(((char *)array) + i * elem_size);
     }
@@ -9103,12 +9110,12 @@ FOUNDATIONAL_LIB_FUNC void reduce(void *array, size_t size, size_t elem_size, vo
     char *char_result = (char *)result;
 
     /* Initialize the result with the first element */
-    for (size_t i = 0; i < elem_size; i++)
+    for (size_t i = 0; i < elem_size; ++i)
     {
         char_result[i] = char_array[i];
     }
 
-    for (size_t i = 1; i < size; i++)
+    for (size_t i = 1; i < size; ++i)
     {
         operation(char_result, char_array + i * elem_size);
     }
@@ -9169,18 +9176,19 @@ FOUNDATIONAL_LIB_FUNC size_t filter(void *source, size_t source_size, size_t ele
     char *char_destination = (char *)destination;
 
     size_t count = 0;
-    for (size_t i = 0; i < source_size; i++)
+    for (size_t i = 0; i < source_size; ++i)
     {
         if (condition(char_source + i * elem_size))
         {
             if (count < dest_size)
             {
-                for (size_t j = 0; j < elem_size; j++)
+                for (size_t j = 0; j < elem_size; ++j)
                 {
                     char_destination[count * elem_size + j] = char_source[i * elem_size + j];
                 }
             }
-            count++;
+
+            ++count;
         }
     }
     return count;
@@ -10325,18 +10333,18 @@ FOUNDATIONAL_LIB_FUNC int string_array_uniq(const char **array, size_t size, cha
     }
 
     // Initialize all elements to NULL
-    for (size_t i = 0; i < size; i++)
+    for (size_t i = 0; i < size; ++i)
     {
         (*output)[i] = NULL;
     }
 
     // Iterate through the input array to find unique strings
-    for (size_t i = 0; i < size; i++)
+    for (size_t i = 0; i < size; ++i)
     {
         int is_unique = 1;
 
         // Check if the current string is not equal to any previous strings
-        for (size_t j = 0; j < count; j++)
+        for (size_t j = 0; j < count; ++j)
         {
             if ((*output)[j] != NULL && FOUNDATIONAL_LIB_STRCMP(array[i], (*output)[j]) == 0)
             {
@@ -12902,7 +12910,7 @@ FOUNDATIONAL_LIB_FUNC int is_valid_utf8(const char *str, size_t len)
         if ((str[i] & 0x80) == 0)
         {
             // ASCII character (0xxxxxxx)
-            i++;
+            ++i;
         }
         else if ((str[i] & 0xE0) == 0xC0)
         {