raphael/minishell
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

I want to kill sheeps in minecraft with a sword

Browse source
This commit is contained in:
Maieul BOYER 2024-05-12 17:14:25 +02:00
parent 4f1768b9e8
commit a779ccb768
No known key found for this signature in database
17 changed files with 488 additions and 268 deletions
Download patch file Download diff file Expand all files Collapse all files

3
gen.list
View file

@ -10,3 +10,6 @@ src/vec/parser_range/parser_range_functions3.c
src/vec/reduce_action/reduce_action.c src/vec/reduce_action/reduce_action.c
src/vec/reduce_action/reduce_action_functions2.c src/vec/reduce_action/reduce_action_functions2.c
src/vec/reduce_action/reduce_action_functions3.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

4
output/src/vec/parser_heredoc/parser_heredoc.c
View file

@ -43,7 +43,7 @@ t_error vec_parser_heredoc_push(t_vec_parser_heredoc *vec, t_heredoc element)
new_capacity = (vec->capacity * 3) / 2 + 1; new_capacity = (vec->capacity * 3) / 2 + 1;
while (vec->len + 1 > new_capacity) while (vec->len + 1 > new_capacity)
new_capacity = (new_capacity * 3) / 2 + 1; new_capacity = (new_capacity * 3) / 2 + 1;
vec->buffer = me_realloc(vec->buffer, new_capacity); vec->buffer = me_realloc_array(vec->buffer, new_capacity, sizeof(t_heredoc));
vec->capacity = new_capacity; vec->capacity = new_capacity;
} }
vec->buffer[vec->len] = element; vec->buffer[vec->len] = element;
@ -63,7 +63,7 @@ t_error vec_parser_heredoc_reserve(t_vec_parser_heredoc *vec, t_usize wanted_cap
new_capacity = (vec->capacity * 3) / 2 + 1; new_capacity = (vec->capacity * 3) / 2 + 1;
while (wanted_capacity > new_capacity) while (wanted_capacity > new_capacity)
new_capacity = (new_capacity * 3) / 2 + 1; new_capacity = (new_capacity * 3) / 2 + 1;
vec->buffer = me_realloc(vec->buffer, new_capacity); vec->buffer = me_realloc_array(vec->buffer, new_capacity, sizeof(t_heredoc));
vec->capacity = new_capacity; vec->capacity = new_capacity;
} }
return (NO_ERROR); return (NO_ERROR);

4
output/src/vec/parser_range/parser_range.c
View file

@ -43,7 +43,7 @@ t_error vec_parser_range_push(t_vec_parser_range *vec, t_parser_range element)
new_capacity = (vec->capacity * 3) / 2 + 1; new_capacity = (vec->capacity * 3) / 2 + 1;
while (vec->len + 1 > new_capacity) while (vec->len + 1 > new_capacity)
new_capacity = (new_capacity * 3) / 2 + 1; new_capacity = (new_capacity * 3) / 2 + 1;
vec->buffer = me_realloc(vec->buffer, new_capacity); vec->buffer = me_realloc_array(vec->buffer, new_capacity, sizeof(t_parser_range));
vec->capacity = new_capacity; vec->capacity = new_capacity;
} }
vec->buffer[vec->len] = element; vec->buffer[vec->len] = element;
@ -63,7 +63,7 @@ t_error vec_parser_range_reserve(t_vec_parser_range *vec, t_usize wanted_capacit
new_capacity = (vec->capacity * 3) / 2 + 1; new_capacity = (vec->capacity * 3) / 2 + 1;
while (wanted_capacity > new_capacity) while (wanted_capacity > new_capacity)
new_capacity = (new_capacity * 3) / 2 + 1; new_capacity = (new_capacity * 3) / 2 + 1;
vec->buffer = me_realloc(vec->buffer, new_capacity); vec->buffer = me_realloc_array(vec->buffer, new_capacity, sizeof(t_parser_range));
vec->capacity = new_capacity; vec->capacity = new_capacity;
} }
return (NO_ERROR); return (NO_ERROR);

4
output/src/vec/reduce_action/reduce_action.c
View file

@ -43,7 +43,7 @@ t_error vec_reduce_action_push(t_vec_reduce_action *vec, t_reduce_action element
new_capacity = (vec->capacity * 3) / 2 + 1; new_capacity = (vec->capacity * 3) / 2 + 1;
while (vec->len + 1 > new_capacity) while (vec->len + 1 > new_capacity)
new_capacity = (new_capacity * 3) / 2 + 1; new_capacity = (new_capacity * 3) / 2 + 1;
vec->buffer = me_realloc(vec->buffer, new_capacity); vec->buffer = me_realloc_array(vec->buffer, new_capacity, sizeof(t_reduce_action));
vec->capacity = new_capacity; vec->capacity = new_capacity;
} }
vec->buffer[vec->len] = element; vec->buffer[vec->len] = element;
@ -63,7 +63,7 @@ t_error vec_reduce_action_reserve(t_vec_reduce_action *vec, t_usize wanted_capac
new_capacity = (vec->capacity * 3) / 2 + 1; new_capacity = (vec->capacity * 3) / 2 + 1;
while (wanted_capacity > new_capacity) while (wanted_capacity > new_capacity)
new_capacity = (new_capacity * 3) / 2 + 1; new_capacity = (new_capacity * 3) / 2 + 1;
vec->buffer = me_realloc(vec->buffer, new_capacity); vec->buffer = me_realloc_array(vec->buffer, new_capacity, sizeof(t_reduce_action));
vec->capacity = new_capacity; vec->capacity = new_capacity;
} }
return (NO_ERROR); return (NO_ERROR);

4
output/src/vec/str/str.c
View file

@ -43,7 +43,7 @@ t_error vec_str_push(t_vec_str *vec, t_str element)
new_capacity = (vec->capacity * 3) / 2 + 1; new_capacity = (vec->capacity * 3) / 2 + 1;
while (vec->len + 1 > new_capacity) while (vec->len + 1 > new_capacity)
new_capacity = (new_capacity * 3) / 2 + 1; new_capacity = (new_capacity * 3) / 2 + 1;
vec->buffer = me_realloc(vec->buffer, new_capacity); vec->buffer = me_realloc_array(vec->buffer, new_capacity, sizeof(t_str));
vec->capacity = new_capacity; vec->capacity = new_capacity;
} }
vec->buffer[vec->len] = element; vec->buffer[vec->len] = element;
@ -63,7 +63,7 @@ t_error vec_str_reserve(t_vec_str *vec, t_usize wanted_capacity)
new_capacity = (vec->capacity * 3) / 2 + 1; new_capacity = (vec->capacity * 3) / 2 + 1;
while (wanted_capacity > new_capacity) while (wanted_capacity > new_capacity)
new_capacity = (new_capacity * 3) / 2 + 1; new_capacity = (new_capacity * 3) / 2 + 1;
vec->buffer = me_realloc(vec->buffer, new_capacity); vec->buffer = me_realloc_array(vec->buffer, new_capacity, sizeof(t_str));
vec->capacity = new_capacity; vec->capacity = new_capacity;
} }
return (NO_ERROR); return (NO_ERROR);

2
parser/Makefile
View file

@ -6,7 +6,7 @@
# By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ # # By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ #
# +#+#+#+#+#+ +#+ # # +#+#+#+#+#+ +#+ #
# Created: 2023/11/03 13:20:01 by maiboyer #+# #+# # # Created: 2023/11/03 13:20:01 by maiboyer #+# #+# #
# Updated: 2024/05/09 21:27:15 by maiboyer ### ########.fr # # Updated: 2024/05/12 17:13:38 by maiboyer ### ########.fr #
# # # #
# **************************************************************************** # # **************************************************************************** #

4
stdme/generic_sources/src/vec/C__PREFIX__.c__TEMPLATE__
View file

@ -43,7 +43,7 @@ t_error vec_C__PREFIX___push(t_vec_C__PREFIX__ *vec, C__TYPENAME__ element)
new_capacity = (vec->capacity * 3) / 2 + 1; new_capacity = (vec->capacity * 3) / 2 + 1;
while (vec->len + 1 > new_capacity) while (vec->len + 1 > new_capacity)
new_capacity = (new_capacity * 3) / 2 + 1; new_capacity = (new_capacity * 3) / 2 + 1;
vec->buffer = me_realloc(vec->buffer, new_capacity); vec->buffer = me_realloc_array(vec->buffer, new_capacity, sizeof(C__TYPENAME__));
vec->capacity = new_capacity; vec->capacity = new_capacity;
} }
vec->buffer[vec->len] = element; vec->buffer[vec->len] = element;
@ -63,7 +63,7 @@ t_error vec_C__PREFIX___reserve(t_vec_C__PREFIX__ *vec, t_usize wanted_capacity)
new_capacity = (vec->capacity * 3) / 2 + 1; new_capacity = (vec->capacity * 3) / 2 + 1;
while (wanted_capacity > new_capacity) while (wanted_capacity > new_capacity)
new_capacity = (new_capacity * 3) / 2 + 1; new_capacity = (new_capacity * 3) / 2 + 1;
vec->buffer = me_realloc(vec->buffer, new_capacity); vec->buffer = me_realloc_array(vec->buffer, new_capacity, sizeof(C__TYPENAME__));
vec->capacity = new_capacity; vec->capacity = new_capacity;
} }
return (NO_ERROR); return (NO_ERROR);

3
stdme/include/me/alloc/alloc.h
View file

@ -6,7 +6,7 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */ /* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2024/05/07 09:42:02 by maiboyer #+# #+# */ /* Created: 2024/05/07 09:42:02 by maiboyer #+# #+# */
/* Updated: 2024/05/07 09:43:31 by maiboyer ### ########.fr */ /* Updated: 2024/05/12 17:10:51 by maiboyer ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
@ -18,5 +18,6 @@
void *me_malloc(t_usize size); void *me_malloc(t_usize size);
void *me_calloc(t_usize elem_count, t_usize elem_size); void *me_calloc(t_usize elem_count, t_usize elem_size);
void *me_realloc(void *ptr, t_usize size); void *me_realloc(void *ptr, t_usize size);
void *me_realloc_array(void *ptr, t_usize elem_size, t_usize elem_count);
#endif /* ALLOC_H */ #endif /* ALLOC_H */

34
stdme/include/me/alloc/alloc_dumb_internal.h Normal file
View file

@ -0,0 +1,34 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* alloc_dumb_internal.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/05/12 15:03:59 by maiboyer #+# #+# */
/* Updated: 2024/05/12 16:42:39 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef ALLOC_DUMB_INTERNAL_H
#define ALLOC_DUMB_INTERNAL_H
#include "me/types.h"
#define PTR_LENS 255
typedef struct s_ptr
{
void *ptr;
t_usize size;
} t_ptr;
typedef struct s_ptr_table
{
t_ptr table[PTR_LENS];
struct s_ptr_table *next;
} t_ptr_table;
t_ptr_table *get_table(void);
#endif /* ALLOC_DUMB_INTERNAL_H */

4
stdme/output/src/vec/buf_str/buf_str.c
View file

@ -43,7 +43,7 @@ t_error vec_buf_str_push(t_vec_buf_str *vec, t_buffer_str element)
new_capacity = (vec->capacity * 3) / 2 + 1; new_capacity = (vec->capacity * 3) / 2 + 1;
while (vec->len + 1 > new_capacity) while (vec->len + 1 > new_capacity)
new_capacity = (new_capacity * 3) / 2 + 1; new_capacity = (new_capacity * 3) / 2 + 1;
vec->buffer = me_realloc(vec->buffer, new_capacity); vec->buffer = me_realloc_array(vec->buffer, new_capacity, sizeof(t_buffer_str));
vec->capacity = new_capacity; vec->capacity = new_capacity;
} }
vec->buffer[vec->len] = element; vec->buffer[vec->len] = element;
@ -63,7 +63,7 @@ t_error vec_buf_str_reserve(t_vec_buf_str *vec, t_usize wanted_capacity)
new_capacity = (vec->capacity * 3) / 2 + 1; new_capacity = (vec->capacity * 3) / 2 + 1;
while (wanted_capacity > new_capacity) while (wanted_capacity > new_capacity)
new_capacity = (new_capacity * 3) / 2 + 1; new_capacity = (new_capacity * 3) / 2 + 1;
vec->buffer = me_realloc(vec->buffer, new_capacity); vec->buffer = me_realloc_array(vec->buffer, new_capacity, sizeof(t_buffer_str));
vec->capacity = new_capacity; vec->capacity = new_capacity;
} }
return (NO_ERROR); return (NO_ERROR);

4
stdme/output/src/vec/str/str.c
View file

@ -43,7 +43,7 @@ t_error vec_str_push(t_vec_str *vec, t_str element)
new_capacity = (vec->capacity * 3) / 2 + 1; new_capacity = (vec->capacity * 3) / 2 + 1;
while (vec->len + 1 > new_capacity) while (vec->len + 1 > new_capacity)
new_capacity = (new_capacity * 3) / 2 + 1; new_capacity = (new_capacity * 3) / 2 + 1;
vec->buffer = me_realloc(vec->buffer, new_capacity); vec->buffer = me_realloc_array(vec->buffer, new_capacity, sizeof(t_str));
vec->capacity = new_capacity; vec->capacity = new_capacity;
} }
vec->buffer[vec->len] = element; vec->buffer[vec->len] = element;
@ -63,7 +63,7 @@ t_error vec_str_reserve(t_vec_str *vec, t_usize wanted_capacity)
new_capacity = (vec->capacity * 3) / 2 + 1; new_capacity = (vec->capacity * 3) / 2 + 1;
while (wanted_capacity > new_capacity) while (wanted_capacity > new_capacity)
new_capacity = (new_capacity * 3) / 2 + 1; new_capacity = (new_capacity * 3) / 2 + 1;
vec->buffer = me_realloc(vec->buffer, new_capacity); vec->buffer = me_realloc_array(vec->buffer, new_capacity, sizeof(t_str));
vec->capacity = new_capacity; vec->capacity = new_capacity;
} }
return (NO_ERROR); return (NO_ERROR);

4
stdme/output/src/vec/u8/u8.c
View file

@ -43,7 +43,7 @@ t_error vec_u8_push(t_vec_u8 *vec, t_u8 element)
new_capacity = (vec->capacity * 3) / 2 + 1; new_capacity = (vec->capacity * 3) / 2 + 1;
while (vec->len + 1 > new_capacity) while (vec->len + 1 > new_capacity)
new_capacity = (new_capacity * 3) / 2 + 1; new_capacity = (new_capacity * 3) / 2 + 1;
vec->buffer = me_realloc(vec->buffer, new_capacity); vec->buffer = me_realloc_array(vec->buffer, new_capacity, sizeof(t_u8));
vec->capacity = new_capacity; vec->capacity = new_capacity;
} }
vec->buffer[vec->len] = element; vec->buffer[vec->len] = element;
@ -63,7 +63,7 @@ t_error vec_u8_reserve(t_vec_u8 *vec, t_usize wanted_capacity)
new_capacity = (vec->capacity * 3) / 2 + 1; new_capacity = (vec->capacity * 3) / 2 + 1;
while (wanted_capacity > new_capacity) while (wanted_capacity > new_capacity)
new_capacity = (new_capacity * 3) / 2 + 1; new_capacity = (new_capacity * 3) / 2 + 1;
vec->buffer = me_realloc(vec->buffer, new_capacity); vec->buffer = me_realloc_array(vec->buffer, new_capacity, sizeof(t_u8));
vec->capacity = new_capacity; vec->capacity = new_capacity;
} }
return (NO_ERROR); return (NO_ERROR);

1
stdme/src.list
View file

@ -1,4 +1,5 @@
alloc/alloc alloc/alloc
alloc/alloc_dumb
alloc/alloc_get_page_from_bloc alloc/alloc_get_page_from_bloc
alloc/get_arena alloc/get_arena
blx/blx blx/blx

115
stdme/src/alloc/alloc.c
View file

@ -6,7 +6,7 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */ /* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2024/05/07 10:13:06 by maiboyer #+# #+# */ /* Created: 2024/05/07 10:13:06 by maiboyer #+# #+# */
/* Updated: 2024/05/12 14:05:48 by maiboyer ### ########.fr */ /* Updated: 2024/05/12 15:02:27 by maiboyer ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
@ -24,59 +24,60 @@
void __libc_free(void *ptr); void __libc_free(void *ptr);
void *me_malloc(t_usize size) // void *me_malloc(t_usize size)
{ // {
t_mblock *block; // t_mblock *block;
void *ret; // void *ret;
//
size = usize_round_up_to(size, 16); // size = usize_round_up_to(size, 16);
printf("Allocating %zu.\n", size); // printf("Allocating %zu.\n", size);
block = get_block_for_size(size); // block = get_block_for_size(size);
if (block == NULL) // if (block
return (me_abort("Found no page for me_malloc"), NULL); // == NULL)
block->used = true; // return (me_abort("Found no page for me_malloc"), NULL);
ret = ((t_u8 *)block->page->data) + block->offset; // block->used = true;
mem_set_zero(ret, block->size); // ret = ((t_u8 *)block->page->data) + block->offset;
return (ret); // mem_set_zero(ret, block->size);
} // return (ret);
// }
void *me_calloc(t_usize elem_size, t_usize elem_count) //
{ // void *me_calloc(t_usize elem_size, t_usize elem_count)
if (elem_size != 0 && elem_count > SIZE_MAX / elem_size) // {
return (NULL); // if (elem_size != 0 && elem_count > SIZE_MAX / elem_size)
return (me_malloc(elem_size * elem_count)); // return (NULL);
} // return (me_malloc(elem_size * elem_count));
// }
void *me_realloc(void *ptr, t_usize new_size) //
{ // void *me_realloc(void *ptr, t_usize new_size)
t_mblock *block; // {
void *ret; // t_mblock *block;
// void *ret;
if (ptr == NULL) //
return (me_malloc(new_size)); // if (ptr == NULL)
block = get_block_from_ptr(ptr); // return (me_malloc(new_size));
if (block == NULL || block->size <= new_size) // block = get_block_from_ptr(ptr);
return (ptr); // if (block == NULL || block->size <= new_size)
if (!merge_next_block(block, new_size)) // return (ptr);
return (ptr); // if (!merge_next_block(block, new_size))
else // return (ptr);
{ // else
ret = me_malloc(new_size); // {
mem_copy(ret, ptr, block->size); // ret = me_malloc(new_size);
me_free(ptr); // mem_copy(ret, ptr, block->size);
return (ret); // me_free(ptr);
} // return (ret);
} // }
// }
void me_free(void *ptr) //
{ // void me_free(void *ptr)
t_mblock *cur; // {
// t_mblock *cur;
if (ptr == NULL) //
return; // if (ptr == NULL)
cur = get_block_from_ptr(ptr); // return;
if (cur == NULL) // cur = get_block_from_ptr(ptr);
return (me_abort("Invalid free (not allocated with me_*alloc)!")); // if (cur == NULL)
cur->used = false; // return (me_abort("Invalid free (not allocated with me_*alloc)!"));
merge_next_block(cur, ~0); // cur->used = false;
} // merge_next_block(cur, ~(t_usize)0);
// }

140
stdme/src/alloc/alloc_dumb.c Normal file
View file

@ -0,0 +1,140 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* alloc_dumb.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/05/12 15:02:37 by maiboyer #+# #+# */
/* Updated: 2024/05/12 17:09:41 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#include "me/alloc/alloc.h"
#include "me/alloc/alloc_dumb_internal.h"
#include "me/fs/putendl_fd.h"
#include "me/mem/mem_copy.h"
#include "me/mem/mem_set_zero.h"
#include <stdlib.h>
void *__libc_malloc(size_t size);
void __libc_free(void *ptr);
t_ptr_table *get_table(void)
{
static t_ptr_table *table = NULL;
if (table == NULL)
{
table = __libc_malloc(sizeof(*table));
if (table == NULL)
(me_putendl_fd("Failed to alloc ptr array", 2), exit(1));
mem_set_zero(table, sizeof(*table));
}
return (table);
}
t_ptr *find_ptr(void *ptr)
{
t_usize i;
t_ptr_table *t;
t = get_table();
i = 0;
while (t)
{
while (i < PTR_LENS)
{
if (t->table[i].ptr == ptr)
return (&t->table[i]);
i++;
}
t = t->next;
}
return (NULL);
}
void print_pages_info(void)
{
}
#include <stdio.h>
void *me_malloc(t_usize size)
{
t_ptr_table *table;
t_ptr *ret;
// printf("ALLOC %zu\n", size);
ret = find_ptr(NULL);
if (ret == NULL)
{
table = get_table();
while (table->next != NULL)
table = table->next;
table->next = __libc_malloc(size);
if (table->next == NULL)
(me_abort("Failed to alloc ptr array"));
mem_set_zero(table->next, sizeof(*table));
ret = &table->next->table[0];
}
ret->ptr = __libc_malloc(size);
if (ret->ptr == NULL)
me_abort("Failed to malloc!");
ret->size = size;
mem_set_zero(ret->ptr, size);
return (ret->ptr);
}
void *me_calloc(t_usize elem_count, t_usize elem_size)
{
// printf("CALLOC %zu * %zu\n", elem_count, elem_size);
if (elem_size != 0 && elem_count > SIZE_MAX / elem_size)
return (me_abort("calloc overflow!"), NULL);
return (me_malloc(elem_size * elem_count));
}
void *me_realloc(void *ptr, t_usize size)
{
t_ptr *p;
t_ptr tmp;
if (ptr == NULL)
return (me_malloc(size));
// printf("REALLOC %p %zu\n", ptr, size);
p = find_ptr(ptr);
if (p == NULL)
return (me_abort("realloc with wrong ptr"), NULL);
if (p->size >= size)
return (p->ptr);
tmp.size = size;
tmp.ptr = __libc_malloc(size);
if (tmp.ptr == NULL)
me_abort("failed to malloc...");
mem_copy(tmp.ptr, p->ptr, p->size);
__libc_free(p->ptr);
*p = tmp;
return (tmp.ptr);
}
void *me_realloc_array(void *ptr, t_usize elem_size, t_usize elem_count)
{
// printf("CALLOC %zu * %zu\n", elem_count, elem_size);
if (elem_size != 0 && elem_count > SIZE_MAX / elem_size)
return (me_abort("realloc_array overflow !"), NULL);
return (me_realloc(ptr, elem_size * elem_count));
}
void me_free(void *ptr)
{
t_ptr *p;
// printf("FREE\n");
p = find_ptr(ptr);
if (p != NULL)
{
__libc_free(p->ptr);
p->ptr = NULL;
p->size = 0;
}
}

331
stdme/src/alloc/get_arena.c
View file

@ -6,7 +6,7 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */ /* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2024/05/07 09:47:50 by maiboyer #+# #+# */ /* Created: 2024/05/07 09:47:50 by maiboyer #+# #+# */
/* Updated: 2024/05/12 14:03:55 by maiboyer ### ########.fr */ /* Updated: 2024/05/12 15:02:02 by maiboyer ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
@ -25,168 +25,167 @@
void *__libc_malloc(size_t size); void *__libc_malloc(size_t size);
void __libc_free(void *ptr); void __libc_free(void *ptr);
void free_ifn(void *ptr) //
{ // void free_ifn(void *ptr)
if (ptr != NULL) // {
__libc_free(ptr); // if (ptr != NULL)
} // __libc_free(ptr);
// }
t_mpage *alloc_page(t_usize size) //
{ // t_mpage *alloc_page(t_usize size)
t_mpage *page; // {
void *data; // t_mpage *page;
t_mblock *block; // void *data;
// t_mblock *block;
size = usize_round_up_to(size, PAGE_SIZE_DEFAULT); //
page = __libc_malloc(sizeof(t_mpage)); // size = usize_round_up_to(size, PAGE_SIZE_DEFAULT);
block = __libc_malloc(sizeof(t_mblock)); // page = __libc_malloc(sizeof(t_mpage));
data = __libc_malloc(size); // block = __libc_malloc(sizeof(t_mblock));
if (page == NULL || data == NULL || block == NULL || PAGE_SIZE_DEFAULT <= 0) // data = __libc_malloc(size);
return (free_ifn(page), free_ifn(data), free_ifn(block), NULL); // if (page == NULL || data == NULL || block == NULL ||
page->data = data; // PAGE_SIZE_DEFAULT <= (t_usize)0)
page->next = NULL; // return (free_ifn(page), free_ifn(data), free_ifn(block), NULL);
page->page_size = size; // page->data = data;
page->first = block; // page->next = NULL;
block->offset = 0; // page->page_size = size;
block->page = page; // page->first = block;
block->next = NULL; // block->offset = 0;
block->used = false; // block->page = page;
block->size = size; // block->next = NULL;
mem_copy(block->padding, BLOCK_PADDING, 7); // block->used = false;
return (page); // block->size = size;
} // mem_copy(block->padding, BLOCK_PADDING, 7);
// return (page);
t_mpage *get_head_arena(void) // }
{ //
static t_mpage *val = NULL; // t_mpage *get_head_arena(void)
// {
if (val == NULL) // static t_mpage *val = NULL;
{ //
val = alloc_page(PAGE_SIZE_DEFAULT); // if (val == NULL)
if (val == NULL) // {
(me_putstr_fd("Failed to alloc first page", 2), exit(1)); // val = alloc_page(PAGE_SIZE_DEFAULT);
} // if (val == NULL)
return (val); // (me_putstr_fd("Failed to alloc first page", 2), exit(1));
} // }
// return (val);
t_mblock *split_block(t_mblock *self, t_usize min_size) // }
{ //
t_usize remaining; // t_mblock *split_block(t_mblock *self, t_usize min_size)
t_mblock *old_next; // {
t_mblock *new_next; // t_usize remaining;
// t_mblock *new_next;
min_size = usize_round_up_to(min_size, 16); //
if (self->size > min_size) // min_size = usize_round_up_to(min_size, 16);
{ // if (self->size > min_size)
remaining = self->size - min_size; // {
new_next = __libc_malloc(sizeof(t_mblock)); // remaining = self->size - min_size - 1;
if (new_next == NULL) // new_next = __libc_malloc(sizeof(t_mblock));
return (me_abort("Failed to alloc block"), NULL); // if (new_next == NULL)
printf("splitting %zu into %zu and %zu\n", self->size, min_size, // return (me_abort("Failed to alloc block"), NULL);
remaining); // printf("splitting %zu into %zu and %zu\n", self->size, min_size,
self->size = min_size; // remaining);
old_next = self->next; // self->size = min_size;
new_next->page = self->page; // new_next->page = self->page;
new_next->next = old_next; // new_next->next = self->next;
new_next->offset = self->offset + self->size; // new_next->offset = self->offset + self->size + 1;
new_next->used = false; // new_next->used = false;
new_next->size = remaining; // new_next->size = remaining;
mem_copy(new_next->padding, BLOCK_PADDING, 7); // mem_copy(new_next->padding, BLOCK_PADDING, 7);
self->next = new_next; // self->next = new_next;
} // }
return (self); // return (self);
} // }
//
t_mblock *get_block_for_size(t_usize size) // t_mblock *get_block_for_size(t_usize size)
{ // {
t_mblock *last; // t_mblock *last;
t_mblock *cur; // t_mblock *cur;
//
last = NULL; // last = NULL;
cur = get_head_arena()->first; // cur = get_head_arena()->first;
printf("cur == %p\n", cur); // while (cur)
while (cur) // {
{ // if (cur->page == NULL)
if (cur->page == NULL) // me_abort("block doesn't have a page ?????");
me_abort("block doesn't have a page ?????"); // if (!cur->used && cur->size >= size)
if (!cur->used && cur->size >= size) // return (split_block(cur, size));
return (split_block(cur, size)); // last = cur;
last = cur; // cur = cur->next;
cur = cur->next; // }
} // if (last == NULL)
if (last == NULL) // return (NULL);
return (NULL); // last->page->next = alloc_page(size);
last->page->next = alloc_page(size); // if (last->page->next == NULL)
if (last->page->next == NULL) // me_abort("Failed to alloc page!");
me_abort("Failed to alloc page!"); // last->next = last->page->next->first;
last->next = last->page->next->first; // return (split_block(last->page->next->first, size));
return (split_block(last->page->next->first, size)); // }
} //
// t_mblock *get_block_from_ptr(void *ptr)
t_mblock *get_block_from_ptr(void *ptr) // {
{ // t_mpage *page;
t_mpage *page; // t_mblock *block;
t_mblock *block; //
// page = get_page_from_ptr(ptr);
page = get_page_from_ptr(ptr); // if (page == NULL)
if (page == NULL) // return (NULL);
return (NULL); // block = page->first;
block = page->first; // while (block && block->page == page)
while (block && block->page == page) // {
{ // if (((t_u8 *)page->data) + block->offset == (t_u8 *)ptr)
if ((t_u8 *)page->data + block->offset == (t_u8 *)ptr) // return (block);
return (block); // block = block->next;
block = block->next; // }
} // return (NULL);
return (NULL); // }
} //
// t_mpage *get_page_from_ptr(void *ptr)
t_mpage *get_page_from_ptr(void *ptr) // {
{ // t_mpage *page;
t_mpage *page; //
// page = get_head_arena();
page = get_head_arena(); // while (page)
while (page) // {
{ // if ((t_u8 *)page->data <= (t_u8 *)ptr &&
if ((t_u8 *)page->data <= (t_u8 *)ptr && // (t_u8 *)ptr < (((t_u8 *)page->data) + page->page_size))
(t_u8 *)ptr < ((t_u8 *)page->data + page->page_size)) // return (page);
return (page); // page = page->next;
page = page->next; // }
} // return (NULL);
return (NULL); // }
} //
// void print_pages_info(void)
void print_pages_info(void) // {
{ // t_mpage *page;
t_mpage *page; // t_i32 page_nb;
t_i32 page_nb; //
// page = get_head_arena();
page = get_head_arena(); // page_nb = 0;
page_nb = 0; // while (page != NULL)
while (page != NULL) // {
{ // me_putstr_fd("Page ", 2);
me_putstr_fd("Page ", 2); // me_putnbr_fd(page_nb++, 2);
me_putnbr_fd(page_nb++, 2); // me_putstr_fd(" with size ", 2);
me_putstr_fd(" with size ", 2); // me_putnbr_fd((t_i32)page->page_size, 2);
me_putnbr_fd((t_i32)page->page_size, 2); // me_putstr_fd("\n", 2);
me_putstr_fd("\n", 2); // page = page->next;
page = page->next; // }
} // }
} //
// bool merge_next_block(t_mblock *cur, t_usize min_size)
t_error merge_next_block(t_mblock *cur, t_usize min_size) // {
{ // t_mblock *next;
t_mblock *next; //
// if (cur->next != NULL && cur->page == cur->next->page && !cur->next->used &&
if (cur->next != NULL && cur->page == cur->next->page && !cur->next->used && // cur->size + cur->next->size >= min_size)
cur->size + cur->next->size >= min_size) // {
{ // cur->size += cur->next->size;
cur->size += cur->next->size; // next = cur->next;
next = cur->next; // cur->next = cur->next->next;
cur->next = cur->next->next; // printf("merging two blocks %p and %p\n", cur, cur->next);
printf("merging two blocks %p and %p\n", cur, cur->next); // __libc_free(next);
__libc_free(next); // return (NO_ERROR);
return (NO_ERROR); // }
} // return (ERROR);
return (ERROR); // }
}

95
stdme/src/os/exit.c
View file

@ -6,45 +6,86 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */ /* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2024/05/07 13:08:52 by maiboyer #+# #+# */ /* Created: 2024/05/07 13:08:52 by maiboyer #+# #+# */
/* Updated: 2024/05/12 14:07:28 by maiboyer ### ########.fr */ /* Updated: 2024/05/12 17:05:27 by maiboyer ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
#include "me/alloc/alloc_dumb_internal.h"
#include "me/alloc/alloc_internal.h" #include "me/alloc/alloc_internal.h"
#include "me/fs/putendl_fd.h" #include "me/fs/putendl_fd.h"
#include "me/fs/putnbr_fd.h" #include "me/fs/putnbr_fd.h"
#include "me/fs/putstr_fd.h"
#include "me/types.h" #include "me/types.h"
#include <stdlib.h> #include <stdlib.h>
void __libc_free(void *ptr); void __libc_free(void *ptr);
// void uninit_allocator(void)
// {
// t_mpage *page;
// void *tmp;
// t_mblock *block;
// t_usize count_block;
//
// page = get_head_arena();
// count_block = 0;
// block = page->first;
// while (block)
// {
// if (block->used)
// count_block += 1;
// tmp = block->next;
// __libc_free(block);
// block = tmp;
// }
// while (page)
// {
// tmp = page->next;
// __libc_free(page->data);
// __libc_free(page);
// page = tmp;
// }
// if (count_block != 0)
// (me_putnbr_fd(count_block, 2),
// me_putendl_fd(" Blocks weren't freed when exiting !", 2));
// }
void uninit_allocator(void)
{
t_ptr_table *table;
t_ptr_table *table_next;
t_usize i;
t_usize unfree_count;
unfree_count = 0;
table = get_table();
while (table)
{
i = 0;
while (i < PTR_LENS)
{
if (table->table[i].ptr != NULL)
{
__libc_free(table->table[i].ptr);
unfree_count++;
}
i++;
}
table_next = table->next;
__libc_free(table);
table = table_next;
}
if (unfree_count != 0)
{
me_putstr_fd("A total of ", 2);
me_putnbr_fd(unfree_count, 2);
me_putendl_fd(" blocks weren't freed !", 2);
}
}
void me_exit(t_i32 exit_code) void me_exit(t_i32 exit_code)
{ {
t_mpage *page; uninit_allocator();
void *tmp;
t_mblock *block;
t_usize count_block;
page = get_head_arena();
count_block = 0;
block = page->first;
while (block)
{
if (block->used)
count_block += 1;
tmp = block->next;
__libc_free(block);
block = tmp;
}
while (page)
{
tmp = page->next;
__libc_free(page->data);
__libc_free(page);
page = tmp;
}
if (count_block != 0)
(me_putnbr_fd(count_block, 2),
me_putendl_fd(" Blocks weren't freed when exiting !", 2));
exit(exit_code); exit(exit_code);
} }