style and consistency improved

Reviewed-on: #1

libkeke_array.c

@@ -1,333 +1,380 @@
-#ifndef LIBKEKE_ARRAY
-#define LIBKEKE_ARRAY
 
-#include <stddef.h>
+// Required for qsort_r on Linux
-#include <stdlib.h>
+#define _GNU_SOURCE
-#include <stdint.h>
+
-#include <string.h>
-#include <stdbool.h>
-#include <stdio.h>
-#include "libkeke_utils.h"
 #include "libkeke_array.h"
-
+#include "libkeke_utils.h"
-typedef struct {
+#include <stdbool.h>
-	size_t type_size;
+#include <stddef.h>
-	size_t len;
+#include <stdint.h>
-	size_t max_len;
+#include <stdio.h>
-	void *content;
+#include <stdlib.h>
-} KekeArray;
+#include <string.h>
 
 #define ARRAY_GET(array, i) ((array)->content + (array)->type_size * (i))
 
 KekeArray *keke_array_alloc(size_t initial_len, size_t type_size) {
-	KekeArray *array = malloc(sizeof(*array));
+  KekeArray *array = malloc(sizeof(*array));
-	array->len = initial_len;
+  array->len = initial_len;
-	size_t max_len = bit_ceil(initial_len);
+  size_t max_len = bit_ceil(initial_len);
 
-	array->type_size = type_size;
+  array->type_size = type_size;
-	array->max_len = max_len;
+  array->max_len = max_len;
-	array->content = calloc(max_len, type_size);
+  array->content = calloc(max_len, type_size);
-	return array;
+  return array;
 }
 
 void keke_array_free(KekeArray *array) {
-	free(array->content);
+  free(array->content);
-	free(array);
+  free(array);
 }
 
 void keke_array_set(KekeArray *array, size_t index, const void *value) {
-	if(index >= array->max_len) {
+  if (index >= array->max_len) {
-		array->content = realloc(array->content, (array->max_len << 1) * array->type_size);
+    array->content =
-		memset(array->content + array->max_len * array->type_size, 0, array->max_len * array->type_size);
+        realloc(array->content, (array->max_len << 1) * array->type_size);
-		array->max_len <<= 1;
+    memset(array->content + array->max_len * array->type_size, 0,
-	}
+           array->max_len * array->type_size);
-	if(index >= array->len) array->len = index + 1;
+    array->max_len <<= 1;
-	memcpy(array->content + index * array->type_size, value, array->type_size);
+  }
+  if (index >= array->len)
+    array->len = index + 1;
+  memcpy(array->content + index * array->type_size, value, array->type_size);
 }
 
 void *keke_array_get(KekeArray *array, size_t index) {
-	if(index >= array->len) return NULL; // is ur fault
+  if (index >= array->len)
-	return ARRAY_GET(array, index);
+    return NULL; // is ur fault
+  return ARRAY_GET(array, index);
 }
 
 int keke_array_copy(KekeArray *array, size_t index, void *value) {
-	if(index >= array->len) return -1; // is ur fault
+  if (index >= array->len)
-	memcpy(value, ARRAY_GET(array, index), array->type_size);
+    return -1; // is ur fault
-	return 0;
+  memcpy(value, ARRAY_GET(array, index), array->type_size);
+  return 0;
 }
 
 void keke_array_set_len(KekeArray *array, size_t new_len) {
-	if(new_len >= array->max_len) {
+  if (new_len >= array->max_len) {
-		size_t new_max_len = 1;
+    size_t new_max_len = 1;
-		size_t len = new_len;
+    size_t len = new_len;
-		while(len >>= 1) new_max_len <<= 1;
+    while (len >>= 1)
-		array->content = realloc(array->content, new_max_len * array->type_size);
+      new_max_len <<= 1;
-		memset(array->content + array->max_len * array->type_size, 0, (new_max_len - array->max_len) * array->type_size);
+    array->content = realloc(array->content, new_max_len * array->type_size);
-		array->max_len <<= 1;
+    memset(array->content + array->max_len * array->type_size, 0,
-	} else if(new_len < array->len) {
+           (new_max_len - array->max_len) * array->type_size);
-        memset(array->content + new_len * array->type_size, 0, (array->len - new_len) * array->type_size);
+    array->max_len <<= 1;
-    }
+  } else if (new_len < array->len) {
-	array->len = new_len;
+    memset(array->content + new_len * array->type_size, 0,
+           (array->len - new_len) * array->type_size);
+  }
+  array->len = new_len;
 }
 
 void keke_array_insert(KekeArray *array, size_t index, const void *value) {
-	if(array->len + 1 > array->max_len) {
+  if (array->len + 1 > array->max_len) {
-		array->content = realloc(array->content, (array->max_len << 1) * array->type_size);
+    array->content =
-		memset(array->content + array->max_len * array->type_size, 0, array->max_len * array->type_size);
+        realloc(array->content, (array->max_len << 1) * array->type_size);
-		array->max_len <<= 1;
+    memset(array->content + array->max_len * array->type_size, 0,
-	}
+           array->max_len * array->type_size);
-    keke_array_set_len(array, array->len + 1);
+    array->max_len <<= 1;
-    memmove(array->content + ((index + 1) * array->type_size), array->content + (index * array->type_size), (array->len - index - 1) * array->type_size);
+  }
-    memcpy(array->content + index * array->type_size, value, array->type_size);
+  keke_array_set_len(array, array->len + 1);
+  memmove(array->content + ((index + 1) * array->type_size),
+          array->content + (index * array->type_size),
+          (array->len - index - 1) * array->type_size);
+  memcpy(array->content + index * array->type_size, value, array->type_size);
 }
 
 void keke_array_remove(KekeArray *array, size_t index, void *value) {
-    memcpy(value, array->content + index * array->type_size, array->type_size);
+  memcpy(value, array->content + index * array->type_size, array->type_size);
-    keke_array_set_len(array, array->len - 1);
+  keke_array_set_len(array, array->len - 1);
-    memmove(array->content + (index * array->type_size), array->content + ((index + 1) * array->type_size), (array->len - index + 1) * array->type_size);
+  memmove(array->content + (index * array->type_size),
+          array->content + ((index + 1) * array->type_size),
+          (array->len - index + 1) * array->type_size);
 }
 
 void keke_array_push(KekeArray *array, const void *value) {
-	keke_array_set(array, array->len, value);
+  keke_array_set(array, array->len, value);
 }
 
 void keke_array_pop(KekeArray *array, void *value) {
-	keke_array_remove(array, array->len - 1, value);
+  keke_array_remove(array, array->len - 1, value);
 }
 
 void keke_array_delete(KekeArray *array, size_t index) {
-    keke_array_set_len(array, array->len - 1);
+  keke_array_set_len(array, array->len - 1);
-    memmove(array->content + (index * array->type_size), array->content + ((index + 1) * array->type_size), (array->len - index + 1) * array->type_size);
+  memmove(array->content + (index * array->type_size),
+          array->content + ((index + 1) * array->type_size),
+          (array->len - index + 1) * array->type_size);
 }
 
 void keke_array_swap_delete(KekeArray *array, size_t index) {
-	size_t new_len = array->len - 1;
+  size_t new_len = array->len - 1;
-	keke_swap(ARRAY_GET(array, index), ARRAY_GET(array, new_len), array->type_size);
+  keke_swap(ARRAY_GET(array, index), ARRAY_GET(array, new_len),
-    keke_array_set_len(array, new_len);
+            array->type_size);
+  keke_array_set_len(array, new_len);
 }
 
 KekeArray *keke_array_yoink(KekeArray *array, size_t start_index, size_t len) {
-	if(start_index + len >= array->len) return NULL;
+  if (start_index + len >= array->len)
-	KekeArray *ret = keke_array_alloc(len, array->type_size);
+    return NULL;
-	memcpy(ret->content, array->content + start_index * array->type_size, len * array->type_size);
+  KekeArray *ret = keke_array_alloc(len, array->type_size);
-	memmove(array->content + start_index * array->type_size, array->content + (start_index + len) * array->type_size, (array->len - len - start_index) * array->type_size);
+  memcpy(ret->content, array->content + start_index * array->type_size,
-	keke_array_set_len(array, array->len - len);
+         len * array->type_size);
-	return ret;
+  memmove(array->content + start_index * array->type_size,
+          array->content + (start_index + len) * array->type_size,
+          (array->len - len - start_index) * array->type_size);
+  keke_array_set_len(array, array->len - len);
+  return ret;
 }
 
-int keke_array_insert_data(KekeArray *array, size_t index, void *data, size_t len) {
+int keke_array_insert_data(KekeArray *array, size_t index, void *data,
-    if(index >= array->len) return -1;
+                           size_t len) {
-    size_t current_len = array->len;
+  if (index >= array->len)
-    keke_array_set_len(array, current_len + len);
+    return -1;
-    memmove(array->content + (index + len) * array->type_size, array->content + index * array->type_size, (current_len - index) * array->type_size);
+  size_t current_len = array->len;
-    memcpy(array->content + index * array->type_size, data, len * array->type_size);
+  keke_array_set_len(array, current_len + len);
-    return 0;
+  memmove(array->content + (index + len) * array->type_size,
+          array->content + index * array->type_size,
+          (current_len - index) * array->type_size);
+  memcpy(array->content + index * array->type_size, data,
+         len * array->type_size);
+  return 0;
 }
 
 int keke_array_plop(KekeArray *array, size_t index, KekeArray *array2) {
-    int ret = keke_array_insert_data(array, index, array2->content, array2->len);
+  int ret = keke_array_insert_data(array, index, array2->content, array2->len);
-    if(ret) return ret;
+  if (ret)
-    keke_array_free(array2);
+    return ret;
-    return 0;
+  keke_array_free(array2);
+  return 0;
 }
 
 typedef void (*Foreach_func)(void *, size_t, KekeArray *);
 
 void keke_array_foreach(KekeArray *array, Foreach_func callback) {
-    for(size_t i = 0; i < array->len; i++) callback(ARRAY_GET(array, i), i, array);
+  for (size_t i = 0; i < array->len; i++)
+    callback(ARRAY_GET(array, i), i, array);
 }
 
 KekeArray *keke_array_clone(KekeArray *array) {
-    KekeArray *ret = malloc(sizeof(*array));
+  KekeArray *ret = malloc(sizeof(*array));
-    memcpy(ret, array, sizeof(*array));
+  memcpy(ret, array, sizeof(*array));
-    ret->content = malloc(array->max_len * array->type_size);
+  ret->content = malloc(array->max_len * array->type_size);
-    memcpy(ret->content, array->content, array->max_len * array->type_size);
+  memcpy(ret->content, array->content, array->max_len * array->type_size);
-    return ret;
+  return ret;
 }
 
 void keke_array_fill(KekeArray *array, const void *value) {
-    for(size_t i = 0; i < array->len; i++) memcpy(ARRAY_GET(array, i), value, array->type_size);
+  for (size_t i = 0; i < array->len; i++)
+    memcpy(ARRAY_GET(array, i), value, array->type_size);
 }
 
 void keke_array_reverse(KekeArray *array) {
-    for(size_t i = 0; i < array->len / 2; i++) {
+  for (size_t i = 0; i < array->len / 2; i++) {
-    	keke_swap(ARRAY_GET(array, i), array->content + array->type_size * (array->len - i - 1), array->type_size);
+    keke_swap(ARRAY_GET(array, i),
-    }
+              array->content + array->type_size * (array->len - i - 1),
+              array->type_size);
+  }
 }
 
 typedef bool (*Test_func)(void *, size_t, KekeArray *);
 
 bool keke_array_some(KekeArray *array, Test_func test) {
-	bool ret = false;
+  bool ret = false;
-    for(size_t i = 0; i < array->len; i++) ret = ret || test(ARRAY_GET(array, i), i, array);	
+  for (size_t i = 0; i < array->len; i++)
-    return ret;
+    ret = ret || test(ARRAY_GET(array, i), i, array);
+  return ret;
 }
 
 bool keke_array_all(KekeArray *array, Test_func test) {
-	bool ret = true;
+  bool ret = true;
-    for(size_t i = 0; i < array->len; i++) ret = ret && test(ARRAY_GET(array, i), i, array);	
+  for (size_t i = 0; i < array->len; i++)
-    return ret;
+    ret = ret && test(ARRAY_GET(array, i), i, array);
+  return ret;
 }
 
 void *keke_array_find(KekeArray *array, Test_func test) {
-    for(size_t i = 0; i < array->len; i++) {
+  for (size_t i = 0; i < array->len; i++) {
-		void *current = ARRAY_GET(array, i);
+    void *current = ARRAY_GET(array, i);
-		if(test(current, i, array)) return current;
+    if (test(current, i, array))
-    }
+      return current;
-    return NULL;
+  }
+  return NULL;
 }
 
 void *keke_array_find_start(KekeArray *array, void *start, size_t size) {
-    for(size_t i = 0; i < array->len; i++) {
+  for (size_t i = 0; i < array->len; i++) {
-		void *current = ARRAY_GET(array, i);
+    void *current = ARRAY_GET(array, i);
-		if(memcmp(current, start, size) == 0) return current;
+    if (memcmp(current, start, size) == 0)
-    }
+      return current;
-    return NULL;
+  }
+  return NULL;
 }
 
-int compar(const void *a, const void *b, void *size_v) {
+/* Windows uses qsort_s rather than qsort_r and wants a BSD-style comparison
-	size_t size = *(size_t *) size_v;
+ * function. This will transparently switch the comparison function based on
-#if defined(__BYTE_ORDER__)&&(__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
+ * platform. */
-	return memcmp(a, b, size);
+#if _WIN32
+#define qsort_r qsort_s
+#define compar(a, b, size_v) _compar(size_v, a, b)
+int _compar(void *size_v, const void *a, const void *b) {
 #else
-	/*const signed char *aa = a;
+#define compar(a, b, size_v) _compar(a, b, size_v)
-	const signed char *bb = b;
+int _compar(const void *a, const void *b, void *size_v) {
-	for(size_t i = 0; i < size; ++i) {
+#endif
-		size_t s = size - i - 1;
+  size_t size = *(size_t *)size_v;
-		if(aa[s] != bb[s]) return aa[s] - bb[s];
+#if defined(__BYTE_ORDER__) && (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
-	}
+  return memcmp(a, b, size);
-	return 0;*/
+#else
-	size_t rem = size % sizeof(int);
+  /*const signed char *aa = a;
-	if(rem) {
+  const signed char *bb = b;
-		size -= rem;
+  for(size_t i = 0; i < size; ++i) {
-		const char *c = a;
+          size_t s = size - i - 1;
-		const char *d = b;
+          if(aa[s] != bb[s]) return aa[s] - bb[s];
-		for(size_t i = 1; i <= rem; ++i) {
+  }
-			char j = c[size + rem - i] - d[size + rem - i];
+  return 0;*/
-			if(j != 0) return j;
+  size_t rem = size % sizeof(int);
-		}
+  if (rem) {
-	}
+    size -= rem;
-	const int *ia = a;
+    const char *c = a;
-	const int *ib = b;
+    const char *d = b;
-	size /= sizeof(int);
+    for (size_t i = 1; i <= rem; ++i) {
-	for(size_t i = 1; i <= size; ++i) {
+      char j = c[size + rem - i] - d[size + rem - i];
-		int j = ia[size - i] - ib[size - i];
+      if (j != 0)
-		if(j != 0) return j;
+        return j;
-	}
+    }
-	return 0;
+  }
+  const int *ia = a;
+  const int *ib = b;
+  size /= sizeof(int);
+  for (size_t i = 1; i <= size; ++i) {
+    int j = ia[size - i] - ib[size - i];
+    if (j != 0)
+      return j;
+  }
+  return 0;
 #endif
 }
 
 void keke_array_qsort(KekeArray *array) {
-	qsort_r(array->content, array->len, array->type_size, compar, &array->type_size);
+  qsort_r(array->content, array->len, array->type_size, _compar,
+          &array->type_size);
 }
 
 void keke_array_qsort_header(KekeArray *array, size_t start_header_size) {
-	qsort_r(array->content, array->len, array->type_size, compar, &start_header_size);
+  qsort_r(array->content, array->len, array->type_size, _compar,
+          &start_header_size);
 }
 
 typedef int (*Rng_fun)(int);
 
 void keke_array_shuffle(KekeArray *array, Rng_fun rng) {
-	for(size_t i = 0; i < array->len; ++i) {
+  for (size_t i = 0; i < array->len; ++i) {
-		size_t j = rng(i + 1);
+    size_t j = rng(i + 1);
-		keke_swap(ARRAY_GET(array, i), ARRAY_GET(array, j), array->type_size);
+    keke_swap(ARRAY_GET(array, i), ARRAY_GET(array, j), array->type_size);
-	} 
+  }
 }
 
 // requires pre-sorted arrays
 KekeArray *keke_array_merge(KekeArray *a, KekeArray *b) {
-	if(a->len == 0) {
+  if (a->len == 0) {
-		KekeArray *r = keke_array_clone(b);
+    KekeArray *r = keke_array_clone(b);
-		keke_array_set_len(b, 0);
+    keke_array_set_len(b, 0);
-		return r;
+    return r;
-	}
+  }
-	if(b->len == 0) {
+  if (b->len == 0) {
-		KekeArray *r = keke_array_clone(a);
+    KekeArray *r = keke_array_clone(a);
-		keke_array_set_len(a, 0);
+    keke_array_set_len(a, 0);
-		return r;
+    return r;
-	}
+  }
-	keke_array_reverse(a);
+  keke_array_reverse(a);
-	keke_array_reverse(b);
+  keke_array_reverse(b);
-	if(a->type_size != b->type_size) return NULL;
+  if (a->type_size != b->type_size)
-	KekeArray *c = keke_array_alloc(a->len + b->len, a->type_size);
+    return NULL;
-	keke_array_set_len(c, 0);
+  KekeArray *c = keke_array_alloc(a->len + b->len, a->type_size);
-	void *s = malloc(a->type_size);
+  keke_array_set_len(c, 0);
-	while(!!(a->len) && !!(b->len)) {
+  void *s = malloc(a->type_size);
-		if(compar(ARRAY_GET(a, a->len - 1), ARRAY_GET(b, b->len - 1), &a->type_size) <= 0) {
+  while (!!(a->len) && !!(b->len)) {
-			keke_array_pop(a, s)	;
+    if (compar(ARRAY_GET(a, a->len - 1), ARRAY_GET(b, b->len - 1),
-			keke_array_push(c, s);
+               &a->type_size) <= 0) {
-		} else {
+      keke_array_pop(a, s);
-			keke_array_pop(b, s);
+      keke_array_push(c, s);
-			keke_array_push(c, s);
+    } else {
-		}
+      keke_array_pop(b, s);
-	}
+      keke_array_push(c, s);
-	while(a->len) {
+    }
-		keke_array_pop(a, s);
+  }
-		keke_array_push(c, s);
+  while (a->len) {
-	}
+    keke_array_pop(a, s);
-	while(b->len) {
+    keke_array_push(c, s);
-		keke_array_pop(b, s);
+  }
-		keke_array_push(c, s);
+  while (b->len) {
-	}
+    keke_array_pop(b, s);
-	free(s);
+    keke_array_push(c, s);
-	return c;
+  }
+  free(s);
+  return c;
 }
 
-KekeArray *keke_array_merge_by_header(KekeArray *a, KekeArray *b, size_t header_size) {
+KekeArray *keke_array_merge_by_header(KekeArray *a, KekeArray *b,
-	if(a->len == 0) {
+                                      size_t header_size) {
-		KekeArray *r = keke_array_clone(b);
+  if (a->len == 0) {
-		keke_array_set_len(b, 0);
+    KekeArray *r = keke_array_clone(b);
-		return r;
+    keke_array_set_len(b, 0);
-	}
+    return r;
-	if(b->len == 0) {
+  }
-		KekeArray *r = keke_array_clone(a);
+  if (b->len == 0) {
-		keke_array_set_len(a, 0);
+    KekeArray *r = keke_array_clone(a);
-		return r;
+    keke_array_set_len(a, 0);
-	}
+    return r;
-	keke_array_reverse(a);
+  }
-	keke_array_reverse(b);
+  keke_array_reverse(a);
-	if(a->type_size != b->type_size) return NULL;
+  keke_array_reverse(b);
-	KekeArray *c = keke_array_alloc(a->len + b->len, a->type_size);
+  if (a->type_size != b->type_size)
-	keke_array_set_len(c, 0);
+    return NULL;
-	void *s = malloc(a->type_size);
+  KekeArray *c = keke_array_alloc(a->len + b->len, a->type_size);
-	while(!!(a->len) && !!(b->len)) {
+  keke_array_set_len(c, 0);
-		if(compar(ARRAY_GET(a, a->len - 1), ARRAY_GET(b, b->len - 1), &header_size) <= 0) {
+  void *s = malloc(a->type_size);
-			keke_array_pop(a, s)	;
+  while (!!(a->len) && !!(b->len)) {
-			keke_array_push(c, s);
+    if (compar(ARRAY_GET(a, a->len - 1), ARRAY_GET(b, b->len - 1),
-		} else {
+               &header_size) <= 0) {
-			keke_array_pop(b, s);
+      keke_array_pop(a, s);
-			keke_array_push(c, s);
+      keke_array_push(c, s);
-		}
+    } else {
-	}
+      keke_array_pop(b, s);
-	while(a->len) {
+      keke_array_push(c, s);
-		keke_array_pop(a, s);
+    }
-		keke_array_push(c, s);
+  }
-	}
+  while (a->len) {
-	while(b->len) {
+    keke_array_pop(a, s);
-		keke_array_pop(b, s);
+    keke_array_push(c, s);
-		keke_array_push(c, s);
+  }
-	}
+  while (b->len) {
-	free(s);
+    keke_array_pop(b, s);
-	return c;
+    keke_array_push(c, s);
+  }
+  free(s);
+  return c;
 }
 
 KekeArray *keke_array_filter(KekeArray *array, Test_func test) {
-	KekeArray *ret = keke_array_alloc(0, array->type_size);
+  KekeArray *ret = keke_array_alloc(0, array->type_size);
-    for(size_t i = 0; i < array->len; i++) {
+  for (size_t i = 0; i < array->len; i++) {
-    	if(test(ARRAY_GET(array, i), i, array)) {
+    if (test(ARRAY_GET(array, i), i, array)) {
-    		keke_array_push(ret, ARRAY_GET(array, i));
+      keke_array_push(ret, ARRAY_GET(array, i));
-    	}
     }
-    return ret;
+  }
+  return ret;
 }
 
 typedef void (*B_func)(void *, void *);
 
 void keke_array_reduce(KekeArray *array, B_func op, void *acc) {
-	for(size_t i = 0; i < array->len; i++) op(ARRAY_GET(array, i), acc);
+  for (size_t i = 0; i < array->len; i++)
+    op(ARRAY_GET(array, i), acc);
 }
 
 #undef ARRAY_GET
-
-#endif

libkeke_array.h

@@ -1,15 +1,13 @@
-#ifndef LIBKEKE_ARRAY
+#include <stdbool.h>
-#define LIBKEKE_ARRAY
-
 #include <stddef.h>
 #include <stdint.h>
-#include <stdbool.h>
+#pragma once
 
 typedef struct {
-	size_t type_size;
+  size_t type_size;
-	size_t len;
+  size_t len;
-	size_t max_len;
+  size_t max_len;
-	void *content;
+  void *content;
 } KekeArray;
 
 KekeArray *keke_array_alloc(size_t initial_len, size_t type_size);
@@ -27,7 +25,8 @@ void keke_array_pop(KekeArray *array, void *value);
 void keke_array_delete(KekeArray *array, size_t index);
 
 KekeArray *keke_array_yoink(KekeArray *array, size_t start_index, size_t len);
-int keke_array_insert_data(KekeArray *array, size_t index, void *data, size_t len);
+int keke_array_insert_data(KekeArray *array, size_t index, void *data,
+                           size_t len);
 int keke_array_plop(KekeArray *array, size_t index, KekeArray *array2);
 
 typedef void (*Foreach_func)(void *, size_t, KekeArray *);
@@ -40,7 +39,8 @@ void keke_array_reverse(KekeArray *array);
 void keke_array_qsort(KekeArray *array);
 void keke_array_qsort_header(KekeArray *array, size_t start_header_size);
 KekeArray *keke_array_merge(KekeArray *a, KekeArray *b);
-KekeArray *keke_array_merge_by_header(KekeArray *a, KekeArray *b, size_t start_header_size);
+KekeArray *keke_array_merge_by_header(KekeArray *a, KekeArray *b,
+                                      size_t start_header_size);
 typedef int (*Rng_fun)(int);
 void keke_array_shuffle(KekeArray *array, Rng_fun rng);
 
@@ -55,5 +55,3 @@ KekeArray *keke_array_filter(KekeArray *array, Test_func test);
 
 typedef void (*B_func)(void *, void *);
 void keke_array_reduce(KekeArray *array, B_func op, void *acc);
-
-#endif

libkeke_symbol.c

@@ -1,8 +1,6 @@
-#include <stdint.h>
 #include "libkeke_symbol.h"
+#include <stdint.h>
 
 static _Atomic KekeSymbol iota = KEKE_NULL_SYMBOL + 1;
 
-KekeSymbol keke_new_symbol() {
+KekeSymbol keke_new_symbol() { return iota++; }
-	return iota++;
-}

libkeke_utils.c

@@ -1,27 +1,29 @@
 #include <stddef.h>
 
 void keke_swap(void *a, void *b, size_t size) {
-	if(a == b) return;
+  if (a == b)
-	size_t i = 0;
+    return;
-	int *ia = a;
+  size_t i = 0;
-	int *ib = b;
+  int *ia = a;
-	for(i = 0; i < (size / sizeof(int)); ++i) {
+  int *ib = b;
-		ia[i] ^= ib[i];
+  for (i = 0; i < (size / sizeof(int)); ++i) {
-		ib[i] ^= ia[i];
+    ia[i] ^= ib[i];
-		ia[i] ^= ib[i];
+    ib[i] ^= ia[i];
-	}
+    ia[i] ^= ib[i];
-	size %= sizeof(int);
+  }
-	char *aa = a + (i * sizeof(int));
+  size %= sizeof(int);
-	char *bb = b + (i * sizeof(int));
+  char *aa = a + (i * sizeof(int));
-	for(i = 0; i < size; i++) {
+  char *bb = b + (i * sizeof(int));
-		aa[i] ^= bb[i];
+  for (i = 0; i < size; i++) {
-		bb[i] ^= aa[i];
+    aa[i] ^= bb[i];
-		aa[i] ^= bb[i];
+    bb[i] ^= aa[i];
-	}
+    aa[i] ^= bb[i];
+  }
 }
 
-size_t bit_ceil(size_t	s) {
+size_t bit_ceil(size_t s) {
-    size_t t = 1;
+  size_t t = 1;
-    while(t < s) t <<= 1;
+  while (t < s)
-    return t;
+    t <<= 1;
+  return t;
 }

libkeke_utils.h

@@ -1,12 +1,8 @@
-#ifndef LIBKEKE_UTILS
-#define LIBKEKE_UTILS
 
+#pragma once
 #include <stddef.h>
 
 #define BOOL_PRETTY(b) (b ? "True" : "False")
 
 void keke_swap(void *, void *, size_t);
 size_t bit_ceil(size_t s);
-
-#endif
-

test_array.c

@@ -1,188 +1,173 @@
-#include <stdio.h>
-#include <stddef.h>
-#include <stdlib.h>
-#include <string.h>
 #include "libkeke_array.h"
 #include "libkeke_utils.h"
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
 
 #define ARRAY_LEN 10
 #define ARRAY_ALT_LEN 512
 
 void set(void *, size_t index, KekeArray *array) {
-    keke_array_set(array, ARRAY_LEN - index - 1, &index);
+  keke_array_set(array, ARRAY_LEN - index - 1, &index);
 }
 
 void set_alt(void *, size_t index, KekeArray *array) {
-    keke_array_set(array, ARRAY_ALT_LEN - index - 1, &index);
+  keke_array_set(array, ARRAY_ALT_LEN - index - 1, &index);
 }
 
-void output(void *i, size_t, KekeArray *) {
+void output(void *i, size_t, KekeArray *) { printf("%d, ", *(int *)i); }
-    printf("%d, ", *(int *)i);
-}
 
-void output_hex(void *i, size_t, KekeArray *) {
+void output_hex(void *i, size_t, KekeArray *) { printf("%x, ", *(int *)i); }
-    printf("%x, ", *(int *)i);
-}
 
-void sub4(void *i, size_t, KekeArray *) {
+void sub4(void *i, size_t, KekeArray *) { *(int *)i -= 4; }
-	*(int *)i -= 4;
-}
 
-void add250(void *i, size_t, KekeArray *) {
+void add250(void *i, size_t, KekeArray *) { *(int *)i += 250; }
-	*(int *)i += 250;
-}
 
-void sub250(void *i, size_t, KekeArray *) {
+void sub250(void *i, size_t, KekeArray *) { *(int *)i -= 250; }
-	*(int *)i -= 250;
-}
 
-bool heart(void *i, size_t, KekeArray *) {
+bool heart(void *i, size_t, KekeArray *) { return *(int *)i < 3; }
-	return *(int *)i < 3;
-}
 
-bool lt2(void *i, size_t, KekeArray *) {
+bool lt2(void *i, size_t, KekeArray *) { return *(int *)i < 2; }
-	return *(int *)i < 2;
-}
 
 void add(void *vx, void *vacc) {
-	int *x = (int *)vx;
+  int *x = (int *)vx;
-	int *acc = (int *)vacc;
+  int *acc = (int *)vacc;
-	*acc += *x;
+  *acc += *x;
 }
 
-int rng(int x) {
+int rng(int x) { return rand() % x; }
-	return rand() % x;
-}
 
 int main(void) {
-	KekeArray *array = keke_array_alloc(ARRAY_LEN, sizeof(int));
+  KekeArray *array = keke_array_alloc(ARRAY_LEN, sizeof(int));
 
-    puts("Expected value:\n0");
+  puts("Expected value:\n0");
-    printf("%d", *(int *)keke_array_get(array, 0)); //initialized to 0
+  printf("%d", *(int *)keke_array_get(array, 0)); // initialized to 0
-	puts("\n");
+  puts("\n");
-    
-    keke_array_foreach(array, set);
-    puts("Expected value:\n9, 8, 7, 6, 5, 4, 3, 2, 1, 0,");
-    keke_array_foreach(array, output);
-	puts("\n");
 
-	KekeArray *array2 = keke_array_yoink(array, 2, 4);
+  keke_array_foreach(array, set);
-    puts("Expected value:\n7, 6, 5, 4,");
+  puts("Expected value:\n9, 8, 7, 6, 5, 4, 3, 2, 1, 0,");
-    keke_array_foreach(array2, output);
+  keke_array_foreach(array, output);
-	puts("\n");
+  puts("\n");
-    puts("Expected value:\n9, 8, 3, 2, 1, 0,");
-    keke_array_foreach(array, output);
-	puts("\n");
 
-    const int k = 100;
+  KekeArray *array2 = keke_array_yoink(array, 2, 4);
-    keke_array_insert(array2, 2, &k);
+  puts("Expected value:\n7, 6, 5, 4,");
-    puts("Expected value:\n7, 6, 100, 5, 4,");
+  keke_array_foreach(array2, output);
-    keke_array_foreach(array2, output);
+  puts("\n");
-	puts("\n");
+  puts("Expected value:\n9, 8, 3, 2, 1, 0,");
+  keke_array_foreach(array, output);
+  puts("\n");
 
-    int j;
+  const int k = 100;
-    keke_array_remove(array2, 2, &j);
+  keke_array_insert(array2, 2, &k);
-    puts("Expected value:\n7, 6, 5, 0,\t100");
+  puts("Expected value:\n7, 6, 100, 5, 4,");
-    keke_array_foreach(array2, output);
+  keke_array_foreach(array2, output);
-    printf("\t%d", j);
+  puts("\n");
-	puts("\n");
 
-    keke_array_delete(array2, 3);
+  int j;
-    puts("Expected value:\n7, 6, 5");
+  keke_array_remove(array2, 2, &j);
-    keke_array_foreach(array2, output);
+  puts("Expected value:\n7, 6, 5, 0,\t100");
-	puts("\n");
+  keke_array_foreach(array2, output);
+  printf("\t%d", j);
+  puts("\n");
 
-    KekeArray *array3 = keke_array_clone(array2);
+  keke_array_delete(array2, 3);
-    keke_array_plop(array2, 1, array3); //array3 is freed
+  puts("Expected value:\n7, 6, 5");
-    puts("Expected value:\n7, 7, 6, 5, 6, 5,");
+  keke_array_foreach(array2, output);
-    keke_array_foreach(array2, output);
+  puts("\n");
-	puts("\n");
 
-    keke_array_pop(array2, &j);
+  KekeArray *array3 = keke_array_clone(array2);
-    puts("Expected value:\n7, 7, 6, 5, 6,\t5");
+  keke_array_plop(array2, 1, array3); // array3 is freed
-    keke_array_foreach(array2, output);
+  puts("Expected value:\n7, 7, 6, 5, 6, 5,");
-    printf("\t%d", j);
+  keke_array_foreach(array2, output);
-	puts("\n");
+  puts("\n");
 
-    keke_array_copy(array2, 2, &j);
+  keke_array_pop(array2, &j);
-    keke_array_push(array2, &j);
+  puts("Expected value:\n7, 7, 6, 5, 6,\t5");
-    puts("Expected value:\n7, 7, 6, 5, 6, 6,");
+  keke_array_foreach(array2, output);
-    keke_array_foreach(array2, output);
+  printf("\t%d", j);
-	puts("\n");
+  puts("\n");
 
-    keke_array_set_len(array, 2);
+  keke_array_copy(array2, 2, &j);
-    puts("Expected value:\n9, 8,");
+  keke_array_push(array2, &j);
-    keke_array_foreach(array, output);
+  puts("Expected value:\n7, 7, 6, 5, 6, 6,");
-	puts("\n");
+  keke_array_foreach(array2, output);
+  puts("\n");
 
-    keke_array_set(array, 4, &j);
+  keke_array_set_len(array, 2);
-    puts("Expected value:\n9, 8, 0, 0, 6,");
+  puts("Expected value:\n9, 8,");
-    keke_array_foreach(array, output);
+  keke_array_foreach(array, output);
-	puts("\n");
+  puts("\n");
 
-    keke_array_fill(array, &j);
+  keke_array_set(array, 4, &j);
-    puts("Expected value:\n6, 6, 6, 6, 6,");
+  puts("Expected value:\n9, 8, 0, 0, 6,");
-    keke_array_foreach(array, output);
+  keke_array_foreach(array, output);
-	puts("\n");
+  puts("\n");
 
-    keke_array_reverse(array2);
+  keke_array_fill(array, &j);
-    puts("Expected value:\n6, 6, 5, 6, 7, 7,");
+  puts("Expected value:\n6, 6, 6, 6, 6,");
-    keke_array_foreach(array2, output);
+  keke_array_foreach(array, output);
-	puts("\n");
+  puts("\n");
 
-	keke_array_foreach(array2, sub4);
+  keke_array_reverse(array2);
-    puts("Expected value:\n2, 2, 1, 2, 3, 3,");
+  puts("Expected value:\n6, 6, 5, 6, 7, 7,");
-	keke_array_foreach(array2, output);
+  keke_array_foreach(array2, output);
-	puts("\n");
+  puts("\n");
 
-	keke_array_qsort(array2);
+  keke_array_foreach(array2, sub4);
-    puts("Expected value:\n1, 2, 2, 2, 3, 3,");
+  puts("Expected value:\n2, 2, 1, 2, 3, 3,");
-	keke_array_foreach(array2, output);
+  keke_array_foreach(array2, output);
-	puts("\n");
+  puts("\n");
 
-	bool h = keke_array_some(array2, heart);
+  keke_array_qsort(array2);
-	bool g = keke_array_all(array2, heart);
+  puts("Expected value:\n1, 2, 2, 2, 3, 3,");
-    puts("Expected value:\nTrue, False");
+  keke_array_foreach(array2, output);
-    printf("%s, %s\n\n", BOOL_PRETTY(h), BOOL_PRETTY(g));
+  puts("\n");
 
-	KekeArray *array4 = keke_array_filter(array2, heart);
+  bool h = keke_array_some(array2, heart);
-    puts("Expected value:\n1, 2, 2, 2,");
+  bool g = keke_array_all(array2, heart);
-	keke_array_foreach(array4, output);
+  puts("Expected value:\nTrue, False");
-	puts("\n");
+  printf("%s, %s\n\n", BOOL_PRETTY(h), BOOL_PRETTY(g));
 
-	int *l = keke_array_find(array2, lt2);
+  KekeArray *array4 = keke_array_filter(array2, heart);
-    puts("Expected value:\n1");
+  puts("Expected value:\n1, 2, 2, 2,");
-    printf("%d\n\n", *l);
+  keke_array_foreach(array4, output);
-    
+  puts("\n");
-	l = keke_array_find_start(array2, l, sizeof(*l));
-    puts("Expected value:\n1");
-    printf("%d\n\n", *l);
 
-	j = 0;
+  int *l = keke_array_find(array2, lt2);
-	keke_array_reduce(array4, add, &j);
+  puts("Expected value:\n1");
-	printf("Expected value:\n7\n%d\n\n", j);
+  printf("%d\n\n", *l);
 
-	keke_array_foreach(array, set);
+  l = keke_array_find_start(array2, l, sizeof(*l));
-	keke_array_qsort(array);
+  puts("Expected value:\n1");
-	KekeArray *array5 = keke_array_merge(array, array2);
+  printf("%d\n\n", *l);
-	printf("Expected value:\n0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 4, 5, 6, 7, 8, 9,\n");
-	keke_array_foreach(array5, output);
-	puts("\n");
 
-	keke_array_shuffle(array5, rng);
+  j = 0;
-	printf("Expected value:\n2, 0, 3, 7, 3, 1, 8, 2, 2, 1, 3, 5, 6, 2, 9, 4,\n");
+  keke_array_reduce(array4, add, &j);
-	keke_array_foreach(array5, output);
+  printf("Expected value:\n7\n%d\n\n", j);
-	puts("\n");
 
-	keke_array_foreach(array5, add250);
+  keke_array_foreach(array, set);
-	keke_array_qsort_header(array5, sizeof(int));
+  keke_array_qsort(array);
-	printf("Expected value:\n250, 251, 251, 252, 252, 252, 252, 253, 253, 253, 254, 255, 256, 257, 258, 259,\n");
+  KekeArray *array5 = keke_array_merge(array, array2);
-	keke_array_foreach(array5, output);
+  printf("Expected value:\n0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 4, 5, 6, 7, 8, 9,\n");
-	puts("\n");
+  keke_array_foreach(array5, output);
+  puts("\n");
 
-    keke_array_free(array);
+  keke_array_shuffle(array5, rng);
-    keke_array_free(array2);
+  printf("Expected value:\n2, 0, 3, 7, 3, 1, 8, 2, 2, 1, 3, 5, 6, 2, 9, 4,\n");
-    keke_array_free(array4);
+  keke_array_foreach(array5, output);
-    keke_array_free(array5);
+  puts("\n");
-	return 0;
+
+  keke_array_foreach(array5, add250);
+  keke_array_qsort_header(array5, sizeof(int));
+  printf("Expected value:\n250, 251, 251, 252, 252, 252, 252, 253, 253, 253, "
+         "254, 255, 256, 257, 258, 259,\n");
+  keke_array_foreach(array5, output);
+  puts("\n");
+
+  keke_array_free(array);
+  keke_array_free(array2);
+  keke_array_free(array4);
+  keke_array_free(array5);
+  return 0;
 }

test_array_u64.c

@@ -1,197 +1,184 @@
-#include <stdio.h>
-#include <stddef.h>
-#include <stdlib.h>
-#include <string.h>
 #include "libkeke_array.h"
 #include "libkeke_utils.h"
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
 
 #define ARRAY_LEN 10
 #define ARRAY_ALT_LEN 512
 
 void set(void *, size_t index, KekeArray *array) {
-    keke_array_set(array, ARRAY_LEN - index - 1, &index);
+  keke_array_set(array, ARRAY_LEN - index - 1, &index);
 }
 
 void set_alt(void *, size_t index, KekeArray *array) {
-    keke_array_set(array, ARRAY_ALT_LEN - index - 1, &index);
+  keke_array_set(array, ARRAY_ALT_LEN - index - 1, &index);
 }
 
-void output(void *i, size_t, KekeArray *) {
+void output(void *i, size_t, KekeArray *) { printf("%lu, ", *(uint64_t *)i); }
-    printf("%lu, ", *(uint64_t *)i);
-}
 
 void output_hex(void *i, size_t, KekeArray *) {
-    printf("%lx, ", *(uint64_t *)i);
+  printf("%lx, ", *(uint64_t *)i);
 }
 
-void sub4(void *i, size_t, KekeArray *) {
+void sub4(void *i, size_t, KekeArray *) { *(uint64_t *)i -= 4; }
-	*(uint64_t *)i -= 4;
-}
 
-void add250(void *i, size_t, KekeArray *) {
+void add250(void *i, size_t, KekeArray *) { *(uint64_t *)i += 250; }
-	*(uint64_t *)i += 250;
-}
 
-void sub250(void *i, size_t, KekeArray *) {
+void sub250(void *i, size_t, KekeArray *) { *(uint64_t *)i -= 250; }
-	*(uint64_t *)i -= 250;
-}
 
-bool heart(void *i, size_t, KekeArray *) {
+bool heart(void *i, size_t, KekeArray *) { return *(uint64_t *)i < 3; }
-	return *(uint64_t *)i < 3;
-}
 
-bool lt2(void *i, size_t, KekeArray *) {
+bool lt2(void *i, size_t, KekeArray *) { return *(uint64_t *)i < 2; }
-	return *(uint64_t *)i < 2;
-}
 
 void add(void *vx, void *vacc) {
-	uint64_t *x = (uint64_t *)vx;
+  uint64_t *x = (uint64_t *)vx;
-	uint64_t *acc = (uint64_t *)vacc;
+  uint64_t *acc = (uint64_t *)vacc;
-	*acc += *x;
+  *acc += *x;
 }
 
-int rng(int x) {
+int rng(int x) { return rand() % x; }
-	return rand() % x;
-}
 
 int main(void) {
-	KekeArray *array = keke_array_alloc(ARRAY_LEN, sizeof(uint64_t));
+  KekeArray *array = keke_array_alloc(ARRAY_LEN, sizeof(uint64_t));
 
-    puts("Expected value:\n0");
+  puts("Expected value:\n0");
-    printf("%lu", *(uint64_t *)keke_array_get(array, 0)); //initialized to 0
+  printf("%lu", *(uint64_t *)keke_array_get(array, 0)); // initialized to 0
-	puts("\n");
+  puts("\n");
-    
-    keke_array_foreach(array, set);
-    puts("Expected value:\n9, 8, 7, 6, 5, 4, 3, 2, 1, 0,");
-    keke_array_foreach(array, output);
-	puts("\n");
 
-	KekeArray *array2 = keke_array_yoink(array, 2, 4);
+  keke_array_foreach(array, set);
-    puts("Expected value:\n7, 6, 5, 4,");
+  puts("Expected value:\n9, 8, 7, 6, 5, 4, 3, 2, 1, 0,");
-    keke_array_foreach(array2, output);
+  keke_array_foreach(array, output);
-	puts("\n");
+  puts("\n");
-    puts("Expected value:\n9, 8, 3, 2, 1, 0,");
-    keke_array_foreach(array, output);
-	puts("\n");
 
-    const uint64_t k = 100;
+  KekeArray *array2 = keke_array_yoink(array, 2, 4);
-    keke_array_insert(array2, 2, &k);
+  puts("Expected value:\n7, 6, 5, 4,");
-    puts("Expected value:\n7, 6, 100, 5, 4,");
+  keke_array_foreach(array2, output);
-    keke_array_foreach(array2, output);
+  puts("\n");
-	puts("\n");
+  puts("Expected value:\n9, 8, 3, 2, 1, 0,");
+  keke_array_foreach(array, output);
+  puts("\n");
 
-    uint64_t j;
+  const uint64_t k = 100;
-    keke_array_remove(array2, 2, &j);
+  keke_array_insert(array2, 2, &k);
-    puts("Expected value:\n7, 6, 5, 0,\t100");
+  puts("Expected value:\n7, 6, 100, 5, 4,");
-    keke_array_foreach(array2, output);
+  keke_array_foreach(array2, output);
-    printf("\t%lu", j);
+  puts("\n");
-	puts("\n");
 
-    keke_array_delete(array2, 3);
+  uint64_t j;
-    puts("Expected value:\n7, 6, 5");
+  keke_array_remove(array2, 2, &j);
-    keke_array_foreach(array2, output);
+  puts("Expected value:\n7, 6, 5, 0,\t100");
-	puts("\n");
+  keke_array_foreach(array2, output);
+  printf("\t%lu", j);
+  puts("\n");
 
-    KekeArray *array3 = keke_array_clone(array2);
+  keke_array_delete(array2, 3);
-    keke_array_plop(array2, 1, array3); //array3 is freed
+  puts("Expected value:\n7, 6, 5");
-    puts("Expected value:\n7, 7, 6, 5, 6, 5,");
+  keke_array_foreach(array2, output);
-    keke_array_foreach(array2, output);
+  puts("\n");
-	puts("\n");
 
-    keke_array_pop(array2, &j);
+  KekeArray *array3 = keke_array_clone(array2);
-    puts("Expected value:\n7, 7, 6, 5, 6,\t5");
+  keke_array_plop(array2, 1, array3); // array3 is freed
-    keke_array_foreach(array2, output);
+  puts("Expected value:\n7, 7, 6, 5, 6, 5,");
-    printf("\t%lu", j);
+  keke_array_foreach(array2, output);
-	puts("\n");
+  puts("\n");
 
-    keke_array_copy(array2, 2, &j);
+  keke_array_pop(array2, &j);
-    keke_array_push(array2, &j);
+  puts("Expected value:\n7, 7, 6, 5, 6,\t5");
-    puts("Expected value:\n7, 7, 6, 5, 6, 6,");
+  keke_array_foreach(array2, output);
-    keke_array_foreach(array2, output);
+  printf("\t%lu", j);
-	puts("\n");
+  puts("\n");
 
-    keke_array_set_len(array, 2);
+  keke_array_copy(array2, 2, &j);
-    puts("Expected value:\n9, 8,");
+  keke_array_push(array2, &j);
-    keke_array_foreach(array, output);
+  puts("Expected value:\n7, 7, 6, 5, 6, 6,");
-	puts("\n");
+  keke_array_foreach(array2, output);
+  puts("\n");
 
-    keke_array_set(array, 4, &j);
+  keke_array_set_len(array, 2);
-    puts("Expected value:\n9, 8, 0, 0, 6,");
+  puts("Expected value:\n9, 8,");
-    keke_array_foreach(array, output);
+  keke_array_foreach(array, output);
-	puts("\n");
+  puts("\n");
 
-    keke_array_fill(array, &j);
+  keke_array_set(array, 4, &j);
-    puts("Expected value:\n6, 6, 6, 6, 6,");
+  puts("Expected value:\n9, 8, 0, 0, 6,");
-    keke_array_foreach(array, output);
+  keke_array_foreach(array, output);
-	puts("\n");
+  puts("\n");
 
-    keke_array_reverse(array2);
+  keke_array_fill(array, &j);
-    puts("Expected value:\n6, 6, 5, 6, 7, 7,");
+  puts("Expected value:\n6, 6, 6, 6, 6,");
-    keke_array_foreach(array2, output);
+  keke_array_foreach(array, output);
-	puts("\n");
+  puts("\n");
 
-	keke_array_foreach(array2, sub4);
+  keke_array_reverse(array2);
-    puts("Expected value:\n2, 2, 1, 2, 3, 3,");
+  puts("Expected value:\n6, 6, 5, 6, 7, 7,");
-	keke_array_foreach(array2, output);
+  keke_array_foreach(array2, output);
-	puts("\n");
+  puts("\n");
 
-	keke_array_qsort(array2);
+  keke_array_foreach(array2, sub4);
-    puts("Expected value:\n1, 2, 2, 2, 3, 3,");
+  puts("Expected value:\n2, 2, 1, 2, 3, 3,");
-	keke_array_foreach(array2, output);
+  keke_array_foreach(array2, output);
-	puts("\n");
+  puts("\n");
 
-	bool h = keke_array_some(array2, heart);
+  keke_array_qsort(array2);
-	bool g = keke_array_all(array2, heart);
+  puts("Expected value:\n1, 2, 2, 2, 3, 3,");
-    puts("Expected value:\nTrue, False");
+  keke_array_foreach(array2, output);
-    printf("%s, %s\n\n", BOOL_PRETTY(h), BOOL_PRETTY(g));
+  puts("\n");
 
-	KekeArray *array4 = keke_array_filter(array2, heart);
+  bool h = keke_array_some(array2, heart);
-    puts("Expected value:\n1, 2, 2, 2,");
+  bool g = keke_array_all(array2, heart);
-	keke_array_foreach(array4, output);
+  puts("Expected value:\nTrue, False");
-	puts("\n");
+  printf("%s, %s\n\n", BOOL_PRETTY(h), BOOL_PRETTY(g));
 
-	uint64_t *l = keke_array_find(array2, lt2);
+  KekeArray *array4 = keke_array_filter(array2, heart);
-    puts("Expected value:\n1");
+  puts("Expected value:\n1, 2, 2, 2,");
-    printf("%lu\n\n", *l);
+  keke_array_foreach(array4, output);
-    
+  puts("\n");
-	l = keke_array_find_start(array2, l, sizeof(*l));
-    puts("Expected value:\n1");
-    printf("%lu\n\n", *l);
 
-	j = 0;
+  uint64_t *l = keke_array_find(array2, lt2);
-	keke_array_reduce(array4, add, &j);
+  puts("Expected value:\n1");
-	printf("Expected value:\n7\n%lu\n\n", j);
+  printf("%lu\n\n", *l);
 
-	keke_array_foreach(array, set);
+  l = keke_array_find_start(array2, l, sizeof(*l));
-	keke_array_qsort(array);
+  puts("Expected value:\n1");
-	KekeArray *array5 = keke_array_merge(array, array2);
+  printf("%lu\n\n", *l);
-	printf("Expected value:\n0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 4, 5, 6, 7, 8, 9,\n");
-	keke_array_foreach(array5, output);
-	puts("\n");
 
-	keke_array_shuffle(array5, rng);
+  j = 0;
-	printf("Expected value:\n2, 0, 3, 7, 3, 1, 8, 2, 2, 1, 3, 5, 6, 2, 9, 4,\n");
+  keke_array_reduce(array4, add, &j);
-	keke_array_foreach(array5, output);
+  printf("Expected value:\n7\n%lu\n\n", j);
-	puts("\n");
 
-	keke_array_foreach(array5, add250);
+  keke_array_foreach(array, set);
-	keke_array_qsort_header(array5, sizeof(uint64_t));
+  keke_array_qsort(array);
-	printf("Expected value:\n250, 251, 251, 252, 252, 252, 252, 253, 253, 253, 254, 255, 256, 257, 258, 259,\n");
+  KekeArray *array5 = keke_array_merge(array, array2);
-	keke_array_foreach(array5, output);
+  printf("Expected value:\n0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 4, 5, 6, 7, 8, 9,\n");
-	puts("\n");
+  keke_array_foreach(array5, output);
+  puts("\n");
 
-	KekeArray *array6 = keke_array_alloc(512, sizeof(uint64_t));
+  keke_array_shuffle(array5, rng);
-	keke_array_foreach(array6, set_alt);
+  printf("Expected value:\n2, 0, 3, 7, 3, 1, 8, 2, 2, 1, 3, 5, 6, 2, 9, 4,\n");
-	keke_array_reverse(array6);
+  keke_array_foreach(array5, output);
-	keke_array_foreach(array5, sub250);
+  puts("\n");
-	KekeArray *array7 = keke_array_merge(array6, array5);
-	keke_array_foreach(array7, output_hex);
-	puts("\n");
 
-    keke_array_free(array);
+  keke_array_foreach(array5, add250);
-    keke_array_free(array2);
+  keke_array_qsort_header(array5, sizeof(uint64_t));
-    keke_array_free(array4);
+  printf("Expected value:\n250, 251, 251, 252, 252, 252, 252, 253, 253, 253, "
-    keke_array_free(array5);
+         "254, 255, 256, 257, 258, 259,\n");
-    keke_array_free(array6);
+  keke_array_foreach(array5, output);
-	return 0;
+  puts("\n");
+
+  KekeArray *array6 = keke_array_alloc(512, sizeof(uint64_t));
+  keke_array_foreach(array6, set_alt);
+  keke_array_reverse(array6);
+  keke_array_foreach(array5, sub250);
+  KekeArray *array7 = keke_array_merge(array6, array5);
+  keke_array_foreach(array7, output_hex);
+  puts("\n");
+
+  keke_array_free(array);
+  keke_array_free(array2);
+  keke_array_free(array4);
+  keke_array_free(array5);
+  keke_array_free(array6);
+  return 0;
 }

test_symbol.c

@@ -1,20 +1,20 @@
-#include <stdio.h>
 #include "libkeke_symbol.h"
+#include <stdio.h>
 
 int main(void) {
-	KekeSymbol s = keke_new_symbol();
+  KekeSymbol s = keke_new_symbol();
-	if(s == KEKE_NULL_SYMBOL) {
+  if (s == KEKE_NULL_SYMBOL) {
-		puts("s != KEKE_NULL_SYMBOL\nTEST FAILED");
+    puts("s != KEKE_NULL_SYMBOL\nTEST FAILED");
-		return 1;
+    return 1;
-	} else {
+  } else {
-		puts("s != KEKE_NULL_SYMBOL\nTEST PASSED\n");
+    puts("s != KEKE_NULL_SYMBOL\nTEST PASSED\n");
-	}
+  }
-	
+
-	KekeSymbol t = keke_new_symbol();
+  KekeSymbol t = keke_new_symbol();
-	if(s == t) {
+  if (s == t) {
-		puts("s == t\nTEST FAILED");
+    puts("s == t\nTEST FAILED");
-		return 1;
+    return 1;
-	} else {
+  } else {
-		puts("s != t\nTEST PASSED\n");
+    puts("s != t\nTEST PASSED\n");
-	}
+  }
 }