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
libkeke_array.h
+10 -12
View File
@@ -1,15 +1,13 @@
#ifndef LIBKEKE_ARRAY
#define LIBKEKE_ARRAY
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <stdbool.h>
#pragma once
typedef struct {
size_t type_size;
size_t len;
size_t max_len;
void *content;
size_t type_size;
size_t len;
size_t max_len;
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
+2 -4
View File
@@ -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() {
return iota++;
}
KekeSymbol keke_new_symbol() { return iota++; }
libkeke_utils.c
+23 -21
View File
@@ -1,27 +1,29 @@
#include <stddef.h>
void keke_swap(void *a, void *b, size_t size) {
if(a == b) return;
size_t i = 0;
int *ia = a;
int *ib = b;
for(i = 0; i < (size / sizeof(int)); ++i) {
ia[i] ^= ib[i];
ib[i] ^= ia[i];
ia[i] ^= ib[i];
}
size %= sizeof(int);
char *aa = a + (i * sizeof(int));
char *bb = b + (i * sizeof(int));
for(i = 0; i < size; i++) {
aa[i] ^= bb[i];
bb[i] ^= aa[i];
aa[i] ^= bb[i];
}
if (a == b)
return;
size_t i = 0;
int *ia = a;
int *ib = b;
for (i = 0; i < (size / sizeof(int)); ++i) {
ia[i] ^= ib[i];
ib[i] ^= ia[i];
ia[i] ^= ib[i];
}
size %= sizeof(int);
char *aa = a + (i * sizeof(int));
char *bb = b + (i * sizeof(int));
for (i = 0; i < size; i++) {
aa[i] ^= bb[i];
bb[i] ^= aa[i];
aa[i] ^= bb[i];
}
}
size_t bit_ceil(size_t s) {
size_t t = 1;
while(t < s) t <<= 1;
return t;
size_t bit_ceil(size_t s) {
size_t t = 1;
while (t < s)
t <<= 1;
return t;
}
libkeke_utils.h
+1 -5
View File
@@ -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
+126 -141
View File
@@ -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 *) {
printf("%d, ", *(int *)i);
}
void output(void *i, size_t, KekeArray *) { printf("%d, ", *(int *)i); }
void output_hex(void *i, size_t, KekeArray *) {
printf("%x, ", *(int *)i);
}
void output_hex(void *i, size_t, KekeArray *) { printf("%x, ", *(int *)i); }
void sub4(void *i, size_t, KekeArray *) {
*(int *)i -= 4;
}
void sub4(void *i, size_t, KekeArray *) { *(int *)i -= 4; }
void add250(void *i, size_t, KekeArray *) {
*(int *)i += 250;
}
void add250(void *i, size_t, KekeArray *) { *(int *)i += 250; }
void sub250(void *i, size_t, KekeArray *) {
*(int *)i -= 250;
}
void sub250(void *i, size_t, KekeArray *) { *(int *)i -= 250; }
bool heart(void *i, size_t, KekeArray *) {
return *(int *)i < 3;
}
bool heart(void *i, size_t, KekeArray *) { return *(int *)i < 3; }
bool lt2(void *i, size_t, KekeArray *) {
return *(int *)i < 2;
}
bool lt2(void *i, size_t, KekeArray *) { return *(int *)i < 2; }
void add(void *vx, void *vacc) {
int *x = (int *)vx;
int *acc = (int *)vacc;
*acc += *x;
int *x = (int *)vx;
int *acc = (int *)vacc;
*acc += *x;
}
int rng(int x) {
return rand() % x;
}
int rng(int 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");
printf("%d", *(int *)keke_array_get(array, 0)); //initialized to 0
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");
puts("Expected value:\n0");
printf("%d", *(int *)keke_array_get(array, 0)); // initialized to 0
puts("\n");
KekeArray *array2 = keke_array_yoink(array, 2, 4);
puts("Expected value:\n7, 6, 5, 4,");
keke_array_foreach(array2, output);
puts("\n");
puts("Expected value:\n9, 8, 3, 2, 1, 0,");
keke_array_foreach(array, output);
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");
const int k = 100;
keke_array_insert(array2, 2, &k);
puts("Expected value:\n7, 6, 100, 5, 4,");
keke_array_foreach(array2, output);
puts("\n");
KekeArray *array2 = keke_array_yoink(array, 2, 4);
puts("Expected value:\n7, 6, 5, 4,");
keke_array_foreach(array2, output);
puts("\n");
puts("Expected value:\n9, 8, 3, 2, 1, 0,");
keke_array_foreach(array, output);
puts("\n");
int j;
keke_array_remove(array2, 2, &j);
puts("Expected value:\n7, 6, 5, 0,\t100");
keke_array_foreach(array2, output);
printf("\t%d", j);
puts("\n");
const int k = 100;
keke_array_insert(array2, 2, &k);
puts("Expected value:\n7, 6, 100, 5, 4,");
keke_array_foreach(array2, output);
puts("\n");
keke_array_delete(array2, 3);
puts("Expected value:\n7, 6, 5");
keke_array_foreach(array2, output);
puts("\n");
int j;
keke_array_remove(array2, 2, &j);
puts("Expected value:\n7, 6, 5, 0,\t100");
keke_array_foreach(array2, output);
printf("\t%d", j);
puts("\n");
KekeArray *array3 = keke_array_clone(array2);
keke_array_plop(array2, 1, array3); //array3 is freed
puts("Expected value:\n7, 7, 6, 5, 6, 5,");
keke_array_foreach(array2, output);
puts("\n");
keke_array_delete(array2, 3);
puts("Expected value:\n7, 6, 5");
keke_array_foreach(array2, output);
puts("\n");
keke_array_pop(array2, &j);
puts("Expected value:\n7, 7, 6, 5, 6,\t5");
keke_array_foreach(array2, output);
printf("\t%d", j);
puts("\n");
KekeArray *array3 = keke_array_clone(array2);
keke_array_plop(array2, 1, array3); // array3 is freed
puts("Expected value:\n7, 7, 6, 5, 6, 5,");
keke_array_foreach(array2, output);
puts("\n");
keke_array_copy(array2, 2, &j);
keke_array_push(array2, &j);
puts("Expected value:\n7, 7, 6, 5, 6, 6,");
keke_array_foreach(array2, output);
puts("\n");
keke_array_pop(array2, &j);
puts("Expected value:\n7, 7, 6, 5, 6,\t5");
keke_array_foreach(array2, output);
printf("\t%d", j);
puts("\n");
keke_array_set_len(array, 2);
puts("Expected value:\n9, 8,");
keke_array_foreach(array, output);
puts("\n");
keke_array_copy(array2, 2, &j);
keke_array_push(array2, &j);
puts("Expected value:\n7, 7, 6, 5, 6, 6,");
keke_array_foreach(array2, output);
puts("\n");
keke_array_set(array, 4, &j);
puts("Expected value:\n9, 8, 0, 0, 6,");
keke_array_foreach(array, output);
puts("\n");
keke_array_set_len(array, 2);
puts("Expected value:\n9, 8,");
keke_array_foreach(array, output);
puts("\n");
keke_array_fill(array, &j);
puts("Expected value:\n6, 6, 6, 6, 6,");
keke_array_foreach(array, output);
puts("\n");
keke_array_set(array, 4, &j);
puts("Expected value:\n9, 8, 0, 0, 6,");
keke_array_foreach(array, output);
puts("\n");
keke_array_reverse(array2);
puts("Expected value:\n6, 6, 5, 6, 7, 7,");
keke_array_foreach(array2, output);
puts("\n");
keke_array_fill(array, &j);
puts("Expected value:\n6, 6, 6, 6, 6,");
keke_array_foreach(array, output);
puts("\n");
keke_array_foreach(array2, sub4);
puts("Expected value:\n2, 2, 1, 2, 3, 3,");
keke_array_foreach(array2, output);
puts("\n");
keke_array_reverse(array2);
puts("Expected value:\n6, 6, 5, 6, 7, 7,");
keke_array_foreach(array2, output);
puts("\n");
keke_array_qsort(array2);
puts("Expected value:\n1, 2, 2, 2, 3, 3,");
keke_array_foreach(array2, output);
puts("\n");
keke_array_foreach(array2, sub4);
puts("Expected value:\n2, 2, 1, 2, 3, 3,");
keke_array_foreach(array2, output);
puts("\n");
bool h = keke_array_some(array2, heart);
bool g = keke_array_all(array2, heart);
puts("Expected value:\nTrue, False");
printf("%s, %s\n\n", BOOL_PRETTY(h), BOOL_PRETTY(g));
keke_array_qsort(array2);
puts("Expected value:\n1, 2, 2, 2, 3, 3,");
keke_array_foreach(array2, output);
puts("\n");
KekeArray *array4 = keke_array_filter(array2, heart);
puts("Expected value:\n1, 2, 2, 2,");
keke_array_foreach(array4, output);
puts("\n");
bool h = keke_array_some(array2, heart);
bool g = keke_array_all(array2, heart);
puts("Expected value:\nTrue, False");
printf("%s, %s\n\n", BOOL_PRETTY(h), BOOL_PRETTY(g));
int *l = keke_array_find(array2, lt2);
puts("Expected value:\n1");
printf("%d\n\n", *l);
l = keke_array_find_start(array2, l, sizeof(*l));
puts("Expected value:\n1");
printf("%d\n\n", *l);
KekeArray *array4 = keke_array_filter(array2, heart);
puts("Expected value:\n1, 2, 2, 2,");
keke_array_foreach(array4, output);
puts("\n");
j = 0;
keke_array_reduce(array4, add, &j);
printf("Expected value:\n7\n%d\n\n", j);
int *l = keke_array_find(array2, lt2);
puts("Expected value:\n1");
printf("%d\n\n", *l);
keke_array_foreach(array, set);
keke_array_qsort(array);
KekeArray *array5 = keke_array_merge(array, array2);
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");
l = keke_array_find_start(array2, l, sizeof(*l));
puts("Expected value:\n1");
printf("%d\n\n", *l);
keke_array_shuffle(array5, rng);
printf("Expected value:\n2, 0, 3, 7, 3, 1, 8, 2, 2, 1, 3, 5, 6, 2, 9, 4,\n");
keke_array_foreach(array5, output);
puts("\n");
j = 0;
keke_array_reduce(array4, add, &j);
printf("Expected value:\n7\n%d\n\n", j);
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_foreach(array, set);
keke_array_qsort(array);
KekeArray *array5 = keke_array_merge(array, array2);
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_free(array);
keke_array_free(array2);
keke_array_free(array4);
keke_array_free(array5);
return 0;
keke_array_shuffle(array5, rng);
printf("Expected value:\n2, 0, 3, 7, 3, 1, 8, 2, 2, 1, 3, 5, 6, 2, 9, 4,\n");
keke_array_foreach(array5, output);
puts("\n");
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
+134 -147
View File
@@ -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 *) {
printf("%lu, ", *(uint64_t *)i);
}
void output(void *i, size_t, KekeArray *) { 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 *) {
*(uint64_t *)i -= 4;
}
void sub4(void *i, size_t, KekeArray *) { *(uint64_t *)i -= 4; }
void add250(void *i, size_t, KekeArray *) {
*(uint64_t *)i += 250;
}
void add250(void *i, size_t, KekeArray *) { *(uint64_t *)i += 250; }
void sub250(void *i, size_t, KekeArray *) {
*(uint64_t *)i -= 250;
}
void sub250(void *i, size_t, KekeArray *) { *(uint64_t *)i -= 250; }
bool heart(void *i, size_t, KekeArray *) {
return *(uint64_t *)i < 3;
}
bool heart(void *i, size_t, KekeArray *) { return *(uint64_t *)i < 3; }
bool lt2(void *i, size_t, KekeArray *) {
return *(uint64_t *)i < 2;
}
bool lt2(void *i, size_t, KekeArray *) { return *(uint64_t *)i < 2; }
void add(void *vx, void *vacc) {
uint64_t *x = (uint64_t *)vx;
uint64_t *acc = (uint64_t *)vacc;
*acc += *x;
uint64_t *x = (uint64_t *)vx;
uint64_t *acc = (uint64_t *)vacc;
*acc += *x;
}
int rng(int x) {
return rand() % x;
}
int rng(int 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");
printf("%lu", *(uint64_t *)keke_array_get(array, 0)); //initialized to 0
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");
puts("Expected value:\n0");
printf("%lu", *(uint64_t *)keke_array_get(array, 0)); // initialized to 0
puts("\n");
KekeArray *array2 = keke_array_yoink(array, 2, 4);
puts("Expected value:\n7, 6, 5, 4,");
keke_array_foreach(array2, output);
puts("\n");
puts("Expected value:\n9, 8, 3, 2, 1, 0,");
keke_array_foreach(array, output);
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");
const uint64_t k = 100;
keke_array_insert(array2, 2, &k);
puts("Expected value:\n7, 6, 100, 5, 4,");
keke_array_foreach(array2, output);
puts("\n");
KekeArray *array2 = keke_array_yoink(array, 2, 4);
puts("Expected value:\n7, 6, 5, 4,");
keke_array_foreach(array2, output);
puts("\n");
puts("Expected value:\n9, 8, 3, 2, 1, 0,");
keke_array_foreach(array, output);
puts("\n");
uint64_t j;
keke_array_remove(array2, 2, &j);
puts("Expected value:\n7, 6, 5, 0,\t100");
keke_array_foreach(array2, output);
printf("\t%lu", j);
puts("\n");
const uint64_t k = 100;
keke_array_insert(array2, 2, &k);
puts("Expected value:\n7, 6, 100, 5, 4,");
keke_array_foreach(array2, output);
puts("\n");
keke_array_delete(array2, 3);
puts("Expected value:\n7, 6, 5");
keke_array_foreach(array2, output);
puts("\n");
uint64_t j;
keke_array_remove(array2, 2, &j);
puts("Expected value:\n7, 6, 5, 0,\t100");
keke_array_foreach(array2, output);
printf("\t%lu", j);
puts("\n");
KekeArray *array3 = keke_array_clone(array2);
keke_array_plop(array2, 1, array3); //array3 is freed
puts("Expected value:\n7, 7, 6, 5, 6, 5,");
keke_array_foreach(array2, output);
puts("\n");
keke_array_delete(array2, 3);
puts("Expected value:\n7, 6, 5");
keke_array_foreach(array2, output);
puts("\n");
keke_array_pop(array2, &j);
puts("Expected value:\n7, 7, 6, 5, 6,\t5");
keke_array_foreach(array2, output);
printf("\t%lu", j);
puts("\n");
KekeArray *array3 = keke_array_clone(array2);
keke_array_plop(array2, 1, array3); // array3 is freed
puts("Expected value:\n7, 7, 6, 5, 6, 5,");
keke_array_foreach(array2, output);
puts("\n");
keke_array_copy(array2, 2, &j);
keke_array_push(array2, &j);
puts("Expected value:\n7, 7, 6, 5, 6, 6,");
keke_array_foreach(array2, output);
puts("\n");
keke_array_pop(array2, &j);
puts("Expected value:\n7, 7, 6, 5, 6,\t5");
keke_array_foreach(array2, output);
printf("\t%lu", j);
puts("\n");
keke_array_set_len(array, 2);
puts("Expected value:\n9, 8,");
keke_array_foreach(array, output);
puts("\n");
keke_array_copy(array2, 2, &j);
keke_array_push(array2, &j);
puts("Expected value:\n7, 7, 6, 5, 6, 6,");
keke_array_foreach(array2, output);
puts("\n");
keke_array_set(array, 4, &j);
puts("Expected value:\n9, 8, 0, 0, 6,");
keke_array_foreach(array, output);
puts("\n");
keke_array_set_len(array, 2);
puts("Expected value:\n9, 8,");
keke_array_foreach(array, output);
puts("\n");
keke_array_fill(array, &j);
puts("Expected value:\n6, 6, 6, 6, 6,");
keke_array_foreach(array, output);
puts("\n");
keke_array_set(array, 4, &j);
puts("Expected value:\n9, 8, 0, 0, 6,");
keke_array_foreach(array, output);
puts("\n");
keke_array_reverse(array2);
puts("Expected value:\n6, 6, 5, 6, 7, 7,");
keke_array_foreach(array2, output);
puts("\n");
keke_array_fill(array, &j);
puts("Expected value:\n6, 6, 6, 6, 6,");
keke_array_foreach(array, output);
puts("\n");
keke_array_foreach(array2, sub4);
puts("Expected value:\n2, 2, 1, 2, 3, 3,");
keke_array_foreach(array2, output);
puts("\n");
keke_array_reverse(array2);
puts("Expected value:\n6, 6, 5, 6, 7, 7,");
keke_array_foreach(array2, output);
puts("\n");
keke_array_qsort(array2);
puts("Expected value:\n1, 2, 2, 2, 3, 3,");
keke_array_foreach(array2, output);
puts("\n");
keke_array_foreach(array2, sub4);
puts("Expected value:\n2, 2, 1, 2, 3, 3,");
keke_array_foreach(array2, output);
puts("\n");
bool h = keke_array_some(array2, heart);
bool g = keke_array_all(array2, heart);
puts("Expected value:\nTrue, False");
printf("%s, %s\n\n", BOOL_PRETTY(h), BOOL_PRETTY(g));
keke_array_qsort(array2);
puts("Expected value:\n1, 2, 2, 2, 3, 3,");
keke_array_foreach(array2, output);
puts("\n");
KekeArray *array4 = keke_array_filter(array2, heart);
puts("Expected value:\n1, 2, 2, 2,");
keke_array_foreach(array4, output);
puts("\n");
bool h = keke_array_some(array2, heart);
bool g = keke_array_all(array2, heart);
puts("Expected value:\nTrue, False");
printf("%s, %s\n\n", BOOL_PRETTY(h), BOOL_PRETTY(g));
uint64_t *l = keke_array_find(array2, lt2);
puts("Expected value:\n1");
printf("%lu\n\n", *l);
l = keke_array_find_start(array2, l, sizeof(*l));
puts("Expected value:\n1");
printf("%lu\n\n", *l);
KekeArray *array4 = keke_array_filter(array2, heart);
puts("Expected value:\n1, 2, 2, 2,");
keke_array_foreach(array4, output);
puts("\n");
j = 0;
keke_array_reduce(array4, add, &j);
printf("Expected value:\n7\n%lu\n\n", j);
uint64_t *l = keke_array_find(array2, lt2);
puts("Expected value:\n1");
printf("%lu\n\n", *l);
keke_array_foreach(array, set);
keke_array_qsort(array);
KekeArray *array5 = keke_array_merge(array, array2);
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");
l = keke_array_find_start(array2, l, sizeof(*l));
puts("Expected value:\n1");
printf("%lu\n\n", *l);
keke_array_shuffle(array5, rng);
printf("Expected value:\n2, 0, 3, 7, 3, 1, 8, 2, 2, 1, 3, 5, 6, 2, 9, 4,\n");
keke_array_foreach(array5, output);
puts("\n");
j = 0;
keke_array_reduce(array4, add, &j);
printf("Expected value:\n7\n%lu\n\n", j);
keke_array_foreach(array5, add250);
keke_array_qsort_header(array5, sizeof(uint64_t));
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_foreach(array, set);
keke_array_qsort(array);
KekeArray *array5 = keke_array_merge(array, array2);
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");
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_shuffle(array5, rng);
printf("Expected value:\n2, 0, 3, 7, 3, 1, 8, 2, 2, 1, 3, 5, 6, 2, 9, 4,\n");
keke_array_foreach(array5, output);
puts("\n");
keke_array_free(array);
keke_array_free(array2);
keke_array_free(array4);
keke_array_free(array5);
keke_array_free(array6);
return 0;
keke_array_foreach(array5, add250);
keke_array_qsort_header(array5, sizeof(uint64_t));
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");
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
+16 -16
View File
@@ -1,20 +1,20 @@
#include <stdio.h>
#include "libkeke_symbol.h"
#include <stdio.h>
int main(void) {
KekeSymbol s = keke_new_symbol();
if(s == KEKE_NULL_SYMBOL) {
puts("s != KEKE_NULL_SYMBOL\nTEST FAILED");
return 1;
} else {
puts("s != KEKE_NULL_SYMBOL\nTEST PASSED\n");
}
KekeSymbol t = keke_new_symbol();
if(s == t) {
puts("s == t\nTEST FAILED");
return 1;
} else {
puts("s != t\nTEST PASSED\n");
}
KekeSymbol s = keke_new_symbol();
if (s == KEKE_NULL_SYMBOL) {
puts("s != KEKE_NULL_SYMBOL\nTEST FAILED");
return 1;
} else {
puts("s != KEKE_NULL_SYMBOL\nTEST PASSED\n");
}
KekeSymbol t = keke_new_symbol();
if (s == t) {
puts("s == t\nTEST FAILED");
return 1;
} else {
puts("s != t\nTEST PASSED\n");
}
}