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

Still working on the exec part

Browse source
This commit is contained in:
Maieul BOYER 2024-07-30 17:16:28 +02:00
parent 9b1574b9c4
commit e5498d92bc
No known key found for this signature in database
12 changed files with 123 additions and 178 deletions
Download patch file Download diff file Expand all files Collapse all files

62
exec/include/exec/spawn_cmd/_redirection.h
View file

@ -1,62 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* _redirection.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/07/29 17:24:19 by maiboyer #+# #+# */
/* Updated: 2024/07/30 15:56:33 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef _REDIRECTION_H
# define _REDIRECTION_H
# include "me/types.h"
# include "me/fs/fs.h"
typedef union u_exec_redirect t_exec_redirect;
enum e_exec_redirect_kind
{
EXEC_REDIR_FD,
EXEC_REDIR_HEREDOC,
EXEC_REDIR_PIPE,
};
union u_exec_redirect
{
enum e_exec_redirect_kind kind;
struct s_exec_redirect_heredoc
{
enum e_exec_redirect_kind kind;
int in_fd;
t_const_str data;
} heredoc;
struct s_exec_redirect_fd
{
enum e_exec_redirect_kind kind;
int lhs_fd;
int rhs_fd;
t_const_str file_path;
} fd;
struct s_exec_redirect_pipe
{
enum e_exec_redirect_kind kind;
int stdin;
int stdout;
} piped;
};
static inline void free_redirection(t_exec_redirect self)
{
void mem_free(void *ptr);
if (self.kind == EXEC_REDIR_FD)
(void)(self.fd.file_path != NULL && (mem_free((void *)self.fd.file_path), 1));
if (self.kind == EXEC_REDIR_HEREDOC)
(void)(self.heredoc.data != NULL && (mem_free((void *)self.heredoc.data), 1));
}
#endif /* _REDIRECTION_H */

8
exec/include/exec/spawn_cmd/pipe.h → exec/include/exec/spawn_cmd/ppipe.h
View file

@ -1,17 +1,17 @@
/* ************************************************************************** */ /* ************************************************************************** */
/* */ /* */
/* ::: :::::::: */ /* ::: :::::::: */
/* pipe.h :+: :+: :+: */ /* ppipe.h :+: :+: :+: */
/* +:+ +:+ +:+ */ /* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */ /* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2024/01/04 17:57:29 by maiboyer #+# #+# */ /* Created: 2024/01/04 17:57:29 by maiboyer #+# #+# */
/* Updated: 2024/07/30 14:33:50 by maiboyer ### ########.fr */ /* Updated: 2024/07/30 17:03:32 by maiboyer ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
#ifndef PIPE_H #ifndef PPIPE_H
#define PIPE_H #define PPIPE_H
#include "me/fs/fs.h" #include "me/fs/fs.h"
#include "me/types.h" #include "me/types.h"

69
exec/include/exec/spawn_cmd/process.h → exec/include/exec/spawn_cmd/pprocess.h
View file

@ -1,17 +1,17 @@
/* ************************************************************************** */ /* ************************************************************************** */
/* */ /* */
/* ::: :::::::: */ /* ::: :::::::: */
/* process.h :+: :+: :+: */ /* pprocess.h :+: :+: :+: */
/* +:+ +:+ +:+ */ /* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */ /* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2024/01/03 15:43:08 by maiboyer #+# #+# */ /* Created: 2024/01/03 15:43:08 by maiboyer #+# #+# */
/* Updated: 2024/07/30 16:28:05 by maiboyer ### ########.fr */ /* Updated: 2024/07/30 17:06:38 by maiboyer ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
#ifndef PROCESS_H #ifndef PPROCESS_H
#define PROCESS_H #define PPROCESS_H
#include "me/fs/fs.h" #include "me/fs/fs.h"
#include "me/types.h" #include "me/types.h"
@ -21,87 +21,90 @@
typedef t_i32 t_pid; typedef t_i32 t_pid;
typedef t_i32 t_exit_code; typedef t_i32 t_exit_code;
enum e_redirection enum e_p_redirection
{ {
R_INHERITED = 0, PR_INHERITED = 0,
R_PIPED = 1, PR_PIPED = 1,
R_FD = 2, PR_FD = 2,
}; };
union u_redirection { union u_p_redirection {
struct s_fd_redirection struct s_pfd_redirection
{ {
t_fd *value; t_fd *value;
} fd; } fd;
struct s_piped_redirection struct s_ppiped_redirection
{ {
} piped; } piped;
struct s_inherited_redirection struct s_pinherited_redirection
{ {
} inherited; } inherited;
}; };
/// @brief Redirection for spawning a process /// @brief Redirection for spawning a process
typedef struct s_process_redirection typedef struct s_p_redirection
{ {
enum e_redirection tag; enum e_p_redirection tag;
union u_redirection vals; union u_p_redirection vals;
} t_redirection; } t_p_redirection;
/// @brief Create a piped redirection /// @brief Create a piped redirection
/// @param void /// @param void
/// @return the redirection /// @return the redirection
static inline t_redirection piped(void) static inline t_p_redirection ppiped(void)
{ {
return ((t_redirection){ return ((t_p_redirection){
.tag = R_PIPED, .tag = PR_PIPED,
}); });
} }
/// @brief Create an inherited redirection (inherit from the parent process) /// @brief Create an inherited redirection (inherit from the parent process)
/// @param void /// @param void
/// @return the redirection /// @return the redirection
static inline t_redirection inherited(void) static inline t_p_redirection pinherited(void)
{ {
return ((t_redirection){ return ((t_p_redirection){
.tag = R_INHERITED, .tag = PR_INHERITED,
}); });
} }
/// @brief Create a file descriptor redirection /// @brief Create a file descriptor redirection
/// @param fd file descriptor to redirect /// @param fd file descriptor to redirect
/// @return the redirection /// @return the redirection
static inline t_redirection fd(t_fd *fd) static inline t_p_redirection pfd(t_fd *fd)
{ {
return ((t_redirection){.tag = R_FD, return ((t_p_redirection){.tag = PR_FD,
.vals = (union u_redirection){ .vals = (union u_p_redirection){
.fd = {.value = fd}, .fd = {.value = fd},
}}); }});
} }
/// @brief Spawn information /// @brief Spawn information
typedef struct s_exec_spawn_info typedef struct s_p_spawn_info
{ {
t_redirection stdin; t_p_redirection stdin;
t_redirection stdout; t_p_redirection stdout;
t_redirection stderr; t_p_redirection stderr;
t_vec_str arguments; t_vec_str arguments;
t_vec_str environement; t_vec_str environement;
t_str binary_path; t_str binary_path;
void (*forked_free)(void *); void (*forked_free)(void *);
void *forked_free_args; void *forked_free_args;
} t_exec_spawn_info; } t_p_spawn_info;
/// @brief Process information /// @brief Process information
typedef struct s_process typedef struct s_p_process
{ {
t_fd *stdin;
t_fd *stderr;
t_fd *stdout;
t_pid pid; t_pid pid;
} t_exec_process; } t_p_process;
/// @brief Spawn a new process with the given information /// @brief Spawn a new process with the given information
/// @param info the information to spawn the process /// @param info the information to spawn the process
/// @param process data returned by the function /// @param process data returned by the function
/// @return true if an error occured, false otherwise /// @return true if an error occured, false otherwise
t_error spawn_process(t_exec_spawn_info info, t_exec_process *process); t_error pspawn_process(t_p_spawn_info info, t_p_process *process);
#endif /* PROCESS_H */ #endif /* PROCESS_H */

8
exec/src/run_ast.c
View file

@ -6,15 +6,15 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */ /* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2024/07/11 17:22:29 by maiboyer #+# #+# */ /* Created: 2024/07/11 17:22:29 by maiboyer #+# #+# */
/* Updated: 2024/07/30 14:52:09 by maiboyer ### ########.fr */ /* Updated: 2024/07/30 17:03:12 by maiboyer ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
#include "app/state.h" #include "app/state.h"
#include "ast/ast.h" #include "ast/ast.h"
#include "exec/run.h" #include "exec/run.h"
#include "exec/spawn_cmd/pipe.h" #include "exec/spawn_cmd/ppipe.h"
#include "exec/spawn_cmd/process.h" #include "exec/spawn_cmd/pprocess.h"
#include "me/convert/numbers_to_str.h" #include "me/convert/numbers_to_str.h"
#include "me/hashmap/hashmap_env.h" #include "me/hashmap/hashmap_env.h"
#include "me/mem/mem.h" #include "me/mem/mem.h"
@ -42,7 +42,7 @@ typedef struct s_command_result t_command_result;
struct s_command_result struct s_command_result
{ {
t_process process; t_p_process process;
}; };
typedef struct s_word_result t_word_result; typedef struct s_word_result t_word_result;

10
exec/src/spawn_cmd/handle_redirection.c
View file

@ -6,15 +6,17 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */ /* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2024/01/04 22:27:00 by maiboyer #+# #+# */ /* Created: 2024/01/04 22:27:00 by maiboyer #+# #+# */
/* Updated: 2024/07/30 16:03:43 by maiboyer ### ########.fr */ /* Updated: 2024/07/30 17:02:51 by maiboyer ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
#include "exec/spawn_cmd/pipe.h" #include "exec/spawn_cmd/ppipe.h"
#include "exec/spawn_cmd/process.h" #include "exec/spawn_cmd/pprocess.h"
#include "me/types.h" #include "me/types.h"
t_error handle_redirections(t_exec_spawn_info *info, t_exec_process *process) t_error handle_redirections(t_p_spawn_info *info, t_p_process *process)
{ {
(void)(info);
(void)(process);
return (ERROR); return (ERROR);
} }

4
exec/src/spawn_cmd/pipe.c
View file

@ -6,11 +6,11 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */ /* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2024/01/04 17:59:48 by maiboyer #+# #+# */ /* Created: 2024/01/04 17:59:48 by maiboyer #+# #+# */
/* Updated: 2024/07/30 14:48:48 by maiboyer ### ########.fr */ /* Updated: 2024/07/30 17:02:58 by maiboyer ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
#include "exec/spawn_cmd/pipe.h" #include "exec/spawn_cmd/ppipe.h"
#include "me/fs/fs.h" #include "me/fs/fs.h"
#include "me/str/str.h" #include "me/str/str.h"

48
exec/src/spawn_cmd/process.c
View file

@ -6,12 +6,12 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */ /* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2024/01/03 16:22:41 by maiboyer #+# #+# */ /* Created: 2024/01/03 16:22:41 by maiboyer #+# #+# */
/* Updated: 2024/07/30 13:22:17 by maiboyer ### ########.fr */ /* Updated: 2024/07/30 17:03:05 by maiboyer ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
#include "exec/spawn_cmd/process.h" #include "exec/spawn_cmd/pprocess.h"
#include "exec/spawn_cmd/pipe.h" #include "exec/spawn_cmd/ppipe.h"
#include "me/mem/mem.h" #include "me/mem/mem.h"
#include "me/printf/printf.h" #include "me/printf/printf.h"
#include "me/str/str.h" #include "me/str/str.h"
@ -25,12 +25,13 @@
bool exec_find_path(const t_str *s); bool exec_find_path(const t_str *s);
bool exec_find_null(const t_str *s); bool exec_find_null(const t_str *s);
t_error exec_handle_redirections(t_spawn_info *info, t_process *process); t_error exec_handle_redirections(t_p_spawn_info *info, t_p_process *process);
t_error exec_spawn_process_exec(t_spawn_info info, t_process *process) t_error exec_spawn_process_exec(t_p_spawn_info info, t_p_process *process)
{ {
bool res; bool res;
(void)(process);
if (info.forked_free) if (info.forked_free)
info.forked_free(info.forked_free_args); info.forked_free(info.forked_free_args);
if (!vec_str_any(&info.arguments, exec_find_null, &res) && res) if (!vec_str_any(&info.arguments, exec_find_null, &res) && res)
@ -42,7 +43,7 @@ t_error exec_spawn_process_exec(t_spawn_info info, t_process *process)
return (ERROR); return (ERROR);
} }
t_error exec_in_path(t_spawn_info *info, t_process *process, t_const_str path_raw, t_string *s) t_error exec_in_path(t_p_spawn_info *info, t_p_process *process, t_const_str path_raw, t_string *s)
{ {
t_vec_str path; t_vec_str path;
t_usize idx; t_usize idx;
@ -55,13 +56,13 @@ t_error exec_in_path(t_spawn_info *info, t_process *process, t_const_str path_ra
{ {
string_clear(s); string_clear(s);
me_printf_str(s, "%s/%s", path.buffer[idx++], info->binary_path); me_printf_str(s, "%s/%s", path.buffer[idx++], info->binary_path);
if (access(s->buf, X_OK | R_OK) == 0) if (access(s->buf, X_OK) == 0)
return (vec_str_free(path), NO_ERROR); return (vec_str_free(path), NO_ERROR);
} }
return (vec_str_free(path), ERROR); return (vec_str_free(path), ERROR);
} }
t_error exec_find_binary(t_spawn_info *info, t_process *process) t_error exec_find_binary(t_p_spawn_info *info, t_p_process *process)
{ {
t_usize p_idx; t_usize p_idx;
t_string s; t_string s;
@ -79,7 +80,7 @@ t_error exec_find_binary(t_spawn_info *info, t_process *process)
if (exec_in_path(info, process, info->environement.buffer[p_idx], &s)) if (exec_in_path(info, process, info->environement.buffer[p_idx], &s))
return (ERROR); return (ERROR);
} }
if (access(s.buf, X_OK | R_OK) == 0) if (access(s.buf, X_OK) == 0)
{ {
mem_free(info->binary_path); mem_free(info->binary_path);
info->binary_path = s.buf; info->binary_path = s.buf;
@ -88,34 +89,35 @@ t_error exec_find_binary(t_spawn_info *info, t_process *process)
return (string_free(s), ERROR); return (string_free(s), ERROR);
} }
static void exec_cleanup(t_spawn_info info, t_process *process, bool cleanup_process) static void cleanup(t_p_spawn_info info, t_p_process *process, bool cleanup_process)
{ {
if (cleanup_process && process->stdin.tag != INVALID) if (cleanup_process && process->stdin != NULL)
close(process->stdin.vals.ro.fd); close_fd(process->stdin);
if (cleanup_process && process->stdout.tag != INVALID) if (cleanup_process && process->stdout != NULL)
close(process->stdout.vals.ro.fd); close_fd(process->stdout);
if (cleanup_process && process->stderr.tag != INVALID) if (cleanup_process && process->stderr != NULL)
close(process->stderr.vals.ro.fd); close_fd(process->stderr);
close(info.stdin.vals.fd.value); close_fd(info.stdin.vals.fd.value);
close(info.stdout.vals.fd.value); close_fd(info.stdout.vals.fd.value);
close(info.stderr.vals.fd.value); close_fd(info.stderr.vals.fd.value);
vec_str_free(info.arguments); vec_str_free(info.arguments);
vec_str_free(info.environement); vec_str_free(info.environement);
mem_free(info.binary_path); mem_free(info.binary_path);
} }
t_error exec_spawn_process(t_spawn_info info, t_vec_ast *redirection, t_process *process) t_error exec_spawn_process(t_p_spawn_info info, t_vec_ast *redirection, t_p_process *process)
{ {
(void)(redirection);
if (exec_handle_redirections(&info, process)) if (exec_handle_redirections(&info, process))
return (exec_cleanup(info, process, true), ERROR); return (cleanup(info, process, true), ERROR);
if (exec_find_binary(&info, process)) if (exec_find_binary(&info, process))
return (exec_cleanup(info, process, true), ERROR); return (cleanup(info, process, true), ERROR);
process->pid = fork(); process->pid = fork();
if (process->pid == 0) if (process->pid == 0)
(exec_spawn_process_exec(info, process), exit(1)); (exec_spawn_process_exec(info, process), exit(1));
else else
{ {
exec_cleanup(info, process, false); cleanup(info, process, false);
if (process->pid == -1) if (process->pid == -1)
return (ERROR); return (ERROR);
} }

4
input.toml
View file

@ -75,7 +75,7 @@ replace.C__PREFIXUP__ = "ESTR"
[[create.vec]] [[create.vec]]
sources_output = "src/vec/C__PREFIX__/" sources_output = "src/vec/C__PREFIX__/"
headers_output = "include/me/vec/" headers_output = "include/me/vec/"
replace.C__TYPENAME__ = "t_exec_redirect" replace.C__TYPENAME__ = "t_p_redirection"
replace.C__TYPEHEADER__ = '#include "exec/spawn_cmd/_redirection.h"' replace.C__TYPEHEADER__ = '#include "exec/spawn_cmd/pprocess.h"'
replace.C__PREFIX__ = "redir" replace.C__PREFIX__ = "redir"
replace.C__PREFIXUP__ = "REDIR" replace.C__PREFIXUP__ = "REDIR"

34
output/include/me/vec/vec_redir.h
View file

@ -13,21 +13,21 @@
#ifndef VEC_REDIR_H #ifndef VEC_REDIR_H
#define VEC_REDIR_H #define VEC_REDIR_H
#include "exec/spawn_cmd/_redirection.h" #include "exec/spawn_cmd/pprocess.h"
#include "me/types.h" #include "me/types.h"
/// @brief A function that takes two t_exec_redirect and compare them /// @brief A function that takes two t_p_redirection and compare them
typedef bool (*t_vec_redir_sort_fn)(t_exec_redirect *, t_exec_redirect *); typedef bool (*t_vec_redir_sort_fn)(t_p_redirection *, t_p_redirection *);
/// @brief A function that free an t_exec_redirect /// @brief A function that free an t_p_redirection
typedef void (*t_free_redir_item)(t_exec_redirect); typedef void (*t_free_redir_item)(t_p_redirection);
/// @brief A dynamic array of t_exec_redirect /// @brief A dynamic array of t_p_redirection
typedef struct s_vec_redir typedef struct s_vec_redir
{ {
t_free_redir_item free_func; t_free_redir_item free_func;
t_usize len; t_usize len;
t_usize capacity; t_usize capacity;
t_exec_redirect *buffer; t_p_redirection *buffer;
} t_vec_redir; } t_vec_redir;
/// @brief Create a new vec_redir with a given capacity /// @brief Create a new vec_redir with a given capacity
@ -37,19 +37,19 @@ t_vec_redir vec_redir_new(t_usize capacity, t_free_redir_item free_function);
/// @brief Push an element to the last position of the vec_redir /// @brief Push an element to the last position of the vec_redir
/// @param vec The vec_redir to push the element to /// @param vec The vec_redir to push the element to
/// @param element The element to push /// @param element The element to push
t_error vec_redir_push(t_vec_redir *vec, t_exec_redirect element); t_error vec_redir_push(t_vec_redir *vec, t_p_redirection element);
/// @brief Push an element to the first position of the vec_redir /// @brief Push an element to the first position of the vec_redir
/// @param vec The vec_redir to push the element to /// @param vec The vec_redir to push the element to
/// @param element The element to push /// @param element The element to push
/// @note This operation is O(n) /// @note This operation is O(n)
t_error vec_redir_push_front(t_vec_redir *vec, t_exec_redirect element); t_error vec_redir_push_front(t_vec_redir *vec, t_p_redirection element);
/// @brief Get the last element from the vec_redir, and remove it from the vec_redir /// @brief Get the last element from the vec_redir, and remove it from the vec_redir
/// @param vec The vec_redir to get the element from /// @param vec The vec_redir to get the element from
/// @param[out] out The last element of the vec_redir /// @param[out] out The last element of the vec_redir
/// @return true if the operation failed, false otherwise /// @return true if the operation failed, false otherwise
t_error vec_redir_pop(t_vec_redir *vec, t_exec_redirect *value); t_error vec_redir_pop(t_vec_redir *vec, t_p_redirection *value);
/// @brief Get the first element from the vec_redir, and remove it from the vec_redir /// @brief Get the first element from the vec_redir, and remove it from the vec_redir
@ -57,7 +57,7 @@ t_error vec_redir_pop(t_vec_redir *vec, t_exec_redirect *value);
/// @param[out] out The first element of the vec_redir /// @param[out] out The first element of the vec_redir
/// @return true if the operation failed, false otherwise /// @return true if the operation failed, false otherwise
/// @note This operation is O(n) /// @note This operation is O(n)
t_error vec_redir_pop_front(t_vec_redir *vec, t_exec_redirect *value); t_error vec_redir_pop_front(t_vec_redir *vec, t_p_redirection *value);
/// @brief Free the vector and all its elements /// @brief Free the vector and all its elements
/// @param vec The vec_redir to free /// @param vec The vec_redir to free
@ -73,7 +73,7 @@ t_error vec_redir_reserve(t_vec_redir *vec, t_usize wanted_capacity);
/// @param vec The vec_redir to search in /// @param vec The vec_redir to search in
/// @param fn The function to run on each element /// @param fn The function to run on each element
/// @param[out] index The index of the first element that returns true /// @param[out] index The index of the first element that returns true
t_error vec_redir_find(t_vec_redir *vec, bool (*fn)(const t_exec_redirect *), t_usize *index); t_error vec_redir_find(t_vec_redir *vec, bool (*fn)(const t_p_redirection *), t_usize *index);
/// @brief Run the function and returns the index of the first element that returns true, but starting at index starting_index /// @brief Run the function and returns the index of the first element that returns true, but starting at index starting_index
@ -81,7 +81,7 @@ t_error vec_redir_find(t_vec_redir *vec, bool (*fn)(const t_exec_redirect *), t_
/// @param fn The function to run on each element /// @param fn The function to run on each element
/// @param starting_index The index to start the search from /// @param starting_index The index to start the search from
/// @param[out] index The index of the first element that returns true /// @param[out] index The index of the first element that returns true
t_error vec_redir_find_starting(t_vec_redir *vec, bool (*fn)(const t_exec_redirect *), t_usize starting_index, t_usize *index); t_error vec_redir_find_starting(t_vec_redir *vec, bool (*fn)(const t_p_redirection *), t_usize starting_index, t_usize *index);
/// @brief Run the function on every element of the vec_redir and returns if all elements returned true /// @brief Run the function on every element of the vec_redir and returns if all elements returned true
/// @param vec The vec_redir to search in /// @param vec The vec_redir to search in
@ -89,7 +89,7 @@ t_error vec_redir_find_starting(t_vec_redir *vec, bool (*fn)(const t_exec_redire
/// @param[out] result The result of the operation /// @param[out] result The result of the operation
/// @return true if the operation failed, false otherwise /// @return true if the operation failed, false otherwise
/// @note If the vec_redir is empty, result will be true /// @note If the vec_redir is empty, result will be true
t_error vec_redir_all(t_vec_redir *vec, bool (*fn)(const t_exec_redirect *), bool *result); t_error vec_redir_all(t_vec_redir *vec, bool (*fn)(const t_p_redirection *), bool *result);
/// @brief Run the function on every element of the vec_redir and returns if any element returned true /// @brief Run the function on every element of the vec_redir and returns if any element returned true
/// @param vec The vec_redir to search in /// @param vec The vec_redir to search in
@ -97,13 +97,13 @@ t_error vec_redir_all(t_vec_redir *vec, bool (*fn)(const t_exec_redirect *), boo
/// @param[out] result The result of the operation /// @param[out] result The result of the operation
/// @return true if the operation failed, false otherwise /// @return true if the operation failed, false otherwise
/// @note If the vec_redir is empty, result will be false /// @note If the vec_redir is empty, result will be false
t_error vec_redir_any(t_vec_redir *vec, bool (*fn)(const t_exec_redirect *), bool *result); t_error vec_redir_any(t_vec_redir *vec, bool (*fn)(const t_p_redirection *), bool *result);
/// @brief Run the function on every element of the vec_redir /// @brief Run the function on every element of the vec_redir
/// @param vec The vec_redir to iterate over /// @param vec The vec_redir to iterate over
/// @param fn The function to run on each element /// @param fn The function to run on each element
/// @param state The state to pass to the function /// @param state The state to pass to the function
void vec_redir_iter(t_vec_redir *vec, void (*fn)(t_usize index, t_exec_redirect *value, void *state), void *state); void vec_redir_iter(t_vec_redir *vec, void (*fn)(t_usize index, t_p_redirection *value, void *state), void *state);
/// @brief Reverse the order of the elements in the vec_redir /// @brief Reverse the order of the elements in the vec_redir
/// @param vec The vec_redir to reverse /// @param vec The vec_redir to reverse
@ -118,6 +118,6 @@ void vec_redir_sort(t_vec_redir *vec, t_vec_redir_sort_fn is_sorted);
/// @param vec The vec_redir to get the element from /// @param vec The vec_redir to get the element from
/// @param[out] out A pointer to the last element of the vec_redir /// @param[out] out A pointer to the last element of the vec_redir
/// @return true if the operation failed, false otherwise /// @return true if the operation failed, false otherwise
t_error vec_redir_back(t_vec_redir *vec, t_exec_redirect **out); t_error vec_redir_back(t_vec_redir *vec, t_p_redirection **out);
#endif #endif

14
output/src/vec/redir/redir.c
View file

@ -22,14 +22,14 @@ t_vec_redir vec_redir_new(t_usize capacity,
out = (t_vec_redir){0}; out = (t_vec_redir){0};
out.free_func = free_function; out.free_func = free_function;
out.buffer = mem_alloc_array(capacity, sizeof(t_exec_redirect)); out.buffer = mem_alloc_array(capacity, sizeof(t_p_redirection));
if (out.buffer) if (out.buffer)
out.capacity = capacity; out.capacity = capacity;
return (out); return (out);
} }
/// Return true in case of an error /// Return true in case of an error
t_error vec_redir_push(t_vec_redir *vec, t_exec_redirect element) t_error vec_redir_push(t_vec_redir *vec, t_p_redirection element)
{ {
if (vec == NULL) if (vec == NULL)
return (ERROR); return (ERROR);
@ -52,7 +52,7 @@ t_error vec_redir_reserve(t_vec_redir *vec, t_usize wanted_capacity)
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 = vec->buffer =
mem_realloc_array(vec->buffer, new_capacity, sizeof(t_exec_redirect)); mem_realloc_array(vec->buffer, new_capacity, sizeof(t_p_redirection));
vec->capacity = new_capacity; vec->capacity = new_capacity;
} }
return (NO_ERROR); return (NO_ERROR);
@ -60,10 +60,10 @@ t_error vec_redir_reserve(t_vec_redir *vec, t_usize wanted_capacity)
/// Return true if the vector is empty /// Return true if the vector is empty
/// This function is safe to call with value being NULL /// This function is safe to call with value being NULL
t_error vec_redir_pop(t_vec_redir *vec, t_exec_redirect *value) t_error vec_redir_pop(t_vec_redir *vec, t_p_redirection *value)
{ {
t_exec_redirect temp_value; t_p_redirection temp_value;
t_exec_redirect *ptr; t_p_redirection *ptr;
if (vec == NULL) if (vec == NULL)
return (ERROR); return (ERROR);
@ -74,7 +74,7 @@ t_error vec_redir_pop(t_vec_redir *vec, t_exec_redirect *value)
ptr = &temp_value; ptr = &temp_value;
vec->len--; vec->len--;
*ptr = vec->buffer[vec->len]; *ptr = vec->buffer[vec->len];
mem_set_zero(&vec->buffer[vec->len], sizeof(t_exec_redirect)); mem_set_zero(&vec->buffer[vec->len], sizeof(t_p_redirection));
return (NO_ERROR); return (NO_ERROR);
} }

18
output/src/vec/redir/redir_functions2.c
View file

@ -18,7 +18,7 @@
#include <stdlib.h> #include <stdlib.h>
t_error vec_redir_find(t_vec_redir *vec, t_error vec_redir_find(t_vec_redir *vec,
bool (*fn)(const t_exec_redirect *), t_usize *index) bool (*fn)(const t_p_redirection *), t_usize *index)
{ {
t_usize idx; t_usize idx;
@ -27,7 +27,7 @@ t_error vec_redir_find(t_vec_redir *vec,
idx = 0; idx = 0;
while (idx < vec->len) while (idx < vec->len)
{ {
if (fn((const t_exec_redirect *)&vec->buffer[idx])) if (fn((const t_p_redirection *)&vec->buffer[idx]))
{ {
*index = idx; *index = idx;
return (NO_ERROR); return (NO_ERROR);
@ -38,7 +38,7 @@ t_error vec_redir_find(t_vec_redir *vec,
} }
t_error vec_redir_find_starting(t_vec_redir *vec, t_error vec_redir_find_starting(t_vec_redir *vec,
bool (*fn)(const t_exec_redirect *), bool (*fn)(const t_p_redirection *),
t_usize starting_index, t_usize *index) t_usize starting_index, t_usize *index)
{ {
t_usize idx; t_usize idx;
@ -48,7 +48,7 @@ t_error vec_redir_find_starting(t_vec_redir *vec,
idx = starting_index; idx = starting_index;
while (idx < vec->len) while (idx < vec->len)
{ {
if (fn((const t_exec_redirect *)&vec->buffer[idx])) if (fn((const t_p_redirection *)&vec->buffer[idx]))
{ {
*index = idx; *index = idx;
return (NO_ERROR); return (NO_ERROR);
@ -59,7 +59,7 @@ t_error vec_redir_find_starting(t_vec_redir *vec,
} }
t_error vec_redir_all(t_vec_redir *vec, t_error vec_redir_all(t_vec_redir *vec,
bool (*fn)(const t_exec_redirect *), bool *result) bool (*fn)(const t_p_redirection *), bool *result)
{ {
t_usize idx; t_usize idx;
@ -69,7 +69,7 @@ t_error vec_redir_all(t_vec_redir *vec,
*result = true; *result = true;
while (*result && idx < vec->len) while (*result && idx < vec->len)
{ {
if (!fn((const t_exec_redirect *)&vec->buffer[idx])) if (!fn((const t_p_redirection *)&vec->buffer[idx]))
*result = false; *result = false;
idx++; idx++;
} }
@ -77,7 +77,7 @@ t_error vec_redir_all(t_vec_redir *vec,
} }
t_error vec_redir_any(t_vec_redir *vec, t_error vec_redir_any(t_vec_redir *vec,
bool (*fn)(const t_exec_redirect *), bool *result) bool (*fn)(const t_p_redirection *), bool *result)
{ {
t_usize idx; t_usize idx;
@ -87,7 +87,7 @@ t_error vec_redir_any(t_vec_redir *vec,
*result = false; *result = false;
while (*result && idx < vec->len) while (*result && idx < vec->len)
{ {
if (fn((const t_exec_redirect *)&vec->buffer[idx])) if (fn((const t_p_redirection *)&vec->buffer[idx]))
*result = true; *result = true;
idx++; idx++;
} }
@ -95,7 +95,7 @@ t_error vec_redir_any(t_vec_redir *vec,
} }
void vec_redir_iter(t_vec_redir *vec, void vec_redir_iter(t_vec_redir *vec,
void (*fn)(t_usize index, t_exec_redirect *value, void (*fn)(t_usize index, t_p_redirection *value,
void *state), void *state),
void *state) void *state)
{ {

10
output/src/vec/redir/redir_functions3.c
View file

@ -18,7 +18,7 @@
#include <stdlib.h> #include <stdlib.h>
t_error vec_redir_push_front(t_vec_redir *vec, t_error vec_redir_push_front(t_vec_redir *vec,
t_exec_redirect element) t_p_redirection element)
{ {
t_usize i; t_usize i;
@ -39,7 +39,7 @@ t_error vec_redir_push_front(t_vec_redir *vec,
return (NO_ERROR); return (NO_ERROR);
} }
t_error vec_redir_pop_front(t_vec_redir *vec, t_exec_redirect *value) t_error vec_redir_pop_front(t_vec_redir *vec, t_p_redirection *value)
{ {
t_usize i; t_usize i;
@ -59,7 +59,7 @@ t_error vec_redir_pop_front(t_vec_redir *vec, t_exec_redirect *value)
void vec_redir_reverse(t_vec_redir *vec) void vec_redir_reverse(t_vec_redir *vec)
{ {
t_exec_redirect temporary; t_p_redirection temporary;
t_usize i; t_usize i;
i = 0; i = 0;
@ -72,9 +72,9 @@ void vec_redir_reverse(t_vec_redir *vec)
} }
} }
t_error vec_redir_back(t_vec_redir *vec, t_exec_redirect **out) t_error vec_redir_back(t_vec_redir *vec, t_p_redirection **out)
{ {
t_exec_redirect *temporary; t_p_redirection *temporary;
if (out == NULL) if (out == NULL)
out = &temporary; out = &temporary;