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

Merge remote-tracking branch 'origin/master'

Browse source
This commit is contained in:
Raphael (rparodi) 2024-07-30 17:25:04 +02:00
commit 25e6159748
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> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* 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
#define PIPE_H
#ifndef PPIPE_H
#define PPIPE_H
#include "me/fs/fs.h"
#include "me/types.h"

81
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> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* 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
#define PROCESS_H
#ifndef PPROCESS_H
#define PPROCESS_H
#include "me/fs/fs.h"
#include "me/types.h"
@ -21,87 +21,90 @@
typedef t_i32 t_pid;
typedef t_i32 t_exit_code;
enum e_redirection
enum e_p_redirection
{
R_INHERITED = 0,
R_PIPED = 1,
R_FD = 2,
PR_INHERITED = 0,
PR_PIPED = 1,
PR_FD = 2,
};
union u_redirection {
struct s_fd_redirection
union u_p_redirection {
struct s_pfd_redirection
{
t_fd *value;
} fd;
struct s_piped_redirection
struct s_ppiped_redirection
{
} piped;
struct s_inherited_redirection
struct s_pinherited_redirection
{
} inherited;
};
/// @brief Redirection for spawning a process
typedef struct s_process_redirection
typedef struct s_p_redirection
{
enum e_redirection tag;
union u_redirection vals;
} t_redirection;
enum e_p_redirection tag;
union u_p_redirection vals;
} t_p_redirection;
/// @brief Create a piped redirection
/// @param void
/// @return the redirection
static inline t_redirection piped(void)
static inline t_p_redirection ppiped(void)
{
return ((t_redirection){
.tag = R_PIPED,
return ((t_p_redirection){
.tag = PR_PIPED,
});
}
/// @brief Create an inherited redirection (inherit from the parent process)
/// @param void
/// @return the redirection
static inline t_redirection inherited(void)
static inline t_p_redirection pinherited(void)
{
return ((t_redirection){
.tag = R_INHERITED,
return ((t_p_redirection){
.tag = PR_INHERITED,
});
}
/// @brief Create a file descriptor redirection
/// @param fd file descriptor to redirect
/// @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,
.vals = (union u_redirection){
.fd = {.value = fd},
}});
return ((t_p_redirection){.tag = PR_FD,
.vals = (union u_p_redirection){
.fd = {.value = fd},
}});
}
/// @brief Spawn information
typedef struct s_exec_spawn_info
typedef struct s_p_spawn_info
{
t_redirection stdin;
t_redirection stdout;
t_redirection stderr;
t_vec_str arguments;
t_vec_str environement;
t_str binary_path;
t_p_redirection stdin;
t_p_redirection stdout;
t_p_redirection stderr;
t_vec_str arguments;
t_vec_str environement;
t_str binary_path;
void (*forked_free)(void *);
void *forked_free_args;
} t_exec_spawn_info;
} t_p_spawn_info;
/// @brief Process information
typedef struct s_process
typedef struct s_p_process
{
t_pid pid;
} t_exec_process;
t_fd *stdin;
t_fd *stderr;
t_fd *stdout;
t_pid pid;
} t_p_process;
/// @brief Spawn a new process with the given information
/// @param info the information to spawn the process
/// @param process data returned by the function
/// @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 */

8
exec/src/run_ast.c
View file

@ -6,15 +6,15 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* 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 "ast/ast.h"
#include "exec/run.h"
#include "exec/spawn_cmd/pipe.h"
#include "exec/spawn_cmd/process.h"
#include "exec/spawn_cmd/ppipe.h"
#include "exec/spawn_cmd/pprocess.h"
#include "me/convert/numbers_to_str.h"
#include "me/hashmap/hashmap_env.h"
#include "me/mem/mem.h"
@ -42,7 +42,7 @@ typedef struct s_command_result t_command_result;
struct s_command_result
{
t_process process;
t_p_process process;
};
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> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* 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/process.h"
#include "exec/spawn_cmd/ppipe.h"
#include "exec/spawn_cmd/pprocess.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);
}

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

@ -6,11 +6,11 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* 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/str/str.h"

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

@ -6,12 +6,12 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* 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/pipe.h"
#include "exec/spawn_cmd/pprocess.h"
#include "exec/spawn_cmd/ppipe.h"
#include "me/mem/mem.h"
#include "me/printf/printf.h"
#include "me/str/str.h"
@ -25,12 +25,13 @@
bool exec_find_path(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;
(void)(process);
if (info.forked_free)
info.forked_free(info.forked_free_args);
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);
}
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_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);
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), 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_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))
return (ERROR);
}
if (access(s.buf, X_OK | R_OK) == 0)
if (access(s.buf, X_OK) == 0)
{
mem_free(info->binary_path);
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);
}
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)
close(process->stdin.vals.ro.fd);
if (cleanup_process && process->stdout.tag != INVALID)
close(process->stdout.vals.ro.fd);
if (cleanup_process && process->stderr.tag != INVALID)
close(process->stderr.vals.ro.fd);
close(info.stdin.vals.fd.value);
close(info.stdout.vals.fd.value);
close(info.stderr.vals.fd.value);
if (cleanup_process && process->stdin != NULL)
close_fd(process->stdin);
if (cleanup_process && process->stdout != NULL)
close_fd(process->stdout);
if (cleanup_process && process->stderr != NULL)
close_fd(process->stderr);
close_fd(info.stdin.vals.fd.value);
close_fd(info.stdout.vals.fd.value);
close_fd(info.stderr.vals.fd.value);
vec_str_free(info.arguments);
vec_str_free(info.environement);
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))
return (exec_cleanup(info, process, true), ERROR);
return (cleanup(info, process, true), ERROR);
if (exec_find_binary(&info, process))
return (exec_cleanup(info, process, true), ERROR);
return (cleanup(info, process, true), ERROR);
process->pid = fork();
if (process->pid == 0)
(exec_spawn_process_exec(info, process), exit(1));
else
{
exec_cleanup(info, process, false);
cleanup(info, process, false);
if (process->pid == -1)
return (ERROR);
}

4
input.toml
View file

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

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

@ -13,21 +13,21 @@
#ifndef VEC_REDIR_H
#define VEC_REDIR_H
#include "exec/spawn_cmd/_redirection.h"
#include "exec/spawn_cmd/pprocess.h"
#include "me/types.h"
/// @brief A function that takes two t_exec_redirect and compare them
typedef bool (*t_vec_redir_sort_fn)(t_exec_redirect *, t_exec_redirect *);
/// @brief A function that free an t_exec_redirect
typedef void (*t_free_redir_item)(t_exec_redirect);
/// @brief A function that takes two t_p_redirection and compare them
typedef bool (*t_vec_redir_sort_fn)(t_p_redirection *, t_p_redirection *);
/// @brief A function that free an t_p_redirection
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
{
t_free_redir_item free_func;
t_usize len;
t_usize capacity;
t_exec_redirect *buffer;
t_p_redirection *buffer;
} t_vec_redir;
/// @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
/// @param vec The vec_redir to push the element to
/// @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
/// @param vec The vec_redir to push the element to
/// @param element The element to push
/// @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
/// @param vec The vec_redir to get the element from
/// @param[out] out The last element of the vec_redir
/// @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
@ -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
/// @return true if the operation failed, false otherwise
/// @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
/// @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 fn The function to run on each element
/// @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
@ -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 starting_index The index to start the search from
/// @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
/// @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
/// @return true if the operation failed, false otherwise
/// @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
/// @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
/// @return true if the operation failed, false otherwise
/// @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
/// @param vec The vec_redir to iterate over
/// @param fn The function to run on each element
/// @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
/// @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[out] out A pointer to the last element of the vec_redir
/// @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

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.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)
out.capacity = capacity;
return (out);
}
/// 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)
return (ERROR);
@ -52,7 +52,7 @@ t_error vec_redir_reserve(t_vec_redir *vec, t_usize wanted_capacity)
while (wanted_capacity > new_capacity)
new_capacity = (new_capacity * 3) / 2 + 1;
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;
}
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
/// 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_exec_redirect *ptr;
t_p_redirection temp_value;
t_p_redirection *ptr;
if (vec == NULL)
return (ERROR);
@ -74,7 +74,7 @@ t_error vec_redir_pop(t_vec_redir *vec, t_exec_redirect *value)
ptr = &temp_value;
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);
}

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

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

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

@ -18,7 +18,7 @@
#include <stdlib.h>
t_error vec_redir_push_front(t_vec_redir *vec,
t_exec_redirect element)
t_p_redirection element)
{
t_usize i;
@ -39,7 +39,7 @@ t_error vec_redir_push_front(t_vec_redir *vec,
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;
@ -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)
{
t_exec_redirect temporary;
t_p_redirection temporary;
t_usize i;
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)
out = &temporary;