update

gen.list

@@ -10,6 +10,3 @@ src/vec/parser_range/parser_range_functions3.c
 src/vec/reduce_action/reduce_action.c
 src/vec/reduce_action/reduce_action_functions2.c
 src/vec/reduce_action/reduce_action_functions3.c
-src/vec/str/str.c
-src/vec/str/str_functions2.c
-src/vec/str/str_functions3.c

input.toml

@@ -62,6 +62,14 @@ replace.C__TYPEHEADER__ = '#include "parser/types/types_reduce_action.h"'
 replace.C__PREFIX__ = "reduce_action"
 replace.C__PREFIXUP__ = "REDUCE_ACTION"
 
+[[create.vec]]
+sources_output = "src/vec/C__PREFIX__/"
+headers_output = "include/me/vec/"
+replace.C__TYPENAME__ = "t_str"
+replace.C__TYPEHEADER__ = ''
+replace.C__PREFIX__ = "str"
+replace.C__PREFIXUP__ = "STR"
+
 [[create.hashmap]]
 sources_output = "src/hashmap/C__PREFIX__/"
 headers_output = "include/me/hashmap/"

output/src/hashmap/env/env.c

@@ -32,9 +32,7 @@ t_hashmap_env *new_hashmap_with_buckets_env(
 	t_drop_env_fn drop, t_usize buckets)
 {
 	t_hashmap_env *hmap;
-	t_usize i;
 
-	i = 0;
 	hmap = mem_alloc(sizeof(*hmap));
 	if (hmap == NULL)
 		return (NULL);
@@ -46,8 +44,6 @@ t_hashmap_env *new_hashmap_with_buckets_env(
 	hmap->drop = drop;
 	if (hmap->buckets == NULL)
 		return ((void)me_free(hmap), NULL);
-	while (i < buckets)
-		hmap->buckets[i++] = NULL;
 	return (hmap);
 }
 

output/src/vec/parser_heredoc/parser_heredoc.c

@@ -14,6 +14,7 @@
 #include "me/mem/mem_copy.h"
 #include "me/mem/mem_set_zero.h"
 #include "me/types.h"
+#include "me/alloc/alloc.h"
 #include "me/vec/vec_parser_heredoc.h"
 #include <stdlib.h>
 
@@ -33,7 +34,6 @@ t_vec_parser_heredoc vec_parser_heredoc_new(t_usize				  capacity,
 /// Return true in case of an error
 t_error vec_parser_heredoc_push(t_vec_parser_heredoc *vec, t_heredoc element)
 {
-	t_heredoc *temp_buffer;
 	size_t		   new_capacity;
 
 	if (vec == NULL)
@@ -43,12 +43,7 @@ t_error vec_parser_heredoc_push(t_vec_parser_heredoc *vec, t_heredoc element)
 		new_capacity = (vec->capacity * 3) / 2 + 1;
 		while (vec->len + 1 > new_capacity)
 			new_capacity = (new_capacity * 3) / 2 + 1;
-		temp_buffer = mem_alloc_array(new_capacity, sizeof(t_heredoc));
+		vec->buffer = me_realloc(vec->buffer, new_capacity);
-		if (temp_buffer == NULL)
-			return (ERROR);
-		mem_copy(temp_buffer, vec->buffer, vec->len * sizeof(t_heredoc));
-		me_free(vec->buffer);
-		vec->buffer = temp_buffer;
 		vec->capacity = new_capacity;
 	}
 	vec->buffer[vec->len] = element;
@@ -59,7 +54,6 @@ t_error vec_parser_heredoc_push(t_vec_parser_heredoc *vec, t_heredoc element)
 /// Return true in case of an error
 t_error vec_parser_heredoc_reserve(t_vec_parser_heredoc *vec, t_usize wanted_capacity)
 {
-	t_heredoc *temp_buffer;
 	size_t		   new_capacity;
 
 	if (vec == NULL)
@@ -69,12 +63,7 @@ t_error vec_parser_heredoc_reserve(t_vec_parser_heredoc *vec, t_usize wanted_cap
 		new_capacity = (vec->capacity * 3) / 2 + 1;
 		while (wanted_capacity > new_capacity)
 			new_capacity = (new_capacity * 3) / 2 + 1;
-		temp_buffer = mem_alloc_array(new_capacity, sizeof(t_heredoc));
+		vec->buffer = me_realloc(vec->buffer, new_capacity);
-		if (temp_buffer == NULL)
-			return (ERROR);
-		mem_copy(temp_buffer, vec->buffer, vec->len * sizeof(t_heredoc));
-		me_free(vec->buffer);
-		vec->buffer = temp_buffer;
 		vec->capacity = new_capacity;
 	}
 	return (NO_ERROR);

output/src/vec/parser_range/parser_range.c

@@ -14,6 +14,7 @@
 #include "me/mem/mem_copy.h"
 #include "me/mem/mem_set_zero.h"
 #include "me/types.h"
+#include "me/alloc/alloc.h"
 #include "me/vec/vec_parser_range.h"
 #include <stdlib.h>
 
@@ -33,7 +34,6 @@ t_vec_parser_range vec_parser_range_new(t_usize				  capacity,
 /// Return true in case of an error
 t_error vec_parser_range_push(t_vec_parser_range *vec, t_parser_range element)
 {
-	t_parser_range *temp_buffer;
 	size_t		   new_capacity;
 
 	if (vec == NULL)
@@ -43,12 +43,7 @@ t_error vec_parser_range_push(t_vec_parser_range *vec, t_parser_range element)
 		new_capacity = (vec->capacity * 3) / 2 + 1;
 		while (vec->len + 1 > new_capacity)
 			new_capacity = (new_capacity * 3) / 2 + 1;
-		temp_buffer = mem_alloc_array(new_capacity, sizeof(t_parser_range));
+		vec->buffer = me_realloc(vec->buffer, new_capacity);
-		if (temp_buffer == NULL)
-			return (ERROR);
-		mem_copy(temp_buffer, vec->buffer, vec->len * sizeof(t_parser_range));
-		me_free(vec->buffer);
-		vec->buffer = temp_buffer;
 		vec->capacity = new_capacity;
 	}
 	vec->buffer[vec->len] = element;
@@ -59,7 +54,6 @@ t_error vec_parser_range_push(t_vec_parser_range *vec, t_parser_range element)
 /// Return true in case of an error
 t_error vec_parser_range_reserve(t_vec_parser_range *vec, t_usize wanted_capacity)
 {
-	t_parser_range *temp_buffer;
 	size_t		   new_capacity;
 
 	if (vec == NULL)
@@ -69,12 +63,7 @@ t_error vec_parser_range_reserve(t_vec_parser_range *vec, t_usize wanted_capacit
 		new_capacity = (vec->capacity * 3) / 2 + 1;
 		while (wanted_capacity > new_capacity)
 			new_capacity = (new_capacity * 3) / 2 + 1;
-		temp_buffer = mem_alloc_array(new_capacity, sizeof(t_parser_range));
+		vec->buffer = me_realloc(vec->buffer, new_capacity);
-		if (temp_buffer == NULL)
-			return (ERROR);
-		mem_copy(temp_buffer, vec->buffer, vec->len * sizeof(t_parser_range));
-		me_free(vec->buffer);
-		vec->buffer = temp_buffer;
 		vec->capacity = new_capacity;
 	}
 	return (NO_ERROR);

output/src/vec/reduce_action/reduce_action.c

@@ -14,6 +14,7 @@
 #include "me/mem/mem_copy.h"
 #include "me/mem/mem_set_zero.h"
 #include "me/types.h"
+#include "me/alloc/alloc.h"
 #include "me/vec/vec_reduce_action.h"
 #include <stdlib.h>
 
@@ -33,7 +34,6 @@ t_vec_reduce_action vec_reduce_action_new(t_usize				  capacity,
 /// Return true in case of an error
 t_error vec_reduce_action_push(t_vec_reduce_action *vec, t_reduce_action element)
 {
-	t_reduce_action *temp_buffer;
 	size_t		   new_capacity;
 
 	if (vec == NULL)
@@ -43,12 +43,7 @@ t_error vec_reduce_action_push(t_vec_reduce_action *vec, t_reduce_action element
 		new_capacity = (vec->capacity * 3) / 2 + 1;
 		while (vec->len + 1 > new_capacity)
 			new_capacity = (new_capacity * 3) / 2 + 1;
-		temp_buffer = mem_alloc_array(new_capacity, sizeof(t_reduce_action));
+		vec->buffer = me_realloc(vec->buffer, new_capacity);
-		if (temp_buffer == NULL)
-			return (ERROR);
-		mem_copy(temp_buffer, vec->buffer, vec->len * sizeof(t_reduce_action));
-		me_free(vec->buffer);
-		vec->buffer = temp_buffer;
 		vec->capacity = new_capacity;
 	}
 	vec->buffer[vec->len] = element;
@@ -59,7 +54,6 @@ 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_reduce_action *temp_buffer;
 	size_t		   new_capacity;
 
 	if (vec == NULL)
@@ -69,12 +63,7 @@ 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;
-		temp_buffer = mem_alloc_array(new_capacity, sizeof(t_reduce_action));
+		vec->buffer = me_realloc(vec->buffer, new_capacity);
-		if (temp_buffer == NULL)
-			return (ERROR);
-		mem_copy(temp_buffer, vec->buffer, vec->len * sizeof(t_reduce_action));
-		me_free(vec->buffer);
-		vec->buffer = temp_buffer;
 		vec->capacity = new_capacity;
 	}
 	return (NO_ERROR);

output/src/vec/str/str.c

@@ -14,6 +14,7 @@
 #include "me/mem/mem_copy.h"
 #include "me/mem/mem_set_zero.h"
 #include "me/types.h"
+#include "me/alloc/alloc.h"
 #include "me/vec/vec_str.h"
 #include <stdlib.h>
 
@@ -33,7 +34,6 @@ 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_str *temp_buffer;
 	size_t		   new_capacity;
 
 	if (vec == NULL)
@@ -43,12 +43,7 @@ t_error vec_str_push(t_vec_str *vec, t_str element)
 		new_capacity = (vec->capacity * 3) / 2 + 1;
 		while (vec->len + 1 > new_capacity)
 			new_capacity = (new_capacity * 3) / 2 + 1;
-		temp_buffer = mem_alloc_array(new_capacity, sizeof(t_str));
+		vec->buffer = me_realloc(vec->buffer, new_capacity);
-		if (temp_buffer == NULL)
-			return (ERROR);
-		mem_copy(temp_buffer, vec->buffer, vec->len * sizeof(t_str));
-		free(vec->buffer);
-		vec->buffer = temp_buffer;
 		vec->capacity = new_capacity;
 	}
 	vec->buffer[vec->len] = element;
@@ -59,7 +54,6 @@ 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_str *temp_buffer;
 	size_t		   new_capacity;
 
 	if (vec == NULL)
@@ -69,12 +63,7 @@ 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;
-		temp_buffer = mem_alloc_array(new_capacity, sizeof(t_str));
+		vec->buffer = me_realloc(vec->buffer, new_capacity);
-		if (temp_buffer == NULL)
-			return (ERROR);
-		mem_copy(temp_buffer, vec->buffer, vec->len * sizeof(t_str));
-		free(vec->buffer);
-		vec->buffer = temp_buffer;
 		vec->capacity = new_capacity;
 	}
 	return (NO_ERROR);
@@ -111,5 +100,5 @@ void vec_str_free(t_vec_str vec)
 			vec.len--;
 		}
 	}
-	free(vec.buffer);
+	me_free(vec.buffer);
 }

parser/src/api.h

@@ -39,7 +39,7 @@
 #define STACK_VERSION_NONE ((t_stack_version)-1)
 #define TS_DECODE_ERROR (-1)
 
-#if false
+#if true
 # undef malloc
 # undef calloc
 # undef realloc

sources/env.c

@@ -6,7 +6,7 @@
 /*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2024/05/04 18:32:50 by maiboyer          #+#    #+#             */
-/*   Updated: 2024/05/04 19:16:37 by maiboyer         ###   ########.fr       */
+/*   Updated: 2024/05/10 21:48:31 by maiboyer         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -62,7 +62,7 @@ t_error build_envp(t_hashmap_env *envs, t_vec_str *envp)
 {
 	struct s_build_envp_state state;
 
-	state.out = vec_str_new(envs->num_buckets, (void (*)(t_str))free);
+	state.out = vec_str_new(envs->num_buckets, (void (*)(t_str))me_free);
 	state.buf = alloc_new_buffer(50);
 	if (hashmap_env_iter(envs, _build_envp_iterator, &state))
 		return (ERROR);

sources/exec/handle_command.c

@@ -6,7 +6,7 @@
 /*   By: rparodi <marvin@42.fr>                     +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2024/05/09 15:00:53 by rparodi           #+#    #+#             */
-/*   Updated: 2024/05/09 17:14:32 by rparodi          ###   ########.fr       */
+/*   Updated: 2024/05/10 22:02:34 by maiboyer         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -28,7 +28,7 @@ t_error handle_command(t_node *self, t_utils *shcat, t_i32 *out_exit_code)
 	t_spawn_info spawn_info;
 	t_str tmp;
 
-	spawn_info.arguments = vec_str_new(self->childs_count, (void (*)(t_str))free);
+	spawn_info.arguments = vec_str_new(self->childs_count, (void (*)(t_str))me_free);
 	if (self->kind != sym_command)
 		 return (ERROR);
 	i = 0;

stdme/gen.list

@@ -23,12 +23,3 @@ vec/str/str_functions3
 vec/u8/u8
 vec/u8/u8_functions2
 vec/u8/u8_functions3
-vec/vec_buf_str
-vec/vec_buf_str_functions2
-vec/vec_buf_str_functions3
-vec/vec_str
-vec/vec_str_functions2
-vec/vec_str_functions3
-vec/vec_u8
-vec/vec_u8_functions2
-vec/vec_u8_functions3

stdme/generic_sources/src/vec/C__PREFIX__.c__TEMPLATE__

@@ -14,6 +14,7 @@
 #include "me/mem/mem_copy.h"
 #include "me/mem/mem_set_zero.h"
 #include "me/types.h"
+#include "me/alloc/alloc.h"
 #include "me/vec/vec_C__PREFIX__.h"
 #include <stdlib.h>
 
@@ -33,7 +34,6 @@ t_vec_C__PREFIX__ vec_C__PREFIX___new(t_usize				  capacity,
 /// Return true in case of an error
 t_error vec_C__PREFIX___push(t_vec_C__PREFIX__ *vec, C__TYPENAME__ element)
 {
-	C__TYPENAME__ *temp_buffer;
 	size_t		   new_capacity;
 
 	if (vec == NULL)
@@ -43,12 +43,7 @@ t_error vec_C__PREFIX___push(t_vec_C__PREFIX__ *vec, C__TYPENAME__ element)
 		new_capacity = (vec->capacity * 3) / 2 + 1;
 		while (vec->len + 1 > new_capacity)
 			new_capacity = (new_capacity * 3) / 2 + 1;
-		temp_buffer = mem_alloc_array(new_capacity, sizeof(C__TYPENAME__));
+		vec->buffer = me_realloc(vec->buffer, new_capacity);
-		if (temp_buffer == NULL)
-			return (ERROR);
-		mem_copy(temp_buffer, vec->buffer, vec->len * sizeof(C__TYPENAME__));
-		me_free(vec->buffer);
-		vec->buffer = temp_buffer;
 		vec->capacity = new_capacity;
 	}
 	vec->buffer[vec->len] = element;
@@ -59,7 +54,6 @@ t_error vec_C__PREFIX___push(t_vec_C__PREFIX__ *vec, C__TYPENAME__ element)
 /// Return true in case of an error
 t_error vec_C__PREFIX___reserve(t_vec_C__PREFIX__ *vec, t_usize wanted_capacity)
 {
-	C__TYPENAME__ *temp_buffer;
 	size_t		   new_capacity;
 
 	if (vec == NULL)
@@ -69,12 +63,7 @@ t_error vec_C__PREFIX___reserve(t_vec_C__PREFIX__ *vec, t_usize wanted_capacity)
 		new_capacity = (vec->capacity * 3) / 2 + 1;
 		while (wanted_capacity > new_capacity)
 			new_capacity = (new_capacity * 3) / 2 + 1;
-		temp_buffer = mem_alloc_array(new_capacity, sizeof(C__TYPENAME__));
+		vec->buffer = me_realloc(vec->buffer, new_capacity);
-		if (temp_buffer == NULL)
-			return (ERROR);
-		mem_copy(temp_buffer, vec->buffer, vec->len * sizeof(C__TYPENAME__));
-		me_free(vec->buffer);
-		vec->buffer = temp_buffer;
 		vec->capacity = new_capacity;
 	}
 	return (NO_ERROR);

stdme/output/src/vec/buf_str/buf_str.c

@@ -14,6 +14,7 @@
 #include "me/mem/mem_copy.h"
 #include "me/mem/mem_set_zero.h"
 #include "me/types.h"
+#include "me/alloc/alloc.h"
 #include "me/vec/vec_buf_str.h"
 #include <stdlib.h>
 
@@ -33,7 +34,6 @@ t_vec_buf_str vec_buf_str_new(t_usize				  capacity,
 /// Return true in case of an error
 t_error vec_buf_str_push(t_vec_buf_str *vec, t_buffer_str element)
 {
-	t_buffer_str *temp_buffer;
 	size_t		   new_capacity;
 
 	if (vec == NULL)
@@ -43,12 +43,7 @@ t_error vec_buf_str_push(t_vec_buf_str *vec, t_buffer_str element)
 		new_capacity = (vec->capacity * 3) / 2 + 1;
 		while (vec->len + 1 > new_capacity)
 			new_capacity = (new_capacity * 3) / 2 + 1;
-		temp_buffer = mem_alloc_array(new_capacity, sizeof(t_buffer_str));
+		vec->buffer = me_realloc(vec->buffer, new_capacity);
-		if (temp_buffer == NULL)
-			return (ERROR);
-		mem_copy(temp_buffer, vec->buffer, vec->len * sizeof(t_buffer_str));
-		me_free(vec->buffer);
-		vec->buffer = temp_buffer;
 		vec->capacity = new_capacity;
 	}
 	vec->buffer[vec->len] = element;
@@ -59,7 +54,6 @@ t_error vec_buf_str_push(t_vec_buf_str *vec, t_buffer_str element)
 /// Return true in case of an error
 t_error vec_buf_str_reserve(t_vec_buf_str *vec, t_usize wanted_capacity)
 {
-	t_buffer_str *temp_buffer;
 	size_t		   new_capacity;
 
 	if (vec == NULL)
@@ -69,12 +63,7 @@ t_error vec_buf_str_reserve(t_vec_buf_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;
-		temp_buffer = mem_alloc_array(new_capacity, sizeof(t_buffer_str));
+		vec->buffer = me_realloc(vec->buffer, new_capacity);
-		if (temp_buffer == NULL)
-			return (ERROR);
-		mem_copy(temp_buffer, vec->buffer, vec->len * sizeof(t_buffer_str));
-		me_free(vec->buffer);
-		vec->buffer = temp_buffer;
 		vec->capacity = new_capacity;
 	}
 	return (NO_ERROR);

stdme/output/src/vec/str/str.c

@@ -14,6 +14,7 @@
 #include "me/mem/mem_copy.h"
 #include "me/mem/mem_set_zero.h"
 #include "me/types.h"
+#include "me/alloc/alloc.h"
 #include "me/vec/vec_str.h"
 #include <stdlib.h>
 
@@ -33,7 +34,6 @@ 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_str *temp_buffer;
 	size_t		   new_capacity;
 
 	if (vec == NULL)
@@ -43,12 +43,7 @@ t_error vec_str_push(t_vec_str *vec, t_str element)
 		new_capacity = (vec->capacity * 3) / 2 + 1;
 		while (vec->len + 1 > new_capacity)
 			new_capacity = (new_capacity * 3) / 2 + 1;
-		temp_buffer = mem_alloc_array(new_capacity, sizeof(t_str));
+		vec->buffer = me_realloc(vec->buffer, new_capacity);
-		if (temp_buffer == NULL)
-			return (ERROR);
-		mem_copy(temp_buffer, vec->buffer, vec->len * sizeof(t_str));
-		me_free(vec->buffer);
-		vec->buffer = temp_buffer;
 		vec->capacity = new_capacity;
 	}
 	vec->buffer[vec->len] = element;
@@ -59,7 +54,6 @@ 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_str *temp_buffer;
 	size_t		   new_capacity;
 
 	if (vec == NULL)
@@ -69,12 +63,7 @@ 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;
-		temp_buffer = mem_alloc_array(new_capacity, sizeof(t_str));
+		vec->buffer = me_realloc(vec->buffer, new_capacity);
-		if (temp_buffer == NULL)
-			return (ERROR);
-		mem_copy(temp_buffer, vec->buffer, vec->len * sizeof(t_str));
-		me_free(vec->buffer);
-		vec->buffer = temp_buffer;
 		vec->capacity = new_capacity;
 	}
 	return (NO_ERROR);

stdme/output/src/vec/u8/u8.c

@@ -14,6 +14,7 @@
 #include "me/mem/mem_copy.h"
 #include "me/mem/mem_set_zero.h"
 #include "me/types.h"
+#include "me/alloc/alloc.h"
 #include "me/vec/vec_u8.h"
 #include <stdlib.h>
 
@@ -33,7 +34,6 @@ t_vec_u8 vec_u8_new(t_usize				  capacity,
 /// Return true in case of an error
 t_error vec_u8_push(t_vec_u8 *vec, t_u8 element)
 {
-	t_u8 *temp_buffer;
 	size_t		   new_capacity;
 
 	if (vec == NULL)
@@ -43,12 +43,7 @@ t_error vec_u8_push(t_vec_u8 *vec, t_u8 element)
 		new_capacity = (vec->capacity * 3) / 2 + 1;
 		while (vec->len + 1 > new_capacity)
 			new_capacity = (new_capacity * 3) / 2 + 1;
-		temp_buffer = mem_alloc_array(new_capacity, sizeof(t_u8));
+		vec->buffer = me_realloc(vec->buffer, new_capacity);
-		if (temp_buffer == NULL)
-			return (ERROR);
-		mem_copy(temp_buffer, vec->buffer, vec->len * sizeof(t_u8));
-		me_free(vec->buffer);
-		vec->buffer = temp_buffer;
 		vec->capacity = new_capacity;
 	}
 	vec->buffer[vec->len] = element;
@@ -59,7 +54,6 @@ t_error vec_u8_push(t_vec_u8 *vec, t_u8 element)
 /// Return true in case of an error
 t_error vec_u8_reserve(t_vec_u8 *vec, t_usize wanted_capacity)
 {
-	t_u8 *temp_buffer;
 	size_t		   new_capacity;
 
 	if (vec == NULL)
@@ -69,12 +63,7 @@ t_error vec_u8_reserve(t_vec_u8 *vec, t_usize wanted_capacity)
 		new_capacity = (vec->capacity * 3) / 2 + 1;
 		while (wanted_capacity > new_capacity)
 			new_capacity = (new_capacity * 3) / 2 + 1;
-		temp_buffer = mem_alloc_array(new_capacity, sizeof(t_u8));
+		vec->buffer = me_realloc(vec->buffer, new_capacity);
-		if (temp_buffer == NULL)
-			return (ERROR);
-		mem_copy(temp_buffer, vec->buffer, vec->len * sizeof(t_u8));
-		me_free(vec->buffer);
-		vec->buffer = temp_buffer;
 		vec->capacity = new_capacity;
 	}
 	return (NO_ERROR);

stdme/output/src/vec/vec_buf_str.c

@@ -1,115 +0,0 @@
-/* ************************************************************************** */
-/*                                                                            */
-/*                                                        :::      ::::::::   */
-/*   vec_buf_str.c                                  :+:      :+:    :+:   */
-/*                                                    +:+ +:+         +:+     */
-/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
-/*                                                +#+#+#+#+#+   +#+           */
-/*   Created: 2023/12/05 18:46:28 by maiboyer          #+#    #+#             */
-/*   Updated: 2023/12/09 17:54:11 by maiboyer         ###   ########.fr       */
-/*                                                                            */
-/* ************************************************************************** */
-
-#include "me/mem/mem_alloc_array.h"
-#include "me/mem/mem_copy.h"
-#include "me/mem/mem_set_zero.h"
-#include "me/types.h"
-#include "me/vec/vec_buf_str.h"
-#include <stdlib.h>
-
-t_vec_buf_str vec_buf_str_new(t_usize				  capacity,
-									  t_free_buf_str_item free_function)
-{
-	t_vec_buf_str out;
-
-	out = (t_vec_buf_str){0};
-	out.free_func = free_function;
-	out.buffer = mem_alloc_array(capacity, sizeof(t_buffer_str));
-	if (out.buffer)
-		out.capacity = capacity;
-	return (out);
-}
-
-/// Return true in case of an error
-t_error vec_buf_str_push(t_vec_buf_str *vec, t_buffer_str element)
-{
-	t_buffer_str *temp_buffer;
-	size_t		   new_capacity;
-
-	if (vec == NULL)
-		return (ERROR);
-	if (vec->len + 1 > vec->capacity)
-	{
-		new_capacity = (vec->capacity * 3) / 2 + 1;
-		while (vec->len + 1 > new_capacity)
-			new_capacity = (new_capacity * 3) / 2 + 1;
-		temp_buffer = mem_alloc_array(new_capacity, sizeof(t_buffer_str));
-		if (temp_buffer == NULL)
-			return (ERROR);
-		mem_copy(temp_buffer, vec->buffer, vec->len * sizeof(t_buffer_str));
-		me_free(vec->buffer);
-		vec->buffer = temp_buffer;
-		vec->capacity = new_capacity;
-	}
-	vec->buffer[vec->len] = element;
-	vec->len += 1;
-	return (NO_ERROR);
-}
-
-/// Return true in case of an error
-t_error vec_buf_str_reserve(t_vec_buf_str *vec, t_usize wanted_capacity)
-{
-	t_buffer_str *temp_buffer;
-	size_t		   new_capacity;
-
-	if (vec == NULL)
-		return (ERROR);
-	if (wanted_capacity > vec->capacity)
-	{
-		new_capacity = (vec->capacity * 3) / 2 + 1;
-		while (wanted_capacity > new_capacity)
-			new_capacity = (new_capacity * 3) / 2 + 1;
-		temp_buffer = mem_alloc_array(new_capacity, sizeof(t_buffer_str));
-		if (temp_buffer == NULL)
-			return (ERROR);
-		mem_copy(temp_buffer, vec->buffer, vec->len * sizeof(t_buffer_str));
-		me_free(vec->buffer);
-		vec->buffer = temp_buffer;
-		vec->capacity = new_capacity;
-	}
-	return (NO_ERROR);
-}
-
-/// Return true if the vector is empty
-/// This function is safe to call with value being NULL
-t_error vec_buf_str_pop(t_vec_buf_str *vec, t_buffer_str *value)
-{
-	t_buffer_str  temp_value;
-	t_buffer_str *ptr;
-
-	if (vec == NULL)
-		return (ERROR);
-	ptr = value;
-	if (vec->len == 0)
-		return (ERROR);
-	if (value == NULL)
-		ptr = &temp_value;
-	vec->len--;
-	*ptr = vec->buffer[vec->len];
-	mem_set_zero(&vec->buffer[vec->len], sizeof(t_buffer_str));
-	return (NO_ERROR);
-}
-
-/// This function is safe to call with `free_elem` being NULL
-void vec_buf_str_free(t_vec_buf_str vec)
-{
-	if (vec.free_func)
-	{
-		while (vec.len)
-		{
-			vec.free_func(vec.buffer[vec.len - 1]);
-			vec.len--;
-		}
-	}
-	me_free(vec.buffer);
-}

stdme/output/src/vec/vec_buf_str_functions2.c

@@ -1,112 +0,0 @@
-/* ************************************************************************** */
-/*                                                                            */
-/*                                                        :::      ::::::::   */
-/*   vec_buf_str.c                                  :+:      :+:    :+:   */
-/*                                                    +:+ +:+         +:+     */
-/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
-/*                                                +#+#+#+#+#+   +#+           */
-/*   Created: 2023/12/30 17:59:28 by maiboyer          #+#    #+#             */
-/*   Updated: 2023/12/30 17:59:28 by maiboyer         ###   ########.fr       */
-/*                                                                            */
-/* ************************************************************************** */
-
-#include "me/mem/mem_alloc_array.h"
-#include "me/mem/mem_copy.h"
-#include "me/mem/mem_set_zero.h"
-#include "me/types.h"
-#include "me/vec/vec_buf_str.h"
-#include <stdlib.h>
-
-t_error vec_buf_str_find(t_vec_buf_str *vec,
-							 bool (*fn)(const t_buffer_str *), t_usize *index)
-{
-	t_usize idx;
-
-	if (vec == NULL || fn == NULL || index == NULL)
-		return (ERROR);
-	idx = 0;
-	while (idx < vec->len)
-	{
-		if (fn(&vec->buffer[idx]))
-		{
-			*index = idx;
-			return (NO_ERROR);
-		}
-		idx++;
-	}
-	return (ERROR);
-}
-
-t_error vec_buf_str_find_starting(t_vec_buf_str *vec,
-									  bool (*fn)(const t_buffer_str *),
-									  t_usize starting_index, t_usize *index)
-{
-	t_usize idx;
-
-	if (vec == NULL || fn == NULL || index == NULL)
-		return (ERROR);
-	idx = starting_index;
-	while (idx < vec->len)
-	{
-		if (fn(&vec->buffer[idx]))
-		{
-			*index = idx;
-			return (NO_ERROR);
-		}
-		idx++;
-	}
-	return (ERROR);
-}
-
-t_error vec_buf_str_all(t_vec_buf_str *vec,
-							bool (*fn)(const t_buffer_str *), bool *result)
-{
-	t_usize idx;
-
-	if (vec == NULL || fn == NULL || result == NULL)
-		return (ERROR);
-	idx = 0;
-	*result = true;
-	while (*result && idx < vec->len)
-	{
-		if (!fn(&vec->buffer[idx]))
-			*result = false;
-		idx++;
-	}
-	return (ERROR);
-}
-
-t_error vec_buf_str_any(t_vec_buf_str *vec,
-							bool (*fn)(const t_buffer_str *), bool *result)
-{
-	t_usize idx;
-
-	if (vec == NULL || fn == NULL || result == NULL)
-		return (ERROR);
-	idx = 0;
-	*result = false;
-	while (*result && idx < vec->len)
-	{
-		if (fn(&vec->buffer[idx]))
-			*result = true;
-		idx++;
-	}
-	return (ERROR);
-}
-
-void vec_buf_str_iter(t_vec_buf_str *vec,
-						  void (*fn)(t_usize index, t_buffer_str *value,
-									 void *state),
-						  void *state)
-{
-	t_usize idx;
-
-	if (vec == NULL || fn == NULL)
-		return;
-	idx = 0;
-	while (idx < vec->len)
-	{
-		fn(idx, &vec->buffer[idx], state);
-		idx++;
-	}
-}

stdme/output/src/vec/vec_buf_str_functions3.c

@@ -1,84 +0,0 @@
-/* ************************************************************************** */
-/*                                                                            */
-/*                                                        :::      ::::::::   */
-/*   vec_buf_str.c                                  :+:      :+:    :+:   */
-/*                                                    +:+ +:+         +:+     */
-/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
-/*                                                +#+#+#+#+#+   +#+           */
-/*   Created: 2023/12/30 17:59:28 by maiboyer          #+#    #+#             */
-/*   Updated: 2023/12/30 17:59:28 by maiboyer         ###   ########.fr       */
-/*                                                                            */
-/* ************************************************************************** */
-
-#include "me/mem/mem_alloc_array.h"
-#include "me/mem/mem_copy.h"
-#include "me/mem/mem_set_zero.h"
-#include "me/types.h"
-#include "me/vec/vec_buf_str.h"
-#include <stdlib.h>
-
-t_error vec_buf_str_push_front(t_vec_buf_str *vec,
-								   t_buffer_str	  element)
-{
-	t_usize i;
-
-	if (vec->len == 0)
-		return (vec_buf_str_push(vec, element));
-	i = vec->len - 1;
-	if (vec->capacity < vec->len + 1 &&
-		vec_buf_str_reserve(vec, 3 * vec->len / 2 + 1))
-		return (ERROR);
-	while (i > 0)
-	{
-		vec->buffer[i + 1] = vec->buffer[i];
-		i--;
-	}
-	vec->buffer[1] = vec->buffer[0];
-	vec->buffer[0] = element;
-	vec->len++;
-	return (NO_ERROR);
-}
-
-t_error vec_buf_str_pop_front(t_vec_buf_str *vec, t_buffer_str *value)
-{
-	t_usize i;
-
-	if (vec->len <= 1)
-		return (vec_buf_str_pop(vec, value));
-	i = 0;
-	*value = vec->buffer[0];
-	vec->len--;
-	while (i < vec->len)
-	{
-		vec->buffer[i] = vec->buffer[i + 1];
-		i++;
-	}
-	mem_set_zero(&vec->buffer[i], sizeof(*vec->buffer));
-	return (NO_ERROR);
-}
-
-void vec_buf_str_reverse(t_vec_buf_str *vec)
-{
-	t_buffer_str temporary;
-	t_usize		  i;
-
-	i = 0;
-	while (i < vec->len / 2)
-	{
-		temporary = vec->buffer[vec->len - 1 - i];
-		vec->buffer[vec->len - 1 - i] = vec->buffer[i];
-		vec->buffer[i] = temporary;
-		i++;
-	}
-}
-
-t_error vec_buf_str_back(t_vec_buf_str *vec, t_buffer_str **out)
-{
-	t_buffer_str *temporary;
-
-	if (out == NULL)
-		out = &temporary;
-	if (vec->len != 0)
-		return (*out = &vec->buffer[vec->len - 1], true);
-	return (false);
-}

stdme/output/src/vec/vec_str.c

@@ -1,115 +0,0 @@
-/* ************************************************************************** */
-/*                                                                            */
-/*                                                        :::      ::::::::   */
-/*   vec_str.c                                  :+:      :+:    :+:   */
-/*                                                    +:+ +:+         +:+     */
-/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
-/*                                                +#+#+#+#+#+   +#+           */
-/*   Created: 2023/12/05 18:46:28 by maiboyer          #+#    #+#             */
-/*   Updated: 2023/12/09 17:54:11 by maiboyer         ###   ########.fr       */
-/*                                                                            */
-/* ************************************************************************** */
-
-#include "me/mem/mem_alloc_array.h"
-#include "me/mem/mem_copy.h"
-#include "me/mem/mem_set_zero.h"
-#include "me/types.h"
-#include "me/vec/vec_str.h"
-#include <stdlib.h>
-
-t_vec_str vec_str_new(t_usize				  capacity,
-									  t_free_str_item free_function)
-{
-	t_vec_str out;
-
-	out = (t_vec_str){0};
-	out.free_func = free_function;
-	out.buffer = mem_alloc_array(capacity, sizeof(t_str));
-	if (out.buffer)
-		out.capacity = capacity;
-	return (out);
-}
-
-/// Return true in case of an error
-t_error vec_str_push(t_vec_str *vec, t_str element)
-{
-	t_str *temp_buffer;
-	size_t		   new_capacity;
-
-	if (vec == NULL)
-		return (ERROR);
-	if (vec->len + 1 > vec->capacity)
-	{
-		new_capacity = (vec->capacity * 3) / 2 + 1;
-		while (vec->len + 1 > new_capacity)
-			new_capacity = (new_capacity * 3) / 2 + 1;
-		temp_buffer = mem_alloc_array(new_capacity, sizeof(t_str));
-		if (temp_buffer == NULL)
-			return (ERROR);
-		mem_copy(temp_buffer, vec->buffer, vec->len * sizeof(t_str));
-		me_free(vec->buffer);
-		vec->buffer = temp_buffer;
-		vec->capacity = new_capacity;
-	}
-	vec->buffer[vec->len] = element;
-	vec->len += 1;
-	return (NO_ERROR);
-}
-
-/// Return true in case of an error
-t_error vec_str_reserve(t_vec_str *vec, t_usize wanted_capacity)
-{
-	t_str *temp_buffer;
-	size_t		   new_capacity;
-
-	if (vec == NULL)
-		return (ERROR);
-	if (wanted_capacity > vec->capacity)
-	{
-		new_capacity = (vec->capacity * 3) / 2 + 1;
-		while (wanted_capacity > new_capacity)
-			new_capacity = (new_capacity * 3) / 2 + 1;
-		temp_buffer = mem_alloc_array(new_capacity, sizeof(t_str));
-		if (temp_buffer == NULL)
-			return (ERROR);
-		mem_copy(temp_buffer, vec->buffer, vec->len * sizeof(t_str));
-		me_free(vec->buffer);
-		vec->buffer = temp_buffer;
-		vec->capacity = new_capacity;
-	}
-	return (NO_ERROR);
-}
-
-/// 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_str  temp_value;
-	t_str *ptr;
-
-	if (vec == NULL)
-		return (ERROR);
-	ptr = value;
-	if (vec->len == 0)
-		return (ERROR);
-	if (value == NULL)
-		ptr = &temp_value;
-	vec->len--;
-	*ptr = vec->buffer[vec->len];
-	mem_set_zero(&vec->buffer[vec->len], sizeof(t_str));
-	return (NO_ERROR);
-}
-
-/// This function is safe to call with `free_elem` being NULL
-void vec_str_free(t_vec_str vec)
-{
-	if (vec.free_func)
-	{
-		while (vec.len)
-		{
-			vec.free_func(vec.buffer[vec.len - 1]);
-			vec.len--;
-		}
-	}
-	me_free(vec.buffer);
-}

stdme/output/src/vec/vec_str_functions2.c

@@ -1,112 +0,0 @@
-/* ************************************************************************** */
-/*                                                                            */
-/*                                                        :::      ::::::::   */
-/*   vec_str.c                                  :+:      :+:    :+:   */
-/*                                                    +:+ +:+         +:+     */
-/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
-/*                                                +#+#+#+#+#+   +#+           */
-/*   Created: 2023/12/30 17:59:28 by maiboyer          #+#    #+#             */
-/*   Updated: 2023/12/30 17:59:28 by maiboyer         ###   ########.fr       */
-/*                                                                            */
-/* ************************************************************************** */
-
-#include "me/mem/mem_alloc_array.h"
-#include "me/mem/mem_copy.h"
-#include "me/mem/mem_set_zero.h"
-#include "me/types.h"
-#include "me/vec/vec_str.h"
-#include <stdlib.h>
-
-t_error vec_str_find(t_vec_str *vec,
-							 bool (*fn)(const t_str *), t_usize *index)
-{
-	t_usize idx;
-
-	if (vec == NULL || fn == NULL || index == NULL)
-		return (ERROR);
-	idx = 0;
-	while (idx < vec->len)
-	{
-		if (fn(&vec->buffer[idx]))
-		{
-			*index = idx;
-			return (NO_ERROR);
-		}
-		idx++;
-	}
-	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_usize idx;
-
-	if (vec == NULL || fn == NULL || index == NULL)
-		return (ERROR);
-	idx = starting_index;
-	while (idx < vec->len)
-	{
-		if (fn(&vec->buffer[idx]))
-		{
-			*index = idx;
-			return (NO_ERROR);
-		}
-		idx++;
-	}
-	return (ERROR);
-}
-
-t_error vec_str_all(t_vec_str *vec,
-							bool (*fn)(const t_str *), bool *result)
-{
-	t_usize idx;
-
-	if (vec == NULL || fn == NULL || result == NULL)
-		return (ERROR);
-	idx = 0;
-	*result = true;
-	while (*result && idx < vec->len)
-	{
-		if (!fn(&vec->buffer[idx]))
-			*result = false;
-		idx++;
-	}
-	return (ERROR);
-}
-
-t_error vec_str_any(t_vec_str *vec,
-							bool (*fn)(const t_str *), bool *result)
-{
-	t_usize idx;
-
-	if (vec == NULL || fn == NULL || result == NULL)
-		return (ERROR);
-	idx = 0;
-	*result = false;
-	while (*result && idx < vec->len)
-	{
-		if (fn(&vec->buffer[idx]))
-			*result = true;
-		idx++;
-	}
-	return (ERROR);
-}
-
-void vec_str_iter(t_vec_str *vec,
-						  void (*fn)(t_usize index, t_str *value,
-									 void *state),
-						  void *state)
-{
-	t_usize idx;
-
-	if (vec == NULL || fn == NULL)
-		return;
-	idx = 0;
-	while (idx < vec->len)
-	{
-		fn(idx, &vec->buffer[idx], state);
-		idx++;
-	}
-}

stdme/output/src/vec/vec_str_functions3.c

@@ -1,84 +0,0 @@
-/* ************************************************************************** */
-/*                                                                            */
-/*                                                        :::      ::::::::   */
-/*   vec_str.c                                  :+:      :+:    :+:   */
-/*                                                    +:+ +:+         +:+     */
-/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
-/*                                                +#+#+#+#+#+   +#+           */
-/*   Created: 2023/12/30 17:59:28 by maiboyer          #+#    #+#             */
-/*   Updated: 2023/12/30 17:59:28 by maiboyer         ###   ########.fr       */
-/*                                                                            */
-/* ************************************************************************** */
-
-#include "me/mem/mem_alloc_array.h"
-#include "me/mem/mem_copy.h"
-#include "me/mem/mem_set_zero.h"
-#include "me/types.h"
-#include "me/vec/vec_str.h"
-#include <stdlib.h>
-
-t_error vec_str_push_front(t_vec_str *vec,
-								   t_str	  element)
-{
-	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))
-		return (ERROR);
-	while (i > 0)
-	{
-		vec->buffer[i + 1] = vec->buffer[i];
-		i--;
-	}
-	vec->buffer[1] = vec->buffer[0];
-	vec->buffer[0] = element;
-	vec->len++;
-	return (NO_ERROR);
-}
-
-t_error vec_str_pop_front(t_vec_str *vec, t_str *value)
-{
-	t_usize i;
-
-	if (vec->len <= 1)
-		return (vec_str_pop(vec, value));
-	i = 0;
-	*value = vec->buffer[0];
-	vec->len--;
-	while (i < vec->len)
-	{
-		vec->buffer[i] = vec->buffer[i + 1];
-		i++;
-	}
-	mem_set_zero(&vec->buffer[i], sizeof(*vec->buffer));
-	return (NO_ERROR);
-}
-
-void vec_str_reverse(t_vec_str *vec)
-{
-	t_str temporary;
-	t_usize		  i;
-
-	i = 0;
-	while (i < vec->len / 2)
-	{
-		temporary = vec->buffer[vec->len - 1 - i];
-		vec->buffer[vec->len - 1 - i] = vec->buffer[i];
-		vec->buffer[i] = temporary;
-		i++;
-	}
-}
-
-t_error vec_str_back(t_vec_str *vec, t_str **out)
-{
-	t_str *temporary;
-
-	if (out == NULL)
-		out = &temporary;
-	if (vec->len != 0)
-		return (*out = &vec->buffer[vec->len - 1], true);
-	return (false);
-}

stdme/output/src/vec/vec_u8.c

@@ -1,115 +0,0 @@
-/* ************************************************************************** */
-/*                                                                            */
-/*                                                        :::      ::::::::   */
-/*   vec_u8.c                                  :+:      :+:    :+:   */
-/*                                                    +:+ +:+         +:+     */
-/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
-/*                                                +#+#+#+#+#+   +#+           */
-/*   Created: 2023/12/05 18:46:28 by maiboyer          #+#    #+#             */
-/*   Updated: 2023/12/09 17:54:11 by maiboyer         ###   ########.fr       */
-/*                                                                            */
-/* ************************************************************************** */
-
-#include "me/mem/mem_alloc_array.h"
-#include "me/mem/mem_copy.h"
-#include "me/mem/mem_set_zero.h"
-#include "me/types.h"
-#include "me/vec/vec_u8.h"
-#include <stdlib.h>
-
-t_vec_u8 vec_u8_new(t_usize				  capacity,
-									  t_free_u8_item free_function)
-{
-	t_vec_u8 out;
-
-	out = (t_vec_u8){0};
-	out.free_func = free_function;
-	out.buffer = mem_alloc_array(capacity, sizeof(t_u8));
-	if (out.buffer)
-		out.capacity = capacity;
-	return (out);
-}
-
-/// Return true in case of an error
-t_error vec_u8_push(t_vec_u8 *vec, t_u8 element)
-{
-	t_u8 *temp_buffer;
-	size_t		   new_capacity;
-
-	if (vec == NULL)
-		return (ERROR);
-	if (vec->len + 1 > vec->capacity)
-	{
-		new_capacity = (vec->capacity * 3) / 2 + 1;
-		while (vec->len + 1 > new_capacity)
-			new_capacity = (new_capacity * 3) / 2 + 1;
-		temp_buffer = mem_alloc_array(new_capacity, sizeof(t_u8));
-		if (temp_buffer == NULL)
-			return (ERROR);
-		mem_copy(temp_buffer, vec->buffer, vec->len * sizeof(t_u8));
-		me_free(vec->buffer);
-		vec->buffer = temp_buffer;
-		vec->capacity = new_capacity;
-	}
-	vec->buffer[vec->len] = element;
-	vec->len += 1;
-	return (NO_ERROR);
-}
-
-/// Return true in case of an error
-t_error vec_u8_reserve(t_vec_u8 *vec, t_usize wanted_capacity)
-{
-	t_u8 *temp_buffer;
-	size_t		   new_capacity;
-
-	if (vec == NULL)
-		return (ERROR);
-	if (wanted_capacity > vec->capacity)
-	{
-		new_capacity = (vec->capacity * 3) / 2 + 1;
-		while (wanted_capacity > new_capacity)
-			new_capacity = (new_capacity * 3) / 2 + 1;
-		temp_buffer = mem_alloc_array(new_capacity, sizeof(t_u8));
-		if (temp_buffer == NULL)
-			return (ERROR);
-		mem_copy(temp_buffer, vec->buffer, vec->len * sizeof(t_u8));
-		me_free(vec->buffer);
-		vec->buffer = temp_buffer;
-		vec->capacity = new_capacity;
-	}
-	return (NO_ERROR);
-}
-
-/// Return true if the vector is empty
-/// This function is safe to call with value being NULL
-t_error vec_u8_pop(t_vec_u8 *vec, t_u8 *value)
-{
-	t_u8  temp_value;
-	t_u8 *ptr;
-
-	if (vec == NULL)
-		return (ERROR);
-	ptr = value;
-	if (vec->len == 0)
-		return (ERROR);
-	if (value == NULL)
-		ptr = &temp_value;
-	vec->len--;
-	*ptr = vec->buffer[vec->len];
-	mem_set_zero(&vec->buffer[vec->len], sizeof(t_u8));
-	return (NO_ERROR);
-}
-
-/// This function is safe to call with `free_elem` being NULL
-void vec_u8_free(t_vec_u8 vec)
-{
-	if (vec.free_func)
-	{
-		while (vec.len)
-		{
-			vec.free_func(vec.buffer[vec.len - 1]);
-			vec.len--;
-		}
-	}
-	me_free(vec.buffer);
-}

stdme/output/src/vec/vec_u8_functions2.c

@@ -1,112 +0,0 @@
-/* ************************************************************************** */
-/*                                                                            */
-/*                                                        :::      ::::::::   */
-/*   vec_u8.c                                  :+:      :+:    :+:   */
-/*                                                    +:+ +:+         +:+     */
-/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
-/*                                                +#+#+#+#+#+   +#+           */
-/*   Created: 2023/12/30 17:59:28 by maiboyer          #+#    #+#             */
-/*   Updated: 2023/12/30 17:59:28 by maiboyer         ###   ########.fr       */
-/*                                                                            */
-/* ************************************************************************** */
-
-#include "me/mem/mem_alloc_array.h"
-#include "me/mem/mem_copy.h"
-#include "me/mem/mem_set_zero.h"
-#include "me/types.h"
-#include "me/vec/vec_u8.h"
-#include <stdlib.h>
-
-t_error vec_u8_find(t_vec_u8 *vec,
-							 bool (*fn)(const t_u8 *), t_usize *index)
-{
-	t_usize idx;
-
-	if (vec == NULL || fn == NULL || index == NULL)
-		return (ERROR);
-	idx = 0;
-	while (idx < vec->len)
-	{
-		if (fn(&vec->buffer[idx]))
-		{
-			*index = idx;
-			return (NO_ERROR);
-		}
-		idx++;
-	}
-	return (ERROR);
-}
-
-t_error vec_u8_find_starting(t_vec_u8 *vec,
-									  bool (*fn)(const t_u8 *),
-									  t_usize starting_index, t_usize *index)
-{
-	t_usize idx;
-
-	if (vec == NULL || fn == NULL || index == NULL)
-		return (ERROR);
-	idx = starting_index;
-	while (idx < vec->len)
-	{
-		if (fn(&vec->buffer[idx]))
-		{
-			*index = idx;
-			return (NO_ERROR);
-		}
-		idx++;
-	}
-	return (ERROR);
-}
-
-t_error vec_u8_all(t_vec_u8 *vec,
-							bool (*fn)(const t_u8 *), bool *result)
-{
-	t_usize idx;
-
-	if (vec == NULL || fn == NULL || result == NULL)
-		return (ERROR);
-	idx = 0;
-	*result = true;
-	while (*result && idx < vec->len)
-	{
-		if (!fn(&vec->buffer[idx]))
-			*result = false;
-		idx++;
-	}
-	return (ERROR);
-}
-
-t_error vec_u8_any(t_vec_u8 *vec,
-							bool (*fn)(const t_u8 *), bool *result)
-{
-	t_usize idx;
-
-	if (vec == NULL || fn == NULL || result == NULL)
-		return (ERROR);
-	idx = 0;
-	*result = false;
-	while (*result && idx < vec->len)
-	{
-		if (fn(&vec->buffer[idx]))
-			*result = true;
-		idx++;
-	}
-	return (ERROR);
-}
-
-void vec_u8_iter(t_vec_u8 *vec,
-						  void (*fn)(t_usize index, t_u8 *value,
-									 void *state),
-						  void *state)
-{
-	t_usize idx;
-
-	if (vec == NULL || fn == NULL)
-		return;
-	idx = 0;
-	while (idx < vec->len)
-	{
-		fn(idx, &vec->buffer[idx], state);
-		idx++;
-	}
-}

stdme/output/src/vec/vec_u8_functions3.c

@@ -1,84 +0,0 @@
-/* ************************************************************************** */
-/*                                                                            */
-/*                                                        :::      ::::::::   */
-/*   vec_u8.c                                  :+:      :+:    :+:   */
-/*                                                    +:+ +:+         +:+     */
-/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
-/*                                                +#+#+#+#+#+   +#+           */
-/*   Created: 2023/12/30 17:59:28 by maiboyer          #+#    #+#             */
-/*   Updated: 2023/12/30 17:59:28 by maiboyer         ###   ########.fr       */
-/*                                                                            */
-/* ************************************************************************** */
-
-#include "me/mem/mem_alloc_array.h"
-#include "me/mem/mem_copy.h"
-#include "me/mem/mem_set_zero.h"
-#include "me/types.h"
-#include "me/vec/vec_u8.h"
-#include <stdlib.h>
-
-t_error vec_u8_push_front(t_vec_u8 *vec,
-								   t_u8	  element)
-{
-	t_usize i;
-
-	if (vec->len == 0)
-		return (vec_u8_push(vec, element));
-	i = vec->len - 1;
-	if (vec->capacity < vec->len + 1 &&
-		vec_u8_reserve(vec, 3 * vec->len / 2 + 1))
-		return (ERROR);
-	while (i > 0)
-	{
-		vec->buffer[i + 1] = vec->buffer[i];
-		i--;
-	}
-	vec->buffer[1] = vec->buffer[0];
-	vec->buffer[0] = element;
-	vec->len++;
-	return (NO_ERROR);
-}
-
-t_error vec_u8_pop_front(t_vec_u8 *vec, t_u8 *value)
-{
-	t_usize i;
-
-	if (vec->len <= 1)
-		return (vec_u8_pop(vec, value));
-	i = 0;
-	*value = vec->buffer[0];
-	vec->len--;
-	while (i < vec->len)
-	{
-		vec->buffer[i] = vec->buffer[i + 1];
-		i++;
-	}
-	mem_set_zero(&vec->buffer[i], sizeof(*vec->buffer));
-	return (NO_ERROR);
-}
-
-void vec_u8_reverse(t_vec_u8 *vec)
-{
-	t_u8 temporary;
-	t_usize		  i;
-
-	i = 0;
-	while (i < vec->len / 2)
-	{
-		temporary = vec->buffer[vec->len - 1 - i];
-		vec->buffer[vec->len - 1 - i] = vec->buffer[i];
-		vec->buffer[i] = temporary;
-		i++;
-	}
-}
-
-t_error vec_u8_back(t_vec_u8 *vec, t_u8 **out)
-{
-	t_u8 *temporary;
-
-	if (out == NULL)
-		out = &temporary;
-	if (vec->len != 0)
-		return (*out = &vec->buffer[vec->len - 1], true);
-	return (false);
-}

stdme/src/alloc/alloc.c

@@ -6,7 +6,7 @@
 /*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2024/05/07 10:13:06 by maiboyer          #+#    #+#             */
-/*   Updated: 2024/05/10 21:39:07 by maiboyer         ###   ########.fr       */
+/*   Updated: 2024/05/10 21:50:09 by maiboyer         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -73,6 +73,8 @@ void me_free(void *ptr)
 {
 	t_mblock *cur;
 
+	if (ptr == NULL)
+		return;
 	cur = (void *)(((t_usize)ptr) - sizeof(t_mblock));
 	cur->used = false;
 	if (cur->next != NULL && cur->page == cur->next->page && !cur->next->used)

stdme/src/alloc/get_arena.c

@@ -6,7 +6,7 @@
 /*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2024/05/07 09:47:50 by maiboyer          #+#    #+#             */
-/*   Updated: 2024/05/09 18:21:33 by maiboyer         ###   ########.fr       */
+/*   Updated: 2024/05/11 15:05:07 by maiboyer         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -37,9 +37,9 @@ t_mpage *alloc_page(t_usize size)
 	val->first = (t_mblock *)(((t_usize)val) + sizeof(t_mpage));
 	val->first->page = val;
 	val->first->next = NULL;
-	mem_copy(val->first->padding, BLOCK_PADDING, 7);
 	val->first->used = false;
 	val->first->size = size - sizeof(t_mblock) - sizeof(t_mpage);
+	mem_copy(val->first->padding, BLOCK_PADDING, 7);
 	return (val);
 }
 
@@ -63,9 +63,8 @@ t_mblock *split_block(t_mblock *self, t_usize min_size)
 	if (self->size > (min_size + sizeof(t_mblock) + 16))
 	{
 		remaining = self->size - min_size - sizeof(t_mblock);
-		printf("splitting %zu into %zu and %zu\n", self->size, min_size, remaining);
+		printf("splitting %zu into %zu and %zu\n", self->size, min_size,
-		if (self->size == 80 && min_size == 16 && remaining == 32)
+			   remaining);
-			printf("HERE\n");
 		self->size = min_size;
 		old_next = self->next;
 		self->next =
@@ -88,6 +87,8 @@ t_mblock *get_block_for_size(t_usize size)
 	cur = get_head_arena()->first;
 	while (cur)
 	{
+		if (cur->page == NULL)
+			me_abort("block doesn't have a page ?????");
 		if (!cur->used && cur->size >= size)
 			return (split_block(cur, size));
 		last = cur;