seoxi/libkeke
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

style and consistency improved

Browse Source
This commit is contained in:
Seoxi Ryouko
2026-09-03 21:13:45 -05:00
parent 8b2a2e8f65
commit 9c583ff0f6
8 changed files with 572 additions and 571 deletions
Download Patch File Download Diff File Expand all files Collapse all files
libkeke_array.c
+260 -225
View File
@@ -1,195 +1,222 @@
#ifndef LIBKEKE_ARRAY
#define LIBKEKE_ARRAY
// Required for qsort_r on Linux
#define _GNU_SOURCE
#include <stddef.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <stdbool.h>
#include <stdio.h>
#include "libkeke_utils.h"
#include "libkeke_array.h"
typedef struct {
size_t type_size;
size_t len;
size_t max_len;
void *content;
} KekeArray;
#include "libkeke_utils.h"
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#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));
array->len = initial_len;
size_t max_len = bit_ceil(initial_len);
KekeArray *array = malloc(sizeof(*array));
array->len = initial_len;
size_t max_len = bit_ceil(initial_len);
array->type_size = type_size;
array->max_len = max_len;
array->content = calloc(max_len, type_size);
return array;
array->type_size = type_size;
array->max_len = max_len;
array->content = calloc(max_len, type_size);
return array;
}
void keke_array_free(KekeArray *array) {
free(array->content);
free(array);
free(array->content);
free(array);
}
void keke_array_set(KekeArray *array, size_t index, const void *value) {
if(index >= array->max_len) {
array->content = realloc(array->content, (array->max_len << 1) * array->type_size);
memset(array->content + array->max_len * array->type_size, 0, array->max_len * array->type_size);
array->max_len <<= 1;
}
if(index >= array->len) array->len = index + 1;
memcpy(array->content + index * array->type_size, value, array->type_size);
if (index >= array->max_len) {
array->content =
realloc(array->content, (array->max_len << 1) * array->type_size);
memset(array->content + array->max_len * array->type_size, 0,
array->max_len * array->type_size);
array->max_len <<= 1;
}
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
return ARRAY_GET(array, index);
if (index >= array->len)
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
memcpy(value, ARRAY_GET(array, index), array->type_size);
return 0;
if (index >= array->len)
return -1; // is ur fault
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) {
size_t new_max_len = 1;
size_t len = new_len;
while(len >>= 1) new_max_len <<= 1;
array->content = realloc(array->content, new_max_len * array->type_size);
memset(array->content + array->max_len * array->type_size, 0, (new_max_len - array->max_len) * array->type_size);
array->max_len <<= 1;
} else if(new_len < array->len) {
memset(array->content + new_len * array->type_size, 0, (array->len - new_len) * array->type_size);
}
array->len = new_len;
if (new_len >= array->max_len) {
size_t new_max_len = 1;
size_t len = new_len;
while (len >>= 1)
new_max_len <<= 1;
array->content = realloc(array->content, new_max_len * array->type_size);
memset(array->content + array->max_len * array->type_size, 0,
(new_max_len - array->max_len) * array->type_size);
array->max_len <<= 1;
} else if (new_len < array->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) {
array->content = realloc(array->content, (array->max_len << 1) * array->type_size);
memset(array->content + array->max_len * array->type_size, 0, array->max_len * array->type_size);
array->max_len <<= 1;
}
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);
if (array->len + 1 > array->max_len) {
array->content =
realloc(array->content, (array->max_len << 1) * array->type_size);
memset(array->content + array->max_len * array->type_size, 0,
array->max_len * array->type_size);
array->max_len <<= 1;
}
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);
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);
memcpy(value, array->content + index * array->type_size, array->type_size);
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);
}
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);
memmove(array->content + (index * array->type_size), array->content + ((index + 1) * array->type_size), (array->len - index + 1) * array->type_size);
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);
}
void keke_array_swap_delete(KekeArray *array, size_t index) {
size_t new_len = array->len - 1;
keke_swap(ARRAY_GET(array, index), ARRAY_GET(array, new_len), array->type_size);
keke_array_set_len(array, new_len);
size_t new_len = array->len - 1;
keke_swap(ARRAY_GET(array, index), ARRAY_GET(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;
KekeArray *ret = keke_array_alloc(len, array->type_size);
memcpy(ret->content, array->content + start_index * array->type_size, 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);
keke_array_set_len(array, array->len - len);
return ret;
if (start_index + len >= array->len)
return NULL;
KekeArray *ret = keke_array_alloc(len, array->type_size);
memcpy(ret->content, array->content + start_index * array->type_size,
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);
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) {
if(index >= array->len) return -1;
size_t current_len = array->len;
keke_array_set_len(array, current_len + len);
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_insert_data(KekeArray *array, size_t index, void *data,
size_t len) {
if (index >= array->len)
return -1;
size_t current_len = array->len;
keke_array_set_len(array, current_len + len);
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);
if(ret) return ret;
keke_array_free(array2);
return 0;
int ret = keke_array_insert_data(array, index, array2->content, array2->len);
if (ret)
return ret;
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));
memcpy(ret, array, sizeof(*array));
ret->content = malloc(array->max_len * array->type_size);
memcpy(ret->content, array->content, array->max_len * array->type_size);
return ret;
KekeArray *ret = malloc(sizeof(*array));
memcpy(ret, array, sizeof(*array));
ret->content = malloc(array->max_len * array->type_size);
memcpy(ret->content, array->content, array->max_len * array->type_size);
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++) {
keke_swap(ARRAY_GET(array, i), array->content + array->type_size * (array->len - i - 1), array->type_size);
}
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);
}
}
typedef bool (*Test_func)(void *, size_t, KekeArray *);
bool keke_array_some(KekeArray *array, Test_func test) {
bool ret = false;
for(size_t i = 0; i < array->len; i++) ret = ret || test(ARRAY_GET(array, i), i, array);
return ret;
bool ret = false;
for (size_t i = 0; i < array->len; i++)
ret = ret || test(ARRAY_GET(array, i), i, array);
return ret;
}
bool keke_array_all(KekeArray *array, Test_func test) {
bool ret = true;
for(size_t i = 0; i < array->len; i++) ret = ret && test(ARRAY_GET(array, i), i, array);
return ret;
bool ret = true;
for (size_t i = 0; i < array->len; i++)
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++) {
void *current = ARRAY_GET(array, i);
if(test(current, i, array)) return current;
}
return NULL;
for (size_t i = 0; i < array->len; i++) {
void *current = ARRAY_GET(array, i);
if (test(current, i, array))
return current;
}
return NULL;
}
void *keke_array_find_start(KekeArray *array, void *start, size_t size) {
for(size_t i = 0; i < array->len; i++) {
void *current = ARRAY_GET(array, i);
if(memcmp(current, start, size) == 0) return current;
}
return NULL;
for (size_t i = 0; i < array->len; i++) {
void *current = ARRAY_GET(array, i);
if (memcmp(current, start, size) == 0)
return current;
}
return NULL;
}
/* Windows uses qsort_s rather than qsort_r and wants a BSD-style comparison function.
* This will transparently switch the comparison function based on platform. */
/* Windows uses qsort_s rather than qsort_r and wants a BSD-style comparison
* function. This will transparently switch the comparison function based on
* platform. */
#if _WIN32
#define qsort_r qsort_s
#define compar(a, b, size_v) _compar(size_v, a, b)
@@ -198,148 +225,156 @@ int _compar(void *size_v, const void *a, const void *b) {
#define compar(a, b, size_v) _compar(a, b, size_v)
int _compar(const void *a, const void *b, void *size_v) {
#endif
size_t size = *(size_t *) size_v;
#if defined(__BYTE_ORDER__)&&(__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
return memcmp(a, b, size);
size_t size = *(size_t *)size_v;
#if defined(__BYTE_ORDER__) && (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
return memcmp(a, b, size);
#else
/*const signed char *aa = a;
const signed char *bb = b;
for(size_t i = 0; i < size; ++i) {
size_t s = size - i - 1;
if(aa[s] != bb[s]) return aa[s] - bb[s];
}
return 0;*/
size_t rem = size % sizeof(int);
if(rem) {
size -= rem;
const char *c = a;
const char *d = b;
for(size_t i = 1; i <= rem; ++i) {
char j = c[size + rem - i] - d[size + rem - i];
if(j != 0) return j;
}
}
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;
/*const signed char *aa = a;
const signed char *bb = b;
for(size_t i = 0; i < size; ++i) {
size_t s = size - i - 1;
if(aa[s] != bb[s]) return aa[s] - bb[s];
}
return 0;*/
size_t rem = size % sizeof(int);
if (rem) {
size -= rem;
const char *c = a;
const char *d = b;
for (size_t i = 1; i <= rem; ++i) {
char j = c[size + rem - i] - d[size + rem - i];
if (j != 0)
return j;
}
}
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) {
size_t j = rng(i + 1);
keke_swap(ARRAY_GET(array, i), ARRAY_GET(array, j), array->type_size);
}
for (size_t i = 0; i < array->len; ++i) {
size_t j = rng(i + 1);
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) {
KekeArray *r = keke_array_clone(b);
keke_array_set_len(b, 0);
return r;
}
if(b->len == 0) {
KekeArray *r = keke_array_clone(a);
keke_array_set_len(a, 0);
return r;
}
keke_array_reverse(a);
keke_array_reverse(b);
if(a->type_size != b->type_size) return NULL;
KekeArray *c = keke_array_alloc(a->len + b->len, a->type_size);
keke_array_set_len(c, 0);
void *s = malloc(a->type_size);
while(!!(a->len) && !!(b->len)) {
if(compar(ARRAY_GET(a, a->len - 1), ARRAY_GET(b, b->len - 1), &a->type_size) <= 0) {
keke_array_pop(a, 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(b->len) {
keke_array_pop(b, s);
keke_array_push(c, s);
}
free(s);
return c;
if (a->len == 0) {
KekeArray *r = keke_array_clone(b);
keke_array_set_len(b, 0);
return r;
}
if (b->len == 0) {
KekeArray *r = keke_array_clone(a);
keke_array_set_len(a, 0);
return r;
}
keke_array_reverse(a);
keke_array_reverse(b);
if (a->type_size != b->type_size)
return NULL;
KekeArray *c = keke_array_alloc(a->len + b->len, a->type_size);
keke_array_set_len(c, 0);
void *s = malloc(a->type_size);
while (!!(a->len) && !!(b->len)) {
if (compar(ARRAY_GET(a, a->len - 1), ARRAY_GET(b, b->len - 1),
&a->type_size) <= 0) {
keke_array_pop(a, 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 (b->len) {
keke_array_pop(b, s);
keke_array_push(c, s);
}
free(s);
return c;
}
KekeArray *keke_array_merge_by_header(KekeArray *a, KekeArray *b, size_t header_size) {
if(a->len == 0) {
KekeArray *r = keke_array_clone(b);
keke_array_set_len(b, 0);
return r;
}
if(b->len == 0) {
KekeArray *r = keke_array_clone(a);
keke_array_set_len(a, 0);
return r;
}
keke_array_reverse(a);
keke_array_reverse(b);
if(a->type_size != b->type_size) return NULL;
KekeArray *c = keke_array_alloc(a->len + b->len, a->type_size);
keke_array_set_len(c, 0);
void *s = malloc(a->type_size);
while(!!(a->len) && !!(b->len)) {
if(compar(ARRAY_GET(a, a->len - 1), ARRAY_GET(b, b->len - 1), &header_size) <= 0) {
keke_array_pop(a, 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(b->len) {
keke_array_pop(b, s);
keke_array_push(c, s);
}
free(s);
return c;
KekeArray *keke_array_merge_by_header(KekeArray *a, KekeArray *b,
size_t header_size) {
if (a->len == 0) {
KekeArray *r = keke_array_clone(b);
keke_array_set_len(b, 0);
return r;
}
if (b->len == 0) {
KekeArray *r = keke_array_clone(a);
keke_array_set_len(a, 0);
return r;
}
keke_array_reverse(a);
keke_array_reverse(b);
if (a->type_size != b->type_size)
return NULL;
KekeArray *c = keke_array_alloc(a->len + b->len, a->type_size);
keke_array_set_len(c, 0);
void *s = malloc(a->type_size);
while (!!(a->len) && !!(b->len)) {
if (compar(ARRAY_GET(a, a->len - 1), ARRAY_GET(b, b->len - 1),
&header_size) <= 0) {
keke_array_pop(a, 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 (b->len) {
keke_array_pop(b, s);
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);
for(size_t i = 0; i < array->len; i++) {
if(test(ARRAY_GET(array, i), i, array)) {
keke_array_push(ret, ARRAY_GET(array, i));
}
KekeArray *ret = keke_array_alloc(0, array->type_size);
for (size_t i = 0; i < array->len; i++) {
if (test(ARRAY_GET(array, i), i, array)) {
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