diff --git a/output/src/hashmap/env/env.c b/output/src/hashmap/env/env.c index d5a7f85c..088db5a2 100644 --- a/output/src/hashmap/env/env.c +++ b/output/src/hashmap/env/env.c @@ -6,7 +6,7 @@ /* By: maiboyer +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2023/12/06 10:58:20 by maiboyer #+# #+# */ -/* Updated: 2024/09/19 15:20:55 by rparodi ### ########.fr */ +/* Updated: 2024/09/19 17:50:02 by maiboyer ### ########.fr */ /* */ /* ************************************************************************** */ @@ -17,15 +17,14 @@ #include "me/types.h" #include -t_hashmap_env *hmap_env_new(\ - t_hash_env_fn hfunc, t_eq_env_fn cfunc, t_free_env_fn free) +t_hashmap_env *hmap_env_new(t_hash_env_fn hfunc, t_eq_env_fn cfunc, + t_free_env_fn free) { - return ( - hmap_env_new_with_buckets(hfunc, cfunc, free, DEFAULT_BUCKETS)); + return (hmap_env_new_with_buckets(hfunc, cfunc, free, DEFAULT_BUCKETS)); } -t_hashmap_env *hmap_env_new_with_buckets(\ - t_hash_env_fn hfunc, t_eq_env_fn cfunc, t_free_env_fn free, t_usize buckets) +t_hashmap_env *hmap_env_new_with_buckets(t_hash_env_fn hfunc, + t_eq_env_fn cfunc, t_free_env_fn free, t_usize buckets) { t_hashmap_env *hmap; @@ -67,8 +66,8 @@ void hmap_env_free(t_hashmap_env *hmap) mem_free(hmap); } -t_entry_env *hmap_env_get_entry(\ - t_hashmap_env *hmap, t_usize hashed_key, t_str *key, t_entry_env **prev) +t_entry_env *hmap_env_get_entry(t_hashmap_env *hmap, t_usize hashed_key, + t_str *key, t_entry_env **prev) { t_entry_env *entry; @@ -88,8 +87,7 @@ t_entry_env *hmap_env_get_entry(\ return (NULL); } -bool hmap_env_insert(\ - t_hashmap_env *hmap, t_str key, t_str value) +bool hmap_env_insert(t_hashmap_env *hmap, t_str key, t_str value) { t_usize hashed_key; t_entry_env *prev; @@ -114,8 +112,6 @@ bool hmap_env_insert(\ else { hmap->free(entry->kv); - entry->kv.key = key; - entry->kv.val = value; - return (true); + return (entry->kv = (typeof(entry->kv)){key, value}, true); } } diff --git a/output/src/vec/estr/estr.c b/output/src/vec/estr/estr.c index e8a2d5cd..df247d6e 100644 --- a/output/src/vec/estr/estr.c +++ b/output/src/vec/estr/estr.c @@ -15,10 +15,9 @@ #include "me/vec/vec_estr.h" #include -t_vec_estr vec_estr_new(t_usize capacity, - t_free_estr_item free_function) +t_vec_estr vec_estr_new(t_usize capacity, t_free_estr_item free_function) { - t_vec_estr out; + t_vec_estr out; out = (t_vec_estr){0}; out.free_func = free_function; @@ -29,7 +28,7 @@ t_vec_estr vec_estr_new(t_usize capacity, } /// Return true in case of an error -t_error vec_estr_push(t_vec_estr *vec, t_expandable_str element) +t_error vec_estr_push(t_vec_estr *vec, t_expandable_str element) { if (vec == NULL) return (ERROR); @@ -40,9 +39,9 @@ t_error vec_estr_push(t_vec_estr *vec, t_expandable_str element) } /// Return true in case of an error -t_error vec_estr_reserve(t_vec_estr *vec, t_usize wanted_capacity) +t_error vec_estr_reserve(t_vec_estr *vec, t_usize wanted_capacity) { - size_t new_capacity; + size_t new_capacity; if (vec == NULL) return (ERROR); @@ -51,8 +50,8 @@ t_error vec_estr_reserve(t_vec_estr *vec, t_usize wanted_capacity) new_capacity = (vec->capacity * 3) / 2 + 1; while (wanted_capacity > new_capacity) new_capacity = (new_capacity * 3) / 2 + 1; - vec->buffer = - mem_realloc_array(vec->buffer, new_capacity, sizeof(t_expandable_str)); + vec->buffer = mem_realloc_array(vec->buffer, new_capacity, + sizeof(t_expandable_str)); vec->capacity = new_capacity; } return (NO_ERROR); @@ -60,10 +59,10 @@ t_error vec_estr_reserve(t_vec_estr *vec, t_usize wanted_capacity) /// Return true if the vector is empty /// This function is safe to call with value being NULL -t_error vec_estr_pop(t_vec_estr *vec, t_expandable_str *value) +t_error vec_estr_pop(t_vec_estr *vec, t_expandable_str *value) { - t_expandable_str temp_value; - t_expandable_str *ptr; + t_expandable_str temp_value; + t_expandable_str *ptr; if (vec == NULL || vec->len == 0) return (ERROR); @@ -77,10 +76,10 @@ t_error vec_estr_pop(t_vec_estr *vec, t_expandable_str *value) } /// This function is safe to call with `free_elem` being NULL -void vec_estr_free(t_vec_estr vec) +void vec_estr_free(t_vec_estr vec) { if (vec.buffer == NULL) - return; + return ; if (vec.free_func) { while (vec.len) diff --git a/output/src/vec/estr/estr_functions2.c b/output/src/vec/estr/estr_functions2.c index 99f4c9ce..9bd3f2c2 100644 --- a/output/src/vec/estr/estr_functions2.c +++ b/output/src/vec/estr/estr_functions2.c @@ -10,17 +10,15 @@ /* */ /* ************************************************************************** */ -#include "me/mem/mem.h" -#include "me/mem/mem.h" #include "me/mem/mem.h" #include "me/types.h" #include "me/vec/vec_estr.h" #include -t_error vec_estr_find(t_vec_estr *vec, - bool (*fn)(const t_expandable_str *), t_usize *index) +t_error vec_estr_find(t_vec_estr *vec, bool (*fn)(const t_expandable_str *), + t_usize *index) { - t_usize idx; + t_usize idx; if (vec == NULL || fn == NULL || index == NULL) return (ERROR); @@ -37,11 +35,11 @@ t_error vec_estr_find(t_vec_estr *vec, return (ERROR); } -t_error vec_estr_find_starting(t_vec_estr *vec, - bool (*fn)(const t_expandable_str *), - t_usize starting_index, t_usize *index) +t_error vec_estr_find_starting(t_vec_estr *vec, + bool (*fn)(const t_expandable_str *), t_usize starting_index, + t_usize *index) { - t_usize idx; + t_usize idx; if (vec == NULL || fn == NULL || index == NULL) return (ERROR); @@ -58,10 +56,10 @@ t_error vec_estr_find_starting(t_vec_estr *vec, return (ERROR); } -t_error vec_estr_all(t_vec_estr *vec, - bool (*fn)(const t_expandable_str *), bool *result) +t_error vec_estr_all(t_vec_estr *vec, bool (*fn)(const t_expandable_str *), + bool *result) { - t_usize idx; + t_usize idx; if (vec == NULL || fn == NULL || result == NULL) return (ERROR); @@ -76,10 +74,10 @@ t_error vec_estr_all(t_vec_estr *vec, return (ERROR); } -t_error vec_estr_any(t_vec_estr *vec, - bool (*fn)(const t_expandable_str *), bool *result) +t_error vec_estr_any(t_vec_estr *vec, bool (*fn)(const t_expandable_str *), + bool *result) { - t_usize idx; + t_usize idx; if (vec == NULL || fn == NULL || result == NULL) return (ERROR); @@ -94,15 +92,13 @@ t_error vec_estr_any(t_vec_estr *vec, return (ERROR); } -void vec_estr_iter(t_vec_estr *vec, - void (*fn)(t_usize index, t_expandable_str *value, - void *state), - void *state) +void vec_estr_iter(t_vec_estr *vec, void (*fn)(t_usize index, + t_expandable_str *value, void *state), void *state) { - t_usize idx; + t_usize idx; if (vec == NULL || fn == NULL) - return; + return ; idx = 0; while (idx < vec->len) { diff --git a/output/src/vec/estr/estr_functions3.c b/output/src/vec/estr/estr_functions3.c index 1c242739..66fbc606 100644 --- a/output/src/vec/estr/estr_functions3.c +++ b/output/src/vec/estr/estr_functions3.c @@ -15,16 +15,15 @@ #include "me/vec/vec_estr.h" #include -t_error vec_estr_push_front(t_vec_estr *vec, - t_expandable_str element) +t_error vec_estr_push_front(t_vec_estr *vec, t_expandable_str element) { - t_usize i; + t_usize i; if (vec->len == 0) return (vec_estr_push(vec, element)); i = vec->len - 1; - if (vec->capacity < vec->len + 1 && - vec_estr_reserve(vec, 3 * vec->len / 2 + 1)) + if (vec->capacity < vec->len + 1 && vec_estr_reserve(vec, 3 * vec->len / 2 + + 1)) return (ERROR); while (i > 0) { @@ -37,9 +36,9 @@ t_error vec_estr_push_front(t_vec_estr *vec, return (NO_ERROR); } -t_error vec_estr_pop_front(t_vec_estr *vec, t_expandable_str *value) +t_error vec_estr_pop_front(t_vec_estr *vec, t_expandable_str *value) { - t_usize i; + t_usize i; if (vec->len <= 1) return (vec_estr_pop(vec, value)); @@ -55,10 +54,10 @@ t_error vec_estr_pop_front(t_vec_estr *vec, t_expandable_str *value) return (NO_ERROR); } -void vec_estr_reverse(t_vec_estr *vec) +void vec_estr_reverse(t_vec_estr *vec) { - t_expandable_str temporary; - t_usize i; + t_expandable_str temporary; + t_usize i; i = 0; while (i < vec->len / 2) @@ -70,9 +69,9 @@ void vec_estr_reverse(t_vec_estr *vec) } } -t_error vec_estr_back(t_vec_estr *vec, t_expandable_str **out) +t_error vec_estr_back(t_vec_estr *vec, t_expandable_str **out) { - t_expandable_str *temporary; + t_expandable_str *temporary; if (out == NULL) out = &temporary; diff --git a/output/src/vec/estr/estr_functions4.c b/output/src/vec/estr/estr_functions4.c index 25e10dbf..f2e786d2 100644 --- a/output/src/vec/estr/estr_functions4.c +++ b/output/src/vec/estr/estr_functions4.c @@ -15,7 +15,7 @@ #include "me/vec/vec_estr.h" #include -t_expandable_str *vec_estr_get(t_vec_estr *vec, t_usize i) +t_expandable_str *vec_estr_get(t_vec_estr *vec, t_usize i) { if (vec == NULL || vec->buffer == NULL) return (NULL); @@ -24,14 +24,14 @@ t_expandable_str *vec_estr_get(t_vec_estr *vec, t_usize i) return (NULL); } -t_expandable_str *vec_estr_last(t_vec_estr *vec) +t_expandable_str *vec_estr_last(t_vec_estr *vec) { if (vec == NULL || vec->len == 0) return (NULL); return (&vec->buffer[vec->len - 1]); } -void vec_estr_copy_into(t_vec_estr *vec, t_vec_estr *dest) +void vec_estr_copy_into(t_vec_estr *vec, t_vec_estr *dest) { if (vec == NULL || dest == NULL) return ; @@ -39,21 +39,20 @@ void vec_estr_copy_into(t_vec_estr *vec, t_vec_estr *dest) mem_copy(dest->buffer, vec->buffer, vec->len * sizeof(t_expandable_str)); } -struct s_vec_estr_splice_arguments vec_estr_splice_args( - t_usize index, t_usize old_count, t_usize new_count, - const t_expandable_str *elements) +struct s_vec_estr_splice_arguments vec_estr_splice_args(t_usize index, + t_usize old_count, t_usize new_count, const t_expandable_str *elements) { - return ((struct s_vec_estr_splice_arguments){index, old_count, - new_count, elements}); + return ((struct s_vec_estr_splice_arguments){index, old_count, new_count, + elements}); } -void vec_estr_splice(t_vec_estr *self, - struct s_vec_estr_splice_arguments args) +void vec_estr_splice(t_vec_estr *self, + struct s_vec_estr_splice_arguments args) { - t_expandable_str *contents; - t_u32 new_size; - t_u32 old_end; - t_u32 new_end; + t_expandable_str *contents; + t_u32 new_size; + t_u32 old_end; + t_u32 new_end; new_size = self->len + args.new_count - args.old_count; old_end = args.index + args.old_count; @@ -61,17 +60,16 @@ void vec_estr_splice(t_vec_estr *self, vec_estr_reserve(self, new_size); contents = self->buffer; if (self->len > old_end) - mem_move(contents + new_end, - contents + old_end, - (self->len - old_end) * sizeof(t_expandable_str)); + mem_move(contents + new_end, contents + old_end, (self->len - old_end) + * sizeof(t_expandable_str)); if (args.new_count > 0) { if (args.elements) mem_copy((contents + args.index * sizeof(t_expandable_str)), - args.elements, args.new_count * sizeof(t_expandable_str)); + args.elements, args.new_count * sizeof(t_expandable_str)); else mem_set_zero((contents + args.index * sizeof(t_expandable_str)), - args.new_count * sizeof(t_expandable_str)); + args.new_count * sizeof(t_expandable_str)); } self->len += args.new_count - args.old_count; } diff --git a/output/src/vec/estr/estr_sort.c b/output/src/vec/estr/estr_sort.c index 9a077e0e..6774643e 100644 --- a/output/src/vec/estr/estr_sort.c +++ b/output/src/vec/estr/estr_sort.c @@ -13,15 +13,14 @@ #include "me/types.h" #include "me/vec/vec_estr.h" -void vec_estr_sort(t_vec_estr *v, - t_vec_estr_sort_fn is_sorted_fn) +void vec_estr_sort(t_vec_estr *v, t_vec_estr_sort_fn is_sorted_fn) { - t_usize sorted_part; - t_usize i; - t_expandable_str tmp; + t_usize sorted_part; + t_usize i; + t_expandable_str tmp; if (v == NULL) - return; + return ; sorted_part = v->len; while (sorted_part > 0) { diff --git a/output/src/vec/pid/pid.c b/output/src/vec/pid/pid.c index 05303095..8a6bafd3 100644 --- a/output/src/vec/pid/pid.c +++ b/output/src/vec/pid/pid.c @@ -15,10 +15,9 @@ #include "me/vec/vec_pid.h" #include -t_vec_pid vec_pid_new(t_usize capacity, - t_free_pid_item free_function) +t_vec_pid vec_pid_new(t_usize capacity, t_free_pid_item free_function) { - t_vec_pid out; + t_vec_pid out; out = (t_vec_pid){0}; out.free_func = free_function; @@ -29,7 +28,7 @@ t_vec_pid vec_pid_new(t_usize capacity, } /// Return true in case of an error -t_error vec_pid_push(t_vec_pid *vec, t_pid element) +t_error vec_pid_push(t_vec_pid *vec, t_pid element) { if (vec == NULL) return (ERROR); @@ -40,9 +39,9 @@ t_error vec_pid_push(t_vec_pid *vec, t_pid element) } /// Return true in case of an error -t_error vec_pid_reserve(t_vec_pid *vec, t_usize wanted_capacity) +t_error vec_pid_reserve(t_vec_pid *vec, t_usize wanted_capacity) { - size_t new_capacity; + size_t new_capacity; if (vec == NULL) return (ERROR); @@ -51,8 +50,8 @@ t_error vec_pid_reserve(t_vec_pid *vec, t_usize wanted_capacity) new_capacity = (vec->capacity * 3) / 2 + 1; while (wanted_capacity > new_capacity) new_capacity = (new_capacity * 3) / 2 + 1; - vec->buffer = - mem_realloc_array(vec->buffer, new_capacity, sizeof(t_pid)); + vec->buffer = mem_realloc_array(vec->buffer, new_capacity, + sizeof(t_pid)); vec->capacity = new_capacity; } return (NO_ERROR); @@ -60,10 +59,10 @@ t_error vec_pid_reserve(t_vec_pid *vec, t_usize wanted_capacity) /// Return true if the vector is empty /// This function is safe to call with value being NULL -t_error vec_pid_pop(t_vec_pid *vec, t_pid *value) +t_error vec_pid_pop(t_vec_pid *vec, t_pid *value) { - t_pid temp_value; - t_pid *ptr; + t_pid temp_value; + t_pid *ptr; if (vec == NULL || vec->len == 0) return (ERROR); @@ -77,10 +76,10 @@ t_error vec_pid_pop(t_vec_pid *vec, t_pid *value) } /// This function is safe to call with `free_elem` being NULL -void vec_pid_free(t_vec_pid vec) +void vec_pid_free(t_vec_pid vec) { if (vec.buffer == NULL) - return; + return ; if (vec.free_func) { while (vec.len) diff --git a/output/src/vec/pid/pid_functions2.c b/output/src/vec/pid/pid_functions2.c index e6a59d29..116f4e52 100644 --- a/output/src/vec/pid/pid_functions2.c +++ b/output/src/vec/pid/pid_functions2.c @@ -10,17 +10,14 @@ /* */ /* ************************************************************************** */ -#include "me/mem/mem.h" -#include "me/mem/mem.h" #include "me/mem/mem.h" #include "me/types.h" #include "me/vec/vec_pid.h" #include -t_error vec_pid_find(t_vec_pid *vec, - bool (*fn)(const t_pid *), t_usize *index) +t_error vec_pid_find(t_vec_pid *vec, bool (*fn)(const t_pid *), t_usize *index) { - t_usize idx; + t_usize idx; if (vec == NULL || fn == NULL || index == NULL) return (ERROR); @@ -37,11 +34,10 @@ t_error vec_pid_find(t_vec_pid *vec, return (ERROR); } -t_error vec_pid_find_starting(t_vec_pid *vec, - bool (*fn)(const t_pid *), - t_usize starting_index, t_usize *index) +t_error vec_pid_find_starting(t_vec_pid *vec, bool (*fn)(const t_pid *), + t_usize starting_index, t_usize *index) { - t_usize idx; + t_usize idx; if (vec == NULL || fn == NULL || index == NULL) return (ERROR); @@ -58,10 +54,9 @@ t_error vec_pid_find_starting(t_vec_pid *vec, return (ERROR); } -t_error vec_pid_all(t_vec_pid *vec, - bool (*fn)(const t_pid *), bool *result) +t_error vec_pid_all(t_vec_pid *vec, bool (*fn)(const t_pid *), bool *result) { - t_usize idx; + t_usize idx; if (vec == NULL || fn == NULL || result == NULL) return (ERROR); @@ -76,10 +71,9 @@ t_error vec_pid_all(t_vec_pid *vec, return (ERROR); } -t_error vec_pid_any(t_vec_pid *vec, - bool (*fn)(const t_pid *), bool *result) +t_error vec_pid_any(t_vec_pid *vec, bool (*fn)(const t_pid *), bool *result) { - t_usize idx; + t_usize idx; if (vec == NULL || fn == NULL || result == NULL) return (ERROR); @@ -94,15 +88,13 @@ t_error vec_pid_any(t_vec_pid *vec, return (ERROR); } -void vec_pid_iter(t_vec_pid *vec, - void (*fn)(t_usize index, t_pid *value, - void *state), - void *state) +void vec_pid_iter(t_vec_pid *vec, void (*fn)(t_usize index, t_pid *value, + void *state), void *state) { - t_usize idx; + t_usize idx; if (vec == NULL || fn == NULL) - return; + return ; idx = 0; while (idx < vec->len) { diff --git a/output/src/vec/pid/pid_functions3.c b/output/src/vec/pid/pid_functions3.c index 5e7dab79..5192b238 100644 --- a/output/src/vec/pid/pid_functions3.c +++ b/output/src/vec/pid/pid_functions3.c @@ -15,16 +15,15 @@ #include "me/vec/vec_pid.h" #include -t_error vec_pid_push_front(t_vec_pid *vec, - t_pid element) +t_error vec_pid_push_front(t_vec_pid *vec, t_pid element) { - t_usize i; + t_usize i; if (vec->len == 0) return (vec_pid_push(vec, element)); i = vec->len - 1; - if (vec->capacity < vec->len + 1 && - vec_pid_reserve(vec, 3 * vec->len / 2 + 1)) + if (vec->capacity < vec->len + 1 && vec_pid_reserve(vec, 3 * vec->len / 2 + + 1)) return (ERROR); while (i > 0) { @@ -37,9 +36,9 @@ t_error vec_pid_push_front(t_vec_pid *vec, return (NO_ERROR); } -t_error vec_pid_pop_front(t_vec_pid *vec, t_pid *value) +t_error vec_pid_pop_front(t_vec_pid *vec, t_pid *value) { - t_usize i; + t_usize i; if (vec->len <= 1) return (vec_pid_pop(vec, value)); @@ -55,10 +54,10 @@ t_error vec_pid_pop_front(t_vec_pid *vec, t_pid *value) return (NO_ERROR); } -void vec_pid_reverse(t_vec_pid *vec) +void vec_pid_reverse(t_vec_pid *vec) { - t_pid temporary; - t_usize i; + t_pid temporary; + t_usize i; i = 0; while (i < vec->len / 2) @@ -70,9 +69,9 @@ void vec_pid_reverse(t_vec_pid *vec) } } -t_error vec_pid_back(t_vec_pid *vec, t_pid **out) +t_error vec_pid_back(t_vec_pid *vec, t_pid **out) { - t_pid *temporary; + t_pid *temporary; if (out == NULL) out = &temporary; diff --git a/output/src/vec/pid/pid_functions4.c b/output/src/vec/pid/pid_functions4.c index 8fbf49bd..99de8bb9 100644 --- a/output/src/vec/pid/pid_functions4.c +++ b/output/src/vec/pid/pid_functions4.c @@ -15,7 +15,7 @@ #include "me/vec/vec_pid.h" #include -t_pid *vec_pid_get(t_vec_pid *vec, t_usize i) +t_pid *vec_pid_get(t_vec_pid *vec, t_usize i) { if (vec == NULL || vec->buffer == NULL) return (NULL); @@ -24,14 +24,14 @@ t_pid *vec_pid_get(t_vec_pid *vec, t_usize i) return (NULL); } -t_pid *vec_pid_last(t_vec_pid *vec) +t_pid *vec_pid_last(t_vec_pid *vec) { if (vec == NULL || vec->len == 0) return (NULL); return (&vec->buffer[vec->len - 1]); } -void vec_pid_copy_into(t_vec_pid *vec, t_vec_pid *dest) +void vec_pid_copy_into(t_vec_pid *vec, t_vec_pid *dest) { if (vec == NULL || dest == NULL) return ; @@ -39,21 +39,19 @@ void vec_pid_copy_into(t_vec_pid *vec, t_vec_pid *dest) mem_copy(dest->buffer, vec->buffer, vec->len * sizeof(t_pid)); } -struct s_vec_pid_splice_arguments vec_pid_splice_args( - t_usize index, t_usize old_count, t_usize new_count, - const t_pid *elements) +struct s_vec_pid_splice_arguments vec_pid_splice_args(t_usize index, + t_usize old_count, t_usize new_count, const t_pid *elements) { - return ((struct s_vec_pid_splice_arguments){index, old_count, - new_count, elements}); + return ((struct s_vec_pid_splice_arguments){index, old_count, new_count, + elements}); } -void vec_pid_splice(t_vec_pid *self, - struct s_vec_pid_splice_arguments args) +void vec_pid_splice(t_vec_pid *self, struct s_vec_pid_splice_arguments args) { - t_pid *contents; - t_u32 new_size; - t_u32 old_end; - t_u32 new_end; + t_pid *contents; + t_u32 new_size; + t_u32 old_end; + t_u32 new_end; new_size = self->len + args.new_count - args.old_count; old_end = args.index + args.old_count; @@ -61,17 +59,16 @@ void vec_pid_splice(t_vec_pid *self, vec_pid_reserve(self, new_size); contents = self->buffer; if (self->len > old_end) - mem_move(contents + new_end, - contents + old_end, - (self->len - old_end) * sizeof(t_pid)); + mem_move(contents + new_end, contents + old_end, (self->len - old_end) + * sizeof(t_pid)); if (args.new_count > 0) { if (args.elements) - mem_copy((contents + args.index * sizeof(t_pid)), - args.elements, args.new_count * sizeof(t_pid)); + mem_copy((contents + args.index * sizeof(t_pid)), args.elements, + args.new_count * sizeof(t_pid)); else - mem_set_zero((contents + args.index * sizeof(t_pid)), - args.new_count * sizeof(t_pid)); + mem_set_zero((contents + args.index * sizeof(t_pid)), args.new_count + * sizeof(t_pid)); } self->len += args.new_count - args.old_count; } diff --git a/output/src/vec/pid/pid_sort.c b/output/src/vec/pid/pid_sort.c index 2ca1ffd8..d350851c 100644 --- a/output/src/vec/pid/pid_sort.c +++ b/output/src/vec/pid/pid_sort.c @@ -13,15 +13,14 @@ #include "me/types.h" #include "me/vec/vec_pid.h" -void vec_pid_sort(t_vec_pid *v, - t_vec_pid_sort_fn is_sorted_fn) +void vec_pid_sort(t_vec_pid *v, t_vec_pid_sort_fn is_sorted_fn) { - t_usize sorted_part; - t_usize i; - t_pid tmp; + t_usize sorted_part; + t_usize i; + t_pid tmp; if (v == NULL) - return; + return ; sorted_part = v->len; while (sorted_part > 0) { diff --git a/output/src/vec/reduce_action/reduce_action.c b/output/src/vec/reduce_action/reduce_action.c index e97b4804..63701dd6 100644 --- a/output/src/vec/reduce_action/reduce_action.c +++ b/output/src/vec/reduce_action/reduce_action.c @@ -1,12 +1,12 @@ /* ************************************************************************** */ /* */ /* ::: :::::::: */ -/* vec_reduce_action.c :+: :+: :+: */ +/* reduce_action.c :+: :+: :+: */ /* +:+ +:+ +:+ */ /* By: maiboyer +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2023/12/05 18:46:28 by maiboyer #+# #+# */ -/* Updated: 2023/12/09 17:54:11 by maiboyer ### ########.fr */ +/* Updated: 2024/09/19 17:50:33 by maiboyer ### ########.fr */ /* */ /* ************************************************************************** */ @@ -15,21 +15,22 @@ #include "me/vec/vec_reduce_action.h" #include -t_vec_reduce_action vec_reduce_action_new(t_usize capacity, - t_free_reduce_action_item free_function) +t_vec_reduce_action vec_reduce_action_new(t_usize capacity, + t_free_reduce_action_item free_function) { - t_vec_reduce_action out; + t_vec_reduce_action out; out = (t_vec_reduce_action){0}; out.free_func = free_function; - out.buffer = mem_alloc_array(capacity, sizeof(t_reduce_action)); + out.buffer = mem_alloc_array(capacity, sizeof(*out.buffer)); if (out.buffer) out.capacity = capacity; return (out); } /// Return true in case of an error -t_error vec_reduce_action_push(t_vec_reduce_action *vec, t_reduce_action element) +t_error vec_reduce_action_push(t_vec_reduce_action *vec, + t_reduce_action element) { if (vec == NULL) return (ERROR); @@ -40,9 +41,10 @@ t_error vec_reduce_action_push(t_vec_reduce_action *vec, t_reduce_action element } /// Return true in case of an error -t_error vec_reduce_action_reserve(t_vec_reduce_action *vec, t_usize wanted_capacity) +t_error vec_reduce_action_reserve(t_vec_reduce_action *vec, + t_usize wanted_capacity) { - size_t new_capacity; + size_t new_capacity; if (vec == NULL) return (ERROR); @@ -51,8 +53,8 @@ t_error vec_reduce_action_reserve(t_vec_reduce_action *vec, t_usize wanted_capac new_capacity = (vec->capacity * 3) / 2 + 1; while (wanted_capacity > new_capacity) new_capacity = (new_capacity * 3) / 2 + 1; - vec->buffer = - mem_realloc_array(vec->buffer, new_capacity, sizeof(t_reduce_action)); + vec->buffer = mem_realloc_array(vec->buffer, new_capacity, + sizeof(t_reduce_action)); vec->capacity = new_capacity; } return (NO_ERROR); @@ -60,10 +62,10 @@ t_error vec_reduce_action_reserve(t_vec_reduce_action *vec, t_usize wanted_capac /// Return true if the vector is empty /// This function is safe to call with value being NULL -t_error vec_reduce_action_pop(t_vec_reduce_action *vec, t_reduce_action *value) +t_error vec_reduce_action_pop(t_vec_reduce_action *vec, t_reduce_action *value) { - t_reduce_action temp_value; - t_reduce_action *ptr; + t_reduce_action temp_value; + t_reduce_action *ptr; if (vec == NULL || vec->len == 0) return (ERROR); @@ -77,10 +79,10 @@ t_error vec_reduce_action_pop(t_vec_reduce_action *vec, t_reduce_action *value) } /// This function is safe to call with `free_elem` being NULL -void vec_reduce_action_free(t_vec_reduce_action vec) +void vec_reduce_action_free(t_vec_reduce_action vec) { if (vec.buffer == NULL) - return; + return ; if (vec.free_func) { while (vec.len) diff --git a/output/src/vec/reduce_action/reduce_action_functions2.c b/output/src/vec/reduce_action/reduce_action_functions2.c index 3fdfcebb..fc96fec1 100644 --- a/output/src/vec/reduce_action/reduce_action_functions2.c +++ b/output/src/vec/reduce_action/reduce_action_functions2.c @@ -1,26 +1,24 @@ /* ************************************************************************** */ /* */ /* ::: :::::::: */ -/* vec_reduce_action.c :+: :+: :+: */ +/* reduce_action_functions2.c :+: :+: :+: */ /* +:+ +:+ +:+ */ /* By: maiboyer +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2023/12/30 17:59:28 by maiboyer #+# #+# */ -/* Updated: 2023/12/30 17:59:28 by maiboyer ### ########.fr */ +/* Updated: 2024/09/19 17:50:57 by maiboyer ### ########.fr */ /* */ /* ************************************************************************** */ -#include "me/mem/mem.h" -#include "me/mem/mem.h" #include "me/mem/mem.h" #include "me/types.h" #include "me/vec/vec_reduce_action.h" #include -t_error vec_reduce_action_find(t_vec_reduce_action *vec, - bool (*fn)(const t_reduce_action *), t_usize *index) +t_error vec_reduce_action_find(t_vec_reduce_action *vec, + bool (*fn)(const t_reduce_action *), t_usize *index) { - t_usize idx; + t_usize idx; if (vec == NULL || fn == NULL || index == NULL) return (ERROR); @@ -37,11 +35,11 @@ t_error vec_reduce_action_find(t_vec_reduce_action *vec, return (ERROR); } -t_error vec_reduce_action_find_starting(t_vec_reduce_action *vec, - bool (*fn)(const t_reduce_action *), - t_usize starting_index, t_usize *index) +t_error vec_reduce_action_find_starting(t_vec_reduce_action *vec, + bool (*fn)(const t_reduce_action *), t_usize starting_index, + t_usize *index) { - t_usize idx; + t_usize idx; if (vec == NULL || fn == NULL || index == NULL) return (ERROR); @@ -58,10 +56,10 @@ t_error vec_reduce_action_find_starting(t_vec_reduce_action *vec, return (ERROR); } -t_error vec_reduce_action_all(t_vec_reduce_action *vec, - bool (*fn)(const t_reduce_action *), bool *result) +t_error vec_reduce_action_all(t_vec_reduce_action *vec, + bool (*fn)(const t_reduce_action *), bool *result) { - t_usize idx; + t_usize idx; if (vec == NULL || fn == NULL || result == NULL) return (ERROR); @@ -76,10 +74,10 @@ t_error vec_reduce_action_all(t_vec_reduce_action *vec, return (ERROR); } -t_error vec_reduce_action_any(t_vec_reduce_action *vec, - bool (*fn)(const t_reduce_action *), bool *result) +t_error vec_reduce_action_any(t_vec_reduce_action *vec, + bool (*fn)(const t_reduce_action *), bool *result) { - t_usize idx; + t_usize idx; if (vec == NULL || fn == NULL || result == NULL) return (ERROR); @@ -94,15 +92,14 @@ t_error vec_reduce_action_any(t_vec_reduce_action *vec, return (ERROR); } -void vec_reduce_action_iter(t_vec_reduce_action *vec, - void (*fn)(t_usize index, t_reduce_action *value, - void *state), - void *state) +void vec_reduce_action_iter(t_vec_reduce_action *vec, + void (*fn)(t_usize index, t_reduce_action *value, void *state), + void *state) { - t_usize idx; + t_usize idx; if (vec == NULL || fn == NULL) - return; + return ; idx = 0; while (idx < vec->len) { diff --git a/output/src/vec/reduce_action/reduce_action_functions3.c b/output/src/vec/reduce_action/reduce_action_functions3.c index ab46793b..c9e581c4 100644 --- a/output/src/vec/reduce_action/reduce_action_functions3.c +++ b/output/src/vec/reduce_action/reduce_action_functions3.c @@ -1,7 +1,7 @@ /* ************************************************************************** */ /* */ /* ::: :::::::: */ -/* vec_reduce_action.c :+: :+: :+: */ +/* reduce_action_functions3.c :+: :+: :+: */ /* +:+ +:+ +:+ */ /* By: maiboyer +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ @@ -15,16 +15,16 @@ #include "me/vec/vec_reduce_action.h" #include -t_error vec_reduce_action_push_front(t_vec_reduce_action *vec, - t_reduce_action element) +t_error vec_reduce_action_push_front(t_vec_reduce_action *vec, + t_reduce_action element) { - t_usize i; + t_usize i; if (vec->len == 0) return (vec_reduce_action_push(vec, element)); i = vec->len - 1; - if (vec->capacity < vec->len + 1 && - vec_reduce_action_reserve(vec, 3 * vec->len / 2 + 1)) + if (vec->capacity < vec->len + 1 && vec_reduce_action_reserve(vec, 3 + * vec->len / 2 + 1)) return (ERROR); while (i > 0) { @@ -37,9 +37,10 @@ t_error vec_reduce_action_push_front(t_vec_reduce_action *vec, return (NO_ERROR); } -t_error vec_reduce_action_pop_front(t_vec_reduce_action *vec, t_reduce_action *value) +t_error vec_reduce_action_pop_front(t_vec_reduce_action *vec, + t_reduce_action *value) { - t_usize i; + t_usize i; if (vec->len <= 1) return (vec_reduce_action_pop(vec, value)); @@ -55,10 +56,10 @@ t_error vec_reduce_action_pop_front(t_vec_reduce_action *vec, t_reduce_action *v return (NO_ERROR); } -void vec_reduce_action_reverse(t_vec_reduce_action *vec) +void vec_reduce_action_reverse(t_vec_reduce_action *vec) { - t_reduce_action temporary; - t_usize i; + t_reduce_action temporary; + t_usize i; i = 0; while (i < vec->len / 2) @@ -70,9 +71,9 @@ void vec_reduce_action_reverse(t_vec_reduce_action *vec) } } -t_error vec_reduce_action_back(t_vec_reduce_action *vec, t_reduce_action **out) +t_error vec_reduce_action_back(t_vec_reduce_action *vec, t_reduce_action **out) { - t_reduce_action *temporary; + t_reduce_action *temporary; if (out == NULL) out = &temporary; diff --git a/output/src/vec/reduce_action/reduce_action_functions4.c b/output/src/vec/reduce_action/reduce_action_functions4.c index 78790127..9c152b5b 100644 --- a/output/src/vec/reduce_action/reduce_action_functions4.c +++ b/output/src/vec/reduce_action/reduce_action_functions4.c @@ -1,12 +1,12 @@ /* ************************************************************************** */ /* */ /* ::: :::::::: */ -/* vec_reduce_action.c :+: :+: :+: */ +/* reduce_action_functions4.c :+: :+: :+: */ /* +:+ +:+ +:+ */ /* By: maiboyer +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2023/12/30 17:59:28 by maiboyer #+# #+# */ -/* Updated: 2023/12/30 17:59:28 by maiboyer ### ########.fr */ +/* Updated: 2024/09/19 17:51:32 by maiboyer ### ########.fr */ /* */ /* ************************************************************************** */ @@ -15,7 +15,7 @@ #include "me/vec/vec_reduce_action.h" #include -t_reduce_action *vec_reduce_action_get(t_vec_reduce_action *vec, t_usize i) +t_reduce_action *vec_reduce_action_get(t_vec_reduce_action *vec, t_usize i) { if (vec == NULL || vec->buffer == NULL) return (NULL); @@ -24,14 +24,15 @@ t_reduce_action *vec_reduce_action_get(t_vec_reduce_action *vec, t_usize i) return (NULL); } -t_reduce_action *vec_reduce_action_last(t_vec_reduce_action *vec) +t_reduce_action *vec_reduce_action_last(t_vec_reduce_action *vec) { if (vec == NULL || vec->len == 0) return (NULL); return (&vec->buffer[vec->len - 1]); } -void vec_reduce_action_copy_into(t_vec_reduce_action *vec, t_vec_reduce_action *dest) +void vec_reduce_action_copy_into(t_vec_reduce_action *vec, + t_vec_reduce_action *dest) { if (vec == NULL || dest == NULL) return ; @@ -39,21 +40,21 @@ void vec_reduce_action_copy_into(t_vec_reduce_action *vec, t_vec_reduce_action * mem_copy(dest->buffer, vec->buffer, vec->len * sizeof(t_reduce_action)); } -struct s_vec_reduce_action_splice_arguments vec_reduce_action_splice_args( - t_usize index, t_usize old_count, t_usize new_count, - const t_reduce_action *elements) +struct s_vec_reduce_action_splice_arguments vec_reduce_action_splice_args(\ + t_usize index, \ + t_usize old_count, t_usize new_count, const t_reduce_action *elements) { return ((struct s_vec_reduce_action_splice_arguments){index, old_count, - new_count, elements}); + new_count, elements}); } -void vec_reduce_action_splice(t_vec_reduce_action *self, - struct s_vec_reduce_action_splice_arguments args) +void vec_reduce_action_splice(t_vec_reduce_action *self, + struct s_vec_reduce_action_splice_arguments args) { - t_reduce_action *contents; - t_u32 new_size; - t_u32 old_end; - t_u32 new_end; + t_reduce_action *contents; + t_u32 new_size; + t_u32 old_end; + t_u32 new_end; new_size = self->len + args.new_count - args.old_count; old_end = args.index + args.old_count; @@ -61,17 +62,16 @@ void vec_reduce_action_splice(t_vec_reduce_action *self, vec_reduce_action_reserve(self, new_size); contents = self->buffer; if (self->len > old_end) - mem_move(contents + new_end, - contents + old_end, - (self->len - old_end) * sizeof(t_reduce_action)); + mem_move(contents + new_end, contents + old_end, (self->len - old_end) + * sizeof(t_reduce_action)); if (args.new_count > 0) { if (args.elements) mem_copy((contents + args.index * sizeof(t_reduce_action)), - args.elements, args.new_count * sizeof(t_reduce_action)); + args.elements, args.new_count * sizeof(t_reduce_action)); else mem_set_zero((contents + args.index * sizeof(t_reduce_action)), - args.new_count * sizeof(t_reduce_action)); + args.new_count * sizeof(t_reduce_action)); } self->len += args.new_count - args.old_count; } diff --git a/output/src/vec/reduce_action/reduce_action_sort.c b/output/src/vec/reduce_action/reduce_action_sort.c index 459956bf..0fc29d29 100644 --- a/output/src/vec/reduce_action/reduce_action_sort.c +++ b/output/src/vec/reduce_action/reduce_action_sort.c @@ -1,7 +1,7 @@ /* ************************************************************************** */ /* */ /* ::: :::::::: */ -/* best_move.c :+: :+: :+: */ +/* reduce_action_sort.c :+: :+: :+: */ /* +:+ +:+ +:+ */ /* By: maiboyer +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ @@ -13,15 +13,15 @@ #include "me/types.h" #include "me/vec/vec_reduce_action.h" -void vec_reduce_action_sort(t_vec_reduce_action *v, - t_vec_reduce_action_sort_fn is_sorted_fn) +void vec_reduce_action_sort(t_vec_reduce_action *v, + t_vec_reduce_action_sort_fn is_sorted_fn) { - t_usize sorted_part; - t_usize i; - t_reduce_action tmp; + t_usize sorted_part; + t_usize i; + t_reduce_action tmp; if (v == NULL) - return; + return ; sorted_part = v->len; while (sorted_part > 0) { diff --git a/output/src/vec/str/str.c b/output/src/vec/str/str.c index fca3426b..79241558 100644 --- a/output/src/vec/str/str.c +++ b/output/src/vec/str/str.c @@ -15,10 +15,9 @@ #include "me/vec/vec_str.h" #include -t_vec_str vec_str_new(t_usize capacity, - t_free_str_item free_function) +t_vec_str vec_str_new(t_usize capacity, t_free_str_item free_function) { - t_vec_str out; + t_vec_str out; out = (t_vec_str){0}; out.free_func = free_function; @@ -29,7 +28,7 @@ t_vec_str vec_str_new(t_usize capacity, } /// Return true in case of an error -t_error vec_str_push(t_vec_str *vec, t_str element) +t_error vec_str_push(t_vec_str *vec, t_str element) { if (vec == NULL) return (ERROR); @@ -40,9 +39,9 @@ t_error vec_str_push(t_vec_str *vec, t_str element) } /// Return true in case of an error -t_error vec_str_reserve(t_vec_str *vec, t_usize wanted_capacity) +t_error vec_str_reserve(t_vec_str *vec, t_usize wanted_capacity) { - size_t new_capacity; + size_t new_capacity; if (vec == NULL) return (ERROR); @@ -51,8 +50,8 @@ t_error vec_str_reserve(t_vec_str *vec, t_usize wanted_capacity) new_capacity = (vec->capacity * 3) / 2 + 1; while (wanted_capacity > new_capacity) new_capacity = (new_capacity * 3) / 2 + 1; - vec->buffer = - mem_realloc_array(vec->buffer, new_capacity, sizeof(t_str)); + vec->buffer = mem_realloc_array(vec->buffer, new_capacity, + sizeof(t_str)); vec->capacity = new_capacity; } return (NO_ERROR); @@ -60,10 +59,10 @@ t_error vec_str_reserve(t_vec_str *vec, t_usize wanted_capacity) /// Return true if the vector is empty /// This function is safe to call with value being NULL -t_error vec_str_pop(t_vec_str *vec, t_str *value) +t_error vec_str_pop(t_vec_str *vec, t_str *value) { - t_str temp_value; - t_str *ptr; + t_str temp_value; + t_str *ptr; if (vec == NULL || vec->len == 0) return (ERROR); @@ -77,10 +76,10 @@ t_error vec_str_pop(t_vec_str *vec, t_str *value) } /// This function is safe to call with `free_elem` being NULL -void vec_str_free(t_vec_str vec) +void vec_str_free(t_vec_str vec) { if (vec.buffer == NULL) - return; + return ; if (vec.free_func) { while (vec.len) diff --git a/output/src/vec/str/str_functions2.c b/output/src/vec/str/str_functions2.c index af61b8e1..8a88ee3a 100644 --- a/output/src/vec/str/str_functions2.c +++ b/output/src/vec/str/str_functions2.c @@ -10,17 +10,14 @@ /* */ /* ************************************************************************** */ -#include "me/mem/mem.h" -#include "me/mem/mem.h" #include "me/mem/mem.h" #include "me/types.h" #include "me/vec/vec_str.h" #include -t_error vec_str_find(t_vec_str *vec, - bool (*fn)(const t_str *), t_usize *index) +t_error vec_str_find(t_vec_str *vec, bool (*fn)(const t_str *), t_usize *index) { - t_usize idx; + t_usize idx; if (vec == NULL || fn == NULL || index == NULL) return (ERROR); @@ -37,11 +34,10 @@ t_error vec_str_find(t_vec_str *vec, return (ERROR); } -t_error vec_str_find_starting(t_vec_str *vec, - bool (*fn)(const t_str *), - t_usize starting_index, t_usize *index) +t_error vec_str_find_starting(t_vec_str *vec, bool (*fn)(const t_str *), + t_usize starting_index, t_usize *index) { - t_usize idx; + t_usize idx; if (vec == NULL || fn == NULL || index == NULL) return (ERROR); @@ -58,10 +54,9 @@ t_error vec_str_find_starting(t_vec_str *vec, return (ERROR); } -t_error vec_str_all(t_vec_str *vec, - bool (*fn)(const t_str *), bool *result) +t_error vec_str_all(t_vec_str *vec, bool (*fn)(const t_str *), bool *result) { - t_usize idx; + t_usize idx; if (vec == NULL || fn == NULL || result == NULL) return (ERROR); @@ -76,10 +71,9 @@ t_error vec_str_all(t_vec_str *vec, return (ERROR); } -t_error vec_str_any(t_vec_str *vec, - bool (*fn)(const t_str *), bool *result) +t_error vec_str_any(t_vec_str *vec, bool (*fn)(const t_str *), bool *result) { - t_usize idx; + t_usize idx; if (vec == NULL || fn == NULL || result == NULL) return (ERROR); @@ -94,15 +88,13 @@ t_error vec_str_any(t_vec_str *vec, return (ERROR); } -void vec_str_iter(t_vec_str *vec, - void (*fn)(t_usize index, t_str *value, - void *state), - void *state) +void vec_str_iter(t_vec_str *vec, void (*fn)(t_usize index, t_str *value, + void *state), void *state) { - t_usize idx; + t_usize idx; if (vec == NULL || fn == NULL) - return; + return ; idx = 0; while (idx < vec->len) { diff --git a/output/src/vec/str/str_functions3.c b/output/src/vec/str/str_functions3.c index 9c34fdf9..dcd88550 100644 --- a/output/src/vec/str/str_functions3.c +++ b/output/src/vec/str/str_functions3.c @@ -15,16 +15,15 @@ #include "me/vec/vec_str.h" #include -t_error vec_str_push_front(t_vec_str *vec, - t_str element) +t_error vec_str_push_front(t_vec_str *vec, t_str element) { - t_usize i; + t_usize i; if (vec->len == 0) return (vec_str_push(vec, element)); i = vec->len - 1; - if (vec->capacity < vec->len + 1 && - vec_str_reserve(vec, 3 * vec->len / 2 + 1)) + if (vec->capacity < vec->len + 1 && vec_str_reserve(vec, 3 * vec->len / 2 + + 1)) return (ERROR); while (i > 0) { @@ -37,9 +36,9 @@ t_error vec_str_push_front(t_vec_str *vec, return (NO_ERROR); } -t_error vec_str_pop_front(t_vec_str *vec, t_str *value) +t_error vec_str_pop_front(t_vec_str *vec, t_str *value) { - t_usize i; + t_usize i; if (vec->len <= 1) return (vec_str_pop(vec, value)); @@ -55,10 +54,10 @@ t_error vec_str_pop_front(t_vec_str *vec, t_str *value) return (NO_ERROR); } -void vec_str_reverse(t_vec_str *vec) +void vec_str_reverse(t_vec_str *vec) { - t_str temporary; - t_usize i; + t_str temporary; + t_usize i; i = 0; while (i < vec->len / 2) @@ -70,9 +69,9 @@ void vec_str_reverse(t_vec_str *vec) } } -t_error vec_str_back(t_vec_str *vec, t_str **out) +t_error vec_str_back(t_vec_str *vec, t_str **out) { - t_str *temporary; + t_str *temporary; if (out == NULL) out = &temporary; diff --git a/output/src/vec/str/str_functions4.c b/output/src/vec/str/str_functions4.c index 4b4d16f2..4a8d527e 100644 --- a/output/src/vec/str/str_functions4.c +++ b/output/src/vec/str/str_functions4.c @@ -15,7 +15,7 @@ #include "me/vec/vec_str.h" #include -t_str *vec_str_get(t_vec_str *vec, t_usize i) +t_str *vec_str_get(t_vec_str *vec, t_usize i) { if (vec == NULL || vec->buffer == NULL) return (NULL); @@ -24,14 +24,14 @@ t_str *vec_str_get(t_vec_str *vec, t_usize i) return (NULL); } -t_str *vec_str_last(t_vec_str *vec) +t_str *vec_str_last(t_vec_str *vec) { if (vec == NULL || vec->len == 0) return (NULL); return (&vec->buffer[vec->len - 1]); } -void vec_str_copy_into(t_vec_str *vec, t_vec_str *dest) +void vec_str_copy_into(t_vec_str *vec, t_vec_str *dest) { if (vec == NULL || dest == NULL) return ; @@ -39,21 +39,19 @@ void vec_str_copy_into(t_vec_str *vec, t_vec_str *dest) mem_copy(dest->buffer, vec->buffer, vec->len * sizeof(t_str)); } -struct s_vec_str_splice_arguments vec_str_splice_args( - t_usize index, t_usize old_count, t_usize new_count, - const t_str *elements) +struct s_vec_str_splice_arguments vec_str_splice_args(t_usize index, + t_usize old_count, t_usize new_count, const t_str *elements) { - return ((struct s_vec_str_splice_arguments){index, old_count, - new_count, elements}); + return ((struct s_vec_str_splice_arguments){index, old_count, new_count, + elements}); } -void vec_str_splice(t_vec_str *self, - struct s_vec_str_splice_arguments args) +void vec_str_splice(t_vec_str *self, struct s_vec_str_splice_arguments args) { - t_str *contents; - t_u32 new_size; - t_u32 old_end; - t_u32 new_end; + t_str *contents; + t_u32 new_size; + t_u32 old_end; + t_u32 new_end; new_size = self->len + args.new_count - args.old_count; old_end = args.index + args.old_count; @@ -61,17 +59,16 @@ void vec_str_splice(t_vec_str *self, vec_str_reserve(self, new_size); contents = self->buffer; if (self->len > old_end) - mem_move(contents + new_end, - contents + old_end, - (self->len - old_end) * sizeof(t_str)); + mem_move(contents + new_end, contents + old_end, (self->len - old_end) + * sizeof(t_str)); if (args.new_count > 0) { if (args.elements) - mem_copy((contents + args.index * sizeof(t_str)), - args.elements, args.new_count * sizeof(t_str)); + mem_copy((contents + args.index * sizeof(t_str)), args.elements, + args.new_count * sizeof(t_str)); else - mem_set_zero((contents + args.index * sizeof(t_str)), - args.new_count * sizeof(t_str)); + mem_set_zero((contents + args.index * sizeof(t_str)), args.new_count + * sizeof(t_str)); } self->len += args.new_count - args.old_count; } diff --git a/output/src/vec/str/str_sort.c b/output/src/vec/str/str_sort.c index a37015ad..090b94fb 100644 --- a/output/src/vec/str/str_sort.c +++ b/output/src/vec/str/str_sort.c @@ -13,15 +13,14 @@ #include "me/types.h" #include "me/vec/vec_str.h" -void vec_str_sort(t_vec_str *v, - t_vec_str_sort_fn is_sorted_fn) +void vec_str_sort(t_vec_str *v, t_vec_str_sort_fn is_sorted_fn) { - t_usize sorted_part; - t_usize i; - t_str tmp; + t_usize sorted_part; + t_usize i; + t_str tmp; if (v == NULL) - return; + return ; sorted_part = v->len; while (sorted_part > 0) { diff --git a/output/src/vec/subtree/subtree.c b/output/src/vec/subtree/subtree.c index aa2e1e92..e34069be 100644 --- a/output/src/vec/subtree/subtree.c +++ b/output/src/vec/subtree/subtree.c @@ -15,10 +15,10 @@ #include "me/vec/vec_subtree.h" #include -t_vec_subtree vec_subtree_new(t_usize capacity, - t_free_subtree_item free_function) +t_vec_subtree vec_subtree_new(t_usize capacity, + t_free_subtree_item free_function) { - t_vec_subtree out; + t_vec_subtree out; out = (t_vec_subtree){0}; out.free_func = free_function; @@ -29,7 +29,7 @@ t_vec_subtree vec_subtree_new(t_usize capacity, } /// Return true in case of an error -t_error vec_subtree_push(t_vec_subtree *vec, t_subtree element) +t_error vec_subtree_push(t_vec_subtree *vec, t_subtree element) { if (vec == NULL) return (ERROR); @@ -40,9 +40,9 @@ t_error vec_subtree_push(t_vec_subtree *vec, t_subtree element) } /// Return true in case of an error -t_error vec_subtree_reserve(t_vec_subtree *vec, t_usize wanted_capacity) +t_error vec_subtree_reserve(t_vec_subtree *vec, t_usize wanted_capacity) { - size_t new_capacity; + size_t new_capacity; if (vec == NULL) return (ERROR); @@ -51,8 +51,8 @@ t_error vec_subtree_reserve(t_vec_subtree *vec, t_usize wanted_capacity) new_capacity = (vec->capacity * 3) / 2 + 1; while (wanted_capacity > new_capacity) new_capacity = (new_capacity * 3) / 2 + 1; - vec->buffer = - mem_realloc_array(vec->buffer, new_capacity, sizeof(t_subtree)); + vec->buffer = mem_realloc_array(vec->buffer, new_capacity, + sizeof(t_subtree)); vec->capacity = new_capacity; } return (NO_ERROR); @@ -60,10 +60,10 @@ t_error vec_subtree_reserve(t_vec_subtree *vec, t_usize wanted_capacity) /// Return true if the vector is empty /// This function is safe to call with value being NULL -t_error vec_subtree_pop(t_vec_subtree *vec, t_subtree *value) +t_error vec_subtree_pop(t_vec_subtree *vec, t_subtree *value) { - t_subtree temp_value; - t_subtree *ptr; + t_subtree temp_value; + t_subtree *ptr; if (vec == NULL || vec->len == 0) return (ERROR); @@ -77,10 +77,10 @@ t_error vec_subtree_pop(t_vec_subtree *vec, t_subtree *value) } /// This function is safe to call with `free_elem` being NULL -void vec_subtree_free(t_vec_subtree vec) +void vec_subtree_free(t_vec_subtree vec) { if (vec.buffer == NULL) - return; + return ; if (vec.free_func) { while (vec.len) diff --git a/output/src/vec/subtree/subtree_functions2.c b/output/src/vec/subtree/subtree_functions2.c index e994ea31..43ecd10b 100644 --- a/output/src/vec/subtree/subtree_functions2.c +++ b/output/src/vec/subtree/subtree_functions2.c @@ -10,17 +10,15 @@ /* */ /* ************************************************************************** */ -#include "me/mem/mem.h" -#include "me/mem/mem.h" #include "me/mem/mem.h" #include "me/types.h" #include "me/vec/vec_subtree.h" #include -t_error vec_subtree_find(t_vec_subtree *vec, - bool (*fn)(const t_subtree *), t_usize *index) +t_error vec_subtree_find(t_vec_subtree *vec, bool (*fn)(const t_subtree *), + t_usize *index) { - t_usize idx; + t_usize idx; if (vec == NULL || fn == NULL || index == NULL) return (ERROR); @@ -37,11 +35,10 @@ t_error vec_subtree_find(t_vec_subtree *vec, return (ERROR); } -t_error vec_subtree_find_starting(t_vec_subtree *vec, - bool (*fn)(const t_subtree *), - t_usize starting_index, t_usize *index) +t_error vec_subtree_find_starting(t_vec_subtree *vec, + bool (*fn)(const t_subtree *), t_usize starting_index, t_usize *index) { - t_usize idx; + t_usize idx; if (vec == NULL || fn == NULL || index == NULL) return (ERROR); @@ -58,10 +55,10 @@ t_error vec_subtree_find_starting(t_vec_subtree *vec, return (ERROR); } -t_error vec_subtree_all(t_vec_subtree *vec, - bool (*fn)(const t_subtree *), bool *result) +t_error vec_subtree_all(t_vec_subtree *vec, bool (*fn)(const t_subtree *), + bool *result) { - t_usize idx; + t_usize idx; if (vec == NULL || fn == NULL || result == NULL) return (ERROR); @@ -76,10 +73,10 @@ t_error vec_subtree_all(t_vec_subtree *vec, return (ERROR); } -t_error vec_subtree_any(t_vec_subtree *vec, - bool (*fn)(const t_subtree *), bool *result) +t_error vec_subtree_any(t_vec_subtree *vec, bool (*fn)(const t_subtree *), + bool *result) { - t_usize idx; + t_usize idx; if (vec == NULL || fn == NULL || result == NULL) return (ERROR); @@ -94,15 +91,13 @@ t_error vec_subtree_any(t_vec_subtree *vec, return (ERROR); } -void vec_subtree_iter(t_vec_subtree *vec, - void (*fn)(t_usize index, t_subtree *value, - void *state), - void *state) +void vec_subtree_iter(t_vec_subtree *vec, void (*fn)(t_usize index, + t_subtree *value, void *state), void *state) { - t_usize idx; + t_usize idx; if (vec == NULL || fn == NULL) - return; + return ; idx = 0; while (idx < vec->len) { diff --git a/output/src/vec/subtree/subtree_functions3.c b/output/src/vec/subtree/subtree_functions3.c index 7ef95490..a53d2de1 100644 --- a/output/src/vec/subtree/subtree_functions3.c +++ b/output/src/vec/subtree/subtree_functions3.c @@ -15,16 +15,15 @@ #include "me/vec/vec_subtree.h" #include -t_error vec_subtree_push_front(t_vec_subtree *vec, - t_subtree element) +t_error vec_subtree_push_front(t_vec_subtree *vec, t_subtree element) { - t_usize i; + t_usize i; if (vec->len == 0) return (vec_subtree_push(vec, element)); i = vec->len - 1; - if (vec->capacity < vec->len + 1 && - vec_subtree_reserve(vec, 3 * vec->len / 2 + 1)) + if (vec->capacity < vec->len + 1 && vec_subtree_reserve(vec, 3 * vec->len + / 2 + 1)) return (ERROR); while (i > 0) { @@ -37,9 +36,9 @@ t_error vec_subtree_push_front(t_vec_subtree *vec, return (NO_ERROR); } -t_error vec_subtree_pop_front(t_vec_subtree *vec, t_subtree *value) +t_error vec_subtree_pop_front(t_vec_subtree *vec, t_subtree *value) { - t_usize i; + t_usize i; if (vec->len <= 1) return (vec_subtree_pop(vec, value)); @@ -55,10 +54,10 @@ t_error vec_subtree_pop_front(t_vec_subtree *vec, t_subtree *value) return (NO_ERROR); } -void vec_subtree_reverse(t_vec_subtree *vec) +void vec_subtree_reverse(t_vec_subtree *vec) { - t_subtree temporary; - t_usize i; + t_subtree temporary; + t_usize i; i = 0; while (i < vec->len / 2) @@ -70,9 +69,9 @@ void vec_subtree_reverse(t_vec_subtree *vec) } } -t_error vec_subtree_back(t_vec_subtree *vec, t_subtree **out) +t_error vec_subtree_back(t_vec_subtree *vec, t_subtree **out) { - t_subtree *temporary; + t_subtree *temporary; if (out == NULL) out = &temporary; diff --git a/output/src/vec/subtree/subtree_functions4.c b/output/src/vec/subtree/subtree_functions4.c index 98bbddfd..a7c32563 100644 --- a/output/src/vec/subtree/subtree_functions4.c +++ b/output/src/vec/subtree/subtree_functions4.c @@ -15,7 +15,7 @@ #include "me/vec/vec_subtree.h" #include -t_subtree *vec_subtree_get(t_vec_subtree *vec, t_usize i) +t_subtree *vec_subtree_get(t_vec_subtree *vec, t_usize i) { if (vec == NULL || vec->buffer == NULL) return (NULL); @@ -24,14 +24,14 @@ t_subtree *vec_subtree_get(t_vec_subtree *vec, t_usize i) return (NULL); } -t_subtree *vec_subtree_last(t_vec_subtree *vec) +t_subtree *vec_subtree_last(t_vec_subtree *vec) { if (vec == NULL || vec->len == 0) return (NULL); return (&vec->buffer[vec->len - 1]); } -void vec_subtree_copy_into(t_vec_subtree *vec, t_vec_subtree *dest) +void vec_subtree_copy_into(t_vec_subtree *vec, t_vec_subtree *dest) { if (vec == NULL || dest == NULL) return ; @@ -39,21 +39,20 @@ void vec_subtree_copy_into(t_vec_subtree *vec, t_vec_subtree *dest) mem_copy(dest->buffer, vec->buffer, vec->len * sizeof(t_subtree)); } -struct s_vec_subtree_splice_arguments vec_subtree_splice_args( - t_usize index, t_usize old_count, t_usize new_count, - const t_subtree *elements) +struct s_vec_subtree_splice_arguments vec_subtree_splice_args(t_usize index, + t_usize old_count, t_usize new_count, const t_subtree *elements) { - return ((struct s_vec_subtree_splice_arguments){index, old_count, - new_count, elements}); + return ((struct s_vec_subtree_splice_arguments){index, old_count, new_count, + elements}); } -void vec_subtree_splice(t_vec_subtree *self, - struct s_vec_subtree_splice_arguments args) +void vec_subtree_splice(t_vec_subtree *self, + struct s_vec_subtree_splice_arguments args) { - t_subtree *contents; - t_u32 new_size; - t_u32 old_end; - t_u32 new_end; + t_subtree *contents; + t_u32 new_size; + t_u32 old_end; + t_u32 new_end; new_size = self->len + args.new_count - args.old_count; old_end = args.index + args.old_count; @@ -61,17 +60,16 @@ void vec_subtree_splice(t_vec_subtree *self, vec_subtree_reserve(self, new_size); contents = self->buffer; if (self->len > old_end) - mem_move(contents + new_end, - contents + old_end, - (self->len - old_end) * sizeof(t_subtree)); + mem_move(contents + new_end, contents + old_end, (self->len - old_end) + * sizeof(t_subtree)); if (args.new_count > 0) { if (args.elements) - mem_copy((contents + args.index * sizeof(t_subtree)), - args.elements, args.new_count * sizeof(t_subtree)); + mem_copy((contents + args.index * sizeof(t_subtree)), args.elements, + args.new_count * sizeof(t_subtree)); else mem_set_zero((contents + args.index * sizeof(t_subtree)), - args.new_count * sizeof(t_subtree)); + args.new_count * sizeof(t_subtree)); } self->len += args.new_count - args.old_count; } diff --git a/output/src/vec/subtree/subtree_sort.c b/output/src/vec/subtree/subtree_sort.c index 2d6b1a5c..2b64880d 100644 --- a/output/src/vec/subtree/subtree_sort.c +++ b/output/src/vec/subtree/subtree_sort.c @@ -13,15 +13,14 @@ #include "me/types.h" #include "me/vec/vec_subtree.h" -void vec_subtree_sort(t_vec_subtree *v, - t_vec_subtree_sort_fn is_sorted_fn) +void vec_subtree_sort(t_vec_subtree *v, t_vec_subtree_sort_fn is_sorted_fn) { - t_usize sorted_part; - t_usize i; - t_subtree tmp; + t_usize sorted_part; + t_usize i; + t_subtree tmp; if (v == NULL) - return; + return ; sorted_part = v->len; while (sorted_part > 0) {