diff --git a/libkeke_array.c b/libkeke_array.c index 371f5cc..a23a0ca 100644 --- a/libkeke_array.c +++ b/libkeke_array.c @@ -1,195 +1,222 @@ -#ifndef LIBKEKE_ARRAY -#define LIBKEKE_ARRAY // Required for qsort_r on Linux #define _GNU_SOURCE -#include -#include -#include -#include -#include -#include -#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 +#include +#include +#include +#include +#include #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 diff --git a/libkeke_array.h b/libkeke_array.h index f153c75..bd1f226 100644 --- a/libkeke_array.h +++ b/libkeke_array.h @@ -1,15 +1,13 @@ -#ifndef LIBKEKE_ARRAY -#define LIBKEKE_ARRAY - +#include #include #include -#include +#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 diff --git a/libkeke_symbol.c b/libkeke_symbol.c index 8eea560..74dbe8a 100644 --- a/libkeke_symbol.c +++ b/libkeke_symbol.c @@ -1,8 +1,6 @@ -#include #include "libkeke_symbol.h" +#include static _Atomic KekeSymbol iota = KEKE_NULL_SYMBOL + 1; -KekeSymbol keke_new_symbol() { - return iota++; -} +KekeSymbol keke_new_symbol() { return iota++; } diff --git a/libkeke_utils.c b/libkeke_utils.c index 798db44..5d52370 100644 --- a/libkeke_utils.c +++ b/libkeke_utils.c @@ -1,27 +1,29 @@ #include 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; } diff --git a/libkeke_utils.h b/libkeke_utils.h index 1eb4929..f0bbaec 100644 --- a/libkeke_utils.h +++ b/libkeke_utils.h @@ -1,12 +1,8 @@ -#ifndef LIBKEKE_UTILS -#define LIBKEKE_UTILS +#pragma once #include #define BOOL_PRETTY(b) (b ? "True" : "False") void keke_swap(void *, void *, size_t); size_t bit_ceil(size_t s); - -#endif - diff --git a/test_array.c b/test_array.c index a7127da..0ce1d05 100644 --- a/test_array.c +++ b/test_array.c @@ -1,188 +1,173 @@ -#include -#include -#include -#include #include "libkeke_array.h" #include "libkeke_utils.h" +#include +#include +#include +#include #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; } diff --git a/test_array_u64.c b/test_array_u64.c index f83a8d6..05ba6c1 100644 --- a/test_array_u64.c +++ b/test_array_u64.c @@ -1,197 +1,184 @@ -#include -#include -#include -#include #include "libkeke_array.h" #include "libkeke_utils.h" +#include +#include +#include +#include #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; } diff --git a/test_symbol.c b/test_symbol.c index 8b3e2a7..b0e02c3 100644 --- a/test_symbol.c +++ b/test_symbol.c @@ -1,20 +1,20 @@ -#include #include "libkeke_symbol.h" +#include 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"); + } }