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

Compiling!

Browse source
This commit is contained in:
Maieul BOYER 2024-04-30 14:20:06 +02:00
parent 019d25174c
commit a22b9ea234
No known key found for this signature in database
24 changed files with 607 additions and 113 deletions
Download patch file Download diff file Expand all files Collapse all files

58
output/include/me/vec/vec_parser_heredoc.h Normal file
View file

@ -0,0 +1,58 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* vec_parser_heredoc.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/12/04 18:46:53 by maiboyer #+# #+# */
/* Updated: 2023/12/09 17:53:00 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef VEC_PARSER_HEREDOC_H
#define VEC_PARSER_HEREDOC_H
#include "parser/types/types_heredoc.h"
#include "me/types.h"
typedef bool (*t_vec_parser_heredoc_sort_fn)(t_heredoc *, t_heredoc *);
typedef void (*t_free_parser_heredoc_item)(t_heredoc);
typedef struct s_vec_parser_heredoc
{
t_free_parser_heredoc_item free_func;
t_usize len;
t_usize capacity;
t_heredoc *buffer;
} t_vec_parser_heredoc;
t_vec_parser_heredoc vec_parser_heredoc_new(t_usize capacity,
t_free_parser_heredoc_item free_function);
t_error vec_parser_heredoc_push(t_vec_parser_heredoc *vec, t_heredoc element);
t_error vec_parser_heredoc_push_front(t_vec_parser_heredoc *vec,
t_heredoc element);
t_error vec_parser_heredoc_pop(t_vec_parser_heredoc *vec, t_heredoc *value);
t_error vec_parser_heredoc_pop_front(t_vec_parser_heredoc *vec, t_heredoc *value);
void vec_parser_heredoc_free(t_vec_parser_heredoc vec);
t_error vec_parser_heredoc_reserve(t_vec_parser_heredoc *vec,
t_usize wanted_capacity);
t_error vec_parser_heredoc_find(t_vec_parser_heredoc *vec,
bool (*fn)(const t_heredoc *), t_usize *index);
t_error vec_parser_heredoc_find_starting(t_vec_parser_heredoc *vec,
bool (*fn)(const t_heredoc *),
t_usize starting_index, t_usize *index);
t_error vec_parser_heredoc_all(t_vec_parser_heredoc *vec,
bool (*fn)(const t_heredoc *), bool *result);
t_error vec_parser_heredoc_any(t_vec_parser_heredoc *vec,
bool (*fn)(const t_heredoc *), bool *result);
void vec_parser_heredoc_iter(t_vec_parser_heredoc *vec,
void (*fn)(t_usize index, t_heredoc *value,
void *state),
void *state);
void vec_parser_heredoc_reverse(t_vec_parser_heredoc *vec);
void vec_parser_heredoc_sort(t_vec_parser_heredoc *vec,
t_vec_parser_heredoc_sort_fn is_sorted);
t_error vec_parser_heredoc_back(t_vec_parser_heredoc *vec, t_heredoc **out);
#endif

1
output/include/me/vec/vec_parser_range.h
View file

@ -53,5 +53,6 @@ void vec_parser_range_iter(t_vec_parser_range *vec,
void vec_parser_range_reverse(t_vec_parser_range *vec);
void vec_parser_range_sort(t_vec_parser_range *vec,
t_vec_parser_range_sort_fn is_sorted);
t_error vec_parser_range_back(t_vec_parser_range *vec, t_parser_range **out);
#endif

115
output/src/vec/vec_parser_heredoc.c Normal file
View file

@ -0,0 +1,115 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* vec_parser_heredoc.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_parser_heredoc.h"
#include <stdlib.h>
t_vec_parser_heredoc vec_parser_heredoc_new(t_usize capacity,
t_free_parser_heredoc_item free_function)
{
t_vec_parser_heredoc out;
out = (t_vec_parser_heredoc){0};
out.free_func = free_function;
out.buffer = mem_alloc_array(capacity, sizeof(t_heredoc));
if (out.buffer)
out.capacity = capacity;
return (out);
}
/// 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)
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_heredoc));
if (temp_buffer == NULL)
return (ERROR);
mem_copy(temp_buffer, vec->buffer, vec->len * sizeof(t_heredoc));
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_parser_heredoc_reserve(t_vec_parser_heredoc *vec, t_usize wanted_capacity)
{
t_heredoc *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_heredoc));
if (temp_buffer == NULL)
return (ERROR);
mem_copy(temp_buffer, vec->buffer, vec->len * sizeof(t_heredoc));
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_parser_heredoc_pop(t_vec_parser_heredoc *vec, t_heredoc *value)
{
t_heredoc temp_value;
t_heredoc *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_heredoc));
return (NO_ERROR);
}
/// This function is safe to call with `free_elem` being NULL
void vec_parser_heredoc_free(t_vec_parser_heredoc vec)
{
if (vec.free_func)
{
while (vec.len)
{
vec.free_func(vec.buffer[vec.len - 1]);
vec.len--;
}
}
free(vec.buffer);
}

112
output/src/vec/vec_parser_heredoc_functions2.c Normal file
View file

@ -0,0 +1,112 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* vec_parser_heredoc.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_parser_heredoc.h"
#include <stdlib.h>
t_error vec_parser_heredoc_find(t_vec_parser_heredoc *vec,
bool (*fn)(const t_heredoc *), 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_parser_heredoc_find_starting(t_vec_parser_heredoc *vec,
bool (*fn)(const t_heredoc *),
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_parser_heredoc_all(t_vec_parser_heredoc *vec,
bool (*fn)(const t_heredoc *), 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_parser_heredoc_any(t_vec_parser_heredoc *vec,
bool (*fn)(const t_heredoc *), 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_parser_heredoc_iter(t_vec_parser_heredoc *vec,
void (*fn)(t_usize index, t_heredoc *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++;
}
}

84
output/src/vec/vec_parser_heredoc_functions3.c Normal file
View file

@ -0,0 +1,84 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* vec_parser_heredoc.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_parser_heredoc.h"
#include <stdlib.h>
t_error vec_parser_heredoc_push_front(t_vec_parser_heredoc *vec,
t_heredoc element)
{
t_usize i;
if (vec->len == 0)
return (vec_parser_heredoc_push(vec, element));
i = vec->len - 1;
if (vec->capacity < vec->len + 1 &&
vec_parser_heredoc_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_parser_heredoc_pop_front(t_vec_parser_heredoc *vec, t_heredoc *value)
{
t_usize i;
if (vec->len <= 1)
return (vec_parser_heredoc_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_parser_heredoc_reverse(t_vec_parser_heredoc *vec)
{
t_heredoc 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_parser_heredoc_back(t_vec_parser_heredoc *vec, t_heredoc **out)
{
t_heredoc *temporary;
if (out == NULL)
out = &temporary;
if (vec->len != 0)
return (*out = &vec->buffer[vec->len - 1], true);
return (false);
}

11
output/src/vec/vec_parser_range_functions3.c
View file

@ -71,3 +71,14 @@ void vec_parser_range_reverse(t_vec_parser_range *vec)
i++;
}
}
t_error vec_parser_range_back(t_vec_parser_range *vec, t_parser_range **out)
{
t_parser_range *temporary;
if (out == NULL)
out = &temporary;
if (vec->len != 0)
return (*out = &vec->buffer[vec->len - 1], true);
return (false);
}