starnakin/42_minishell
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Compare commits

base: starnakin:master
Branches Tags
starnakin:master
starnakin:camille
..
compare: starnakin:camille
Branches Tags
starnakin:master
starnakin:camille

No commits in common. "master" and "camille" have entirely different histories.
master ... camille

79 changed files with 1318 additions and 2668 deletions
Show Stats Expand all files Collapse all files

34
Makefile
View File

@ -1,39 +1,13 @@
UTILS_SRC = utils/ft_is_in_quote.c utils/ft_strncpy.c utils/ft_strreplace.c utils/ft_strnchr.c utils/ft_split_charset_quoted.c utils/ft_strshift.c utils/ft_quote_remover.c utils/ft_str_is_empty.c utils/ft_atoi_check.c ./utils/ft_get_executable.c ./utils/fd.c
BUILTINS_SRC = builtins/pwd.c \
builtins/export.c \
builtins/env.c \
builtins/cd.c \
builtins/exit.c \
builtins/unset.c \
builtins/echo.c
SRCS = ${BUILTINS_SRC} \
${UTILS_SRC} \
main.c \
./cmd/cmd.c \
./env/env1.c \
./env/env2.c \
./env/env3.c \
./env/env_fill.c \
./data/data.c \
./execution/execution.c \
./syntax/syntax.c \
./format/format.c \
./redirection/heredoc.c \
./redirection/file.c \
./redirection/redirection.c \
./redirection/check.c \
./parse/parse.c \
./signal/signal.c
UTILS_SRC = utils/ft_is_in_quote.c utils/ft_strncpy.c utils/ft_strreplace.c utils/ft_strnchr.c utils/ft_split_quoted.c utils/ft_strshift.c utils/ft_quote_remover.c utils/ft_str_is_empty.c
SRCS = ${UTILS_SRC} main.c file.c infile.c outfile.c heredoc.c syntatics.c cmd.c cmds.c env.c execution.c spacer.c env_fill.c
OBJS = ${SRCS:.c=.o}
NAME = minishell
CC = clang
CC = gcc
CFLAGS = -Werror -Wextra -Wall -g
CFLAGS = -Werror -Wextra -g
LIBS = libftx/libftx.a

34
bozoshell.h
View File

@ -1,34 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* bozoshell.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: cchauvet <cchauvet@student.42angoulem +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/02/14 13:45:30 by cchauvet #+# #+# */
/* Updated: 2023/04/14 16:16:31 by erey-bet ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef BOZOSHELL_H
# define BOZOSHELL_H
# include "./env/env.h"
# include "./cmd/cmd.h"
# include "./parse/parse.h"
# include "./syntax/syntax.h"
# include "./execution/execution.h"
# include "./builtins/builtins.h"
# include "./format/format.h"
# include "./redirection/redirection.h"
# include "./libftx/libftx.h"
# include "./utils/utils.h"
# include "./data/data.h"
# include "./signal/signal.h"
# include <stdio.h>
# include <readline/readline.h>
# include <readline/history.h>
# include <signal.h>
# include <sys/types.h>
# include <sys/wait.h>
#endif

18
builtins/env.c → builtin/env.c
View File

@ -6,26 +6,20 @@
/* By: cchauvet <cchauvet@student.42angoulem +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/02/14 14:56:02 by cchauvet #+# #+# */
/* Updated: 2023/03/30 15:15:04 by erey-bet ### ########.fr */
/* Updated: 2023/02/14 14:58:40 by cchauvet ### ########.fr */
/* */
/* ************************************************************************** */
#include "./builtins_private.h"
#include "../minishell.h"
int print_env(t_list **env, int fd)
int main(char **env)
{
t_list **head;
t_list *current;
current = *env;
while (current->next != NULL)
while (current != NULL)
{
if (((t_env *)(current->content))->value)
{
ft_putstr_fd(((t_env *)(current->content))->key, fd);
ft_putstr_fd("=", fd);
ft_putstr_fd(((t_env *)(current->content))->value, fd);
write(fd, "\n", 1);
}
ft_putendl_fd(1, current->content);
current = current->next;
}
return (0);

40
builtin/export.c Normal file
View File

@ -0,0 +1,40 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* export.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: cchauvet <cchauvet@student.42angoulem +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/02/14 14:27:08 by cchauvet #+# #+# */
/* Updated: 2023/02/14 14:52:50 by cchauvet ### ########.fr */
/* */
/* ************************************************************************** */
#include "../minishell.h"
int main(char **env)
{
t_list **env_lst;
t_list *current;
char *key;
char *value;
env_lst = init_env(env);
current = *env_lst;
while (current != NULL)
{
value = ft_strchr(current->content, '=') + 1;
key = ft_strndup(current->content,
ft_strlen(current->content) - ft_strlen(value));
if (key == NULL)
{
ft_lstclear(env_lst, env_del);
return (1);
}
ft_printf("declare -x %s=\"%s\"\n", key, value);
free(key);
current = current->next;
}
ft_lstclear(env_lst, env_del);
return (0);
}

26
builtins/builtins.h
View File

@ -1,26 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* builtins.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: cchauvet <cchauvet@student.42angouleme.fr +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/03/27 13:41:30 by cchauvet #+# #+# */
/* Updated: 2023/04/18 12:57:36 by erey-bet ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef BUILTINS_H
# define BUILTINS_H
# include "../libftx/libft/list.h"
int echo(int fd, char **strs);
int pwd(int fd);
char *get_pwd(void);
int print_env(t_list **env, int fd);
int ft_export(t_list **env, char **args, int fd);
int move_folder(char **args, t_list **env, int fd);
int unset(t_list **env, char **args, int fd);
int ft_exit(char **args, int err);
#endif

22
builtins/builtins_private.h
View File

@ -1,22 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* builtins_private.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: cchauvet <cchauvet@student.42angouleme.fr +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/03/27 13:41:42 by cchauvet #+# #+# */
/* Updated: 2023/04/18 12:57:25 by erey-bet ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef BUILTINS_PRIVATE_H
# define BUILTINS_PRIVATE_H
# include <limits.h>
# include "../libftx/libftx.h"
# include "../env/env.h"
# include "../utils/utils.h"
char *get_pwd(void);
#endif

62
builtins/cd.c
View File

@ -1,62 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* cd.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: erey-bet <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/02/20 14:27:36 by erey-bet #+# #+# */
/* Updated: 2023/04/18 13:22:22 by erey-bet ### ########.fr */
/* */
/* ************************************************************************** */
#include "./builtins_private.h"
int make_move(char *path, t_list **env)
{
char *join;
char *old;
join = ft_strjoin("/", path);
join = ft_strfjoin(get_pwd(), join);
old = get_pwd();
if (chdir(join) == 0)
{
set_value_by_key("OLDPWD", old, env);
set_value_by_key("PWD", get_pwd(), env);
free(join);
return (0);
}
free(old);
free(join);
write(2, "cd: No such file or directory\n", 30);
return (1);
}
int move_folder(char **args, t_list **env)
{
char *path;
char *old;
if (args[0] == NULL || args[1] != NULL)
{
write(2, "cd: Wrong number's argument\n", 28);
return (1);
}
path = args[0];
if (path[0] == '/' || ft_strncmp(path, "..", ft_strlen(path)) == 0)
{
old = get_pwd();
if (chdir(path) == 0)
{
set_value_by_key("OLDPWD", old, env);
set_value_by_key("PWD", get_pwd(), env);
return (0);
}
free(old);
write(2, "cd: No such file or directory\n", 30);
return (1);
}
else
return (make_move(path, env));
}

63
builtins/echo.c
View File

@ -1,63 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* echo.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: erey-bet <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/02/17 13:09:08 by erey-bet #+# #+# */
/* Updated: 2023/04/11 14:57:00 by erey-bet ### ########.fr */
/* */
/* ************************************************************************** */
#include "./builtins_private.h"
int is_space(char c)
{
return (c == ' ' || c == '\f' || c == '\v' || c == '\t'
|| c == '\r' || c == '\n');
}
int check_argument(char *str, int *check_backslash_n)
{
int i;
i = -1;
while (str[++i])
if (str[i] != '-' && str[i] != 'n')
return (1);
if (ft_strnstr(str, "n", ft_strlen(str)) && str[0] == '-')
*check_backslash_n = 1;
else
return (1);
return (0);
}
int echo(int fd, char **strs)
{
int check_backslash_n;
int check_start_write;
int i;
int y;
check_backslash_n = 0;
check_start_write = 0;
i = -1;
while (strs[++i])
{
y = -1;
while (is_space(strs[i][++y]))
;
if (check_start_write == 1
|| check_argument(strs[i], &check_backslash_n))
{
check_start_write = 1;
ft_putstr_fd(strs[i], fd);
if (strs[i + 1] != NULL)
write(fd, " ", 1);
}
}
if (!check_backslash_n)
write(fd, "\n", 1);
return (0);
}

43
builtins/exit.c
View File

@ -1,43 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* exit.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: erey-bet <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/02/24 10:17:59 by erey-bet #+# #+# */
/* Updated: 2023/04/05 12:30:46 by erey-bet ### ########.fr */
/* */
/* ************************************************************************** */
#include "./builtins_private.h"
static int error(int err, char *reason, char *problem)
{
ft_putstr_fd("bozoshell: bozo_exit ", 2);
if (problem != NULL)
{
ft_putstr_fd(problem, 2);
write(2, ": ", 3);
}
ft_putstr_fd(reason, 2);
return (err);
}
int ft_exit(char **args, int err)
{
if (args[0] == NULL)
{
write(1, "bozo_exit\n", 10);
return (err);
}
err = ft_atoi_check(args[0]);
if (err == 1)
return (error(err, "bozo_exit: numeric argument required\n", args[0]));
if (args[1] != NULL)
return (error(-1, "bozo_exit: too many arguments\n", NULL));
if (err > 0)
return (error(err, "bozo_exit: numeric argument required\n", args[0]));
write(1, "exit\n", 6);
return ((ft_atoi(args[0]) % 256 + 256) % 256);
}

114
builtins/export.c
View File

@ -1,114 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* export.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: cchauvet <cchauvet@student.42angoulem +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/02/14 14:27:08 by cchauvet #+# #+# */
/* Updated: 2023/04/14 19:12:10 by erey-bet ### ########.fr */
/* */
/* ************************************************************************** */
#include "./builtins_private.h"
static int error(char *str, char *to_free1, char *to_free2)
{
write(2, "bozoshell: export: `", 20);
write(2, str, ft_strlen(str));
write(2, "': not a valid identifier\n", 26);
if (to_free1 != NULL)
free(to_free1);
if (to_free2 != NULL)
free(to_free2);
return (1);
}
void print_export(t_list **env, int fd)
{
t_list *current;
current = *env;
while (current->next != NULL)
{
if (ft_strcmp(((t_env *)(current->content))->key, "_"))
{
write(fd, "declare -x ", 11);
ft_putstr_fd(((t_env *)(current->content))->key, fd);
if (((t_env *)(current->content))->value != NULL)
{
ft_putstr_fd("=", fd);
write(fd, "\"", 1);
ft_putstr_fd(((t_env *)(current->content))->value, fd);
write(fd, "\"\n", 2);
}
else
write(fd, "\n", 2);
}
current = current->next;
}
}
int set_key_value_export(t_list **env, char *args, char **key, char **value)
{
*key = ft_strndup(args, ft_strnchr(args, '='));
if (*key == NULL)
return (1);
if (ft_strlen(*key) == 0)
return (1);
if (possible_key(*key) == 2)
{
(*key)[ft_strlen(*key) - 1] = '\0';
if (get_value_by_key(*key, env) == NULL)
*value = ft_strdup(ft_strchr(args, '=') + 1);
else
*value = ft_strjoin(get_value_by_key(*key, env),
ft_strchr(args, '=') + 1);
}
else
*value = ft_strdup(ft_strchr(args, '=') + 1);
return (0);
}
int add_export(t_list **env, char *args)
{
char *key;
char *value;
if (ft_strchr(args, '=') != NULL)
{
if (set_key_value_export(env, args, &key, &value))
return (error(args, key, NULL));
}
else
{
key = ft_strdup(args);
value = get_value_by_key(key, env);
if (value != NULL)
value = ft_strdup(value);
if (possible_key(key) == 2)
return (error(key, key, value));
}
if (!possible_key(key))
return (error(args, key, value));
create_value_by_key(key, value, env);
return (0);
}
int ft_export(t_list **env, char **args, int fd)
{
int err;
int i;
err = 0;
if (args[0] == NULL)
print_export(env, fd);
else
{
i = -1;
while (args[++i])
if (add_export(env, args[i]) == 1)
err = 1;
}
return (err);
}

41
builtins/pwd.c
View File

@ -1,41 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* pwd.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: erey-bet <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/02/17 16:09:11 by erey-bet #+# #+# */
/* Updated: 2023/04/18 12:59:25 by erey-bet ### ########.fr */
/* */
/* ************************************************************************** */
#include "./builtins_private.h"
int pwd(int fd)
{
char path[PATH_MAX];
if (getcwd(path, sizeof(path)) != NULL)
ft_putendl_fd(path, fd);
else
{
ft_putendl_fd("Error getcwd", 2);
return (1);
}
return (0);
}
char *get_pwd(void)
{
char *str;
str = ft_calloc(PATH_MAX, sizeof(char *));
if (getcwd(str, PATH_MAX) != NULL)
return (str);
else
{
ft_putendl_fd("Error getcwd", 2);
return (NULL);
}
}

35
builtins/unset.c
View File

@ -1,35 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* unset.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: erey-bet <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/02/22 13:28:27 by erey-bet #+# #+# */
/* Updated: 2023/04/07 12:46:28 by erey-bet ### ########.fr */
/* */
/* ************************************************************************** */
#include "./builtins_private.h"
int error(char *str, int fd)
{
write(fd, "bozoshell: unset: `", 19);
write(fd, str, ft_strlen(str));
write(fd, "': not a valid identifier\n", 26);
return (1);
}
int unset(t_list **env, char **args, int fd)
{
int i;
int err;
i = -1;
err = 0;
while (args[++i])
if (delete_by_key(args[i], env))
if (!possible_key(args[i]))
err = error(args[i], fd);
return (err);
}

54
cmd.c Normal file
View File

@ -0,0 +1,54 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* cmd.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: cchauvet <cchauvet@student.42angoulem +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/02/15 14:18:21 by cchauvet #+# #+# */
/* Updated: 2023/02/16 18:25:14 by cchauvet ### ########.fr */
/* */
/* ************************************************************************** */
#include "libftx/libftx.h"
#include "minishell.h"
void ft_cmddel(void *ptr)
{
t_cmd *content;
content = (t_cmd *) ptr;
if (content->args != NULL)
ft_freer_tab_ultimate(1, content->args);
if (content->executable != NULL)
free(content->executable);
free(content);
}
int ft_cmd_filler(t_list *element, char **args, t_list **env)
{
t_cmd *content;
char *temp;
size_t i;
if (args == NULL)
return (1);
content = (t_cmd *)element->content;
i = 0;
while (args[i] != NULL)
{
temp = ft_env_filler(env, args[i]);
if (temp == NULL)
{
ft_eprintf("minishell: malloc failed\n");
return (1);
}
free(args[i]);
args[i] = temp;
ft_quote_remover(temp);
i++;
}
content->args = args;
content->executable = args[0];
return (0);
}

73
cmd/cmd.c
View File

@ -1,73 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* cmd.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: cchauvet <cchauvet@student.42angoulem +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/02/15 14:18:21 by cchauvet #+# #+# */
/* Updated: 2023/04/17 11:57:07 by cchauvet ### ########.fr */
/* */
/* ************************************************************************** */
#include "cmd.h"
#include "cmd_private.h"
#include "../signal/signal.h"
#include <signal.h>
void ft_cmddel(void *ptr)
{
t_cmd *content;
content = (t_cmd *) ptr;
if (content->args != NULL)
ft_freer_tab_ultimate(1, content->args);
if (content->own_cmd == false && content->executable != NULL)
free(content->executable);
if (content->fd_in[0] > 2)
close(content->fd_in[0]);
if (content->fd_out[0] > 2)
close(content->fd_out[0]);
if (content->fd_in[1] > 2)
close(content->fd_in[1]);
if (content->fd_out[1] > 2)
close(content->fd_out[1]);
free(content);
}
void ft_cmdcloser(void *ptr)
{
t_cmd *cmd;
cmd = ptr;
ft_closer(cmd->fd_in);
ft_closer(cmd->fd_out);
}
void ft_cmdwaiter(void *ptr)
{
t_cmd *cmd;
int exit_status;
cmd = ptr;
if (cmd->executable != NULL && cmd->own_cmd == 0
&& cmd->pid != -1 && cmd->fd_in[0] != -2 && cmd->fd_out[0] != -2)
{
waitpid(cmd->pid, &exit_status, 0);
if (WIFSIGNALED(exit_status))
{
if (exit_status == 131)
{
ft_printf("Quit (core dumped)");
*ft_get_exit_code() = 131;
}
else
*ft_get_exit_code() = 130;
ft_printf("\n");
}
else
*ft_get_exit_code() = WEXITSTATUS(exit_status);
}
signal(SIGINT, ft_ctrlc);
signal(SIGQUIT, SIG_IGN);
}

32
cmd/cmd.h
View File

@ -1,32 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* cmd.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: cchauvet <cchauvet@student.42angouleme.fr +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/03/28 15:47:01 by cchauvet #+# #+# */
/* Updated: 2023/04/07 15:03:53 by alouis-j ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef CMD_H
# define CMD_H
# include <stdbool.h>
# include "../data/data.h"
typedef struct s_cmd
{
int fd_in[2];
int fd_out[2];
int pid;
char *executable;
char **args;
bool own_cmd;
} t_cmd;
void ft_cmddel(void *content);
void ft_cmdwaiter(void *content);
void ft_cmdcloser(void *ptr);
#endif

21
cmd/cmd_private.h
View File

@ -1,21 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* cmd_private.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: cchauvet <cchauvet@student.42angouleme.fr +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/03/28 15:50:23 by cchauvet #+# #+# */
/* Updated: 2023/03/31 16:33:24 by alouis-j ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef CMD_PRIVATE_H
# define CMD_PRIVATE_H
# include <sys/types.h>
# include <sys/wait.h>
# include "./cmd.h"
# include "../libftx/libftx.h"
# include "../data/data.h"
# include "../utils/utils.h"
#endif

114
cmds.c Normal file
View File

@ -0,0 +1,114 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* cmds.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: cchauvet <cchauvet@student.42angoulem +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/02/15 14:17:26 by cchauvet #+# #+# */
/* Updated: 2023/02/17 15:20:29 by cchauvet ### ########.fr */
/* */
/* ************************************************************************** */
#include "libftx/libftx.h"
#include "minishell.h"
static int ft_cmds_init(t_list **cmds, size_t len)
{
t_cmd *content;
t_list *current;
size_t i;
*cmds = malloc(sizeof(t_list));
current = *cmds;
i = 0;
while (i < len)
{
content = malloc(sizeof(t_cmd));
if (content == NULL)
{
ft_lstclear(cmds, ft_cmddel);
return (1);
}
content->args = NULL;
content->executable = NULL;
content->fd_in = -1;
content->fd_out = -1;
current->content = content;
if (!((i + 1) < len))
{
current->next = NULL;
return (0);
}
current->next = malloc(sizeof(t_list));
if (current->next == NULL)
ft_lstclear(cmds, ft_cmddel);
current = current->next;
i++;
}
return (0);
}
static int ft_cmds_prep(t_list **cmds, const char *line, int infile, int outfile)
{
size_t len;
t_cmd *cmd;
t_list *current;
len = ft_seglen_quoted(line, '|');
if (len == 0)
return (0);
if (ft_cmds_init(cmds, ft_seglen_quoted(line, '|')))
{
free(cmds);
return (1);
}
cmd = (t_cmd *)(*cmds)->content;
cmd->fd_in = infile;
current = *cmds;
while (current->next != NULL)
current = current->next;
cmd = (t_cmd *) current->content;
cmd->fd_out = outfile;
return (0);
}
static int ft_cmds_fill(t_list **cmds, t_list **env, const char *line)
{
char **tab;
char **args;
t_list *current;
size_t i;
tab = ft_split_quoted(line, '|');
if (tab == NULL)
return (1);
i = 0;
current = *cmds;
while (tab[i] != NULL)
{
args = ft_split_quoted(tab[i], ' ');
if (ft_cmd_filler(current, args, env) == 1)
{
ft_lstclear(cmds, ft_cmddel);
ft_freer_tab_ultimate(2, args, tab);
return (1);
}
current = current->next;
i++;
}
ft_freer_tab_ultimate(1, tab);
return (0);
}
t_list **ft_parse_cmds(char *line, t_list **env, int infile, int outfile)
{
t_list **cmds;
cmds = malloc(sizeof(t_list *));
if (ft_cmds_prep(cmds, line, infile, outfile) == 1)
return (NULL);
if (ft_cmds_fill(cmds, env, line) == 1)
return (NULL);
return (cmds);
}

21
data/data.c
View File

@ -1,21 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* data.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: cchauvet <cchauvet@student.42angouleme.fr +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/03/27 13:42:09 by cchauvet #+# #+# */
/* Updated: 2023/04/05 14:48:30 by alouis-j ### ########.fr */
/* */
/* ************************************************************************** */
#include "./data_private.h"
#include "data.h"
int *ft_get_exit_code(void)
{
static int exit_code;
return (&exit_code);
}

26
data/data.h
View File

@ -1,26 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* data.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: cchauvet <cchauvet@student.42angouleme.fr +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/03/27 13:43:39 by cchauvet #+# #+# */
/* Updated: 2023/04/05 14:45:23 by alouis-j ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef DATA_H
# define DATA_H
# include "../libftx/libft/list.h"
typedef struct s_data
{
t_list **env;
t_list **cmds;
int *exit_code;
} t_data;
int *ft_get_exit_code(void);
#endif

18
data/data_private.h
View File

@ -1,18 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* data_private.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: cchauvet <cchauvet@student.42angouleme.fr +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/03/27 13:42:21 by cchauvet #+# #+# */
/* Updated: 2023/03/27 13:42:23 by cchauvet ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef DATA_PRIVATE_H
# define DATA_PRIVATE_H
# include "../libftx/libftx.h"
# include "./data.h"
#endif

182
env/env1.c → env.c
View File

@ -1,16 +1,151 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* env1.c :+: :+: :+: */
/* env.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: erey-bet <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/02/02 14:39:56 by erey-bet #+# #+# */
/* Updated: 2023/04/18 13:57:38 by erey-bet ### ########.fr */
/* Updated: 2023/02/17 13:05:29 by erey-bet ### ########.fr */
/* */
/* ************************************************************************** */
#include "env_private.h"
#include "minishell.h"
int get_index(char *s, char c)
{
int i;
i = -1;
while (s[++i])
if (s[i] == c)
return (i);
return (-1);
}
void print_export(t_list **head, int fd)
{
t_list *current;
current = *head;
while (current->next != NULL)
{
write(fd, "declare -x ", 11);
ft_putstr_fd(((t_env*)(current->content))->key, fd);
ft_putstr_fd("=", fd);
write(fd, "\"", 1);
ft_putstr_fd(((t_env*)(current->content))->value, fd);
write(fd, "\"\n", 2);
current = current->next;
}
}
void print_env(t_list **head, int fd)
{
t_list *current;
current = *head;
while (current->next != NULL)
{
ft_putstr_fd(((t_env*)(current->content))->key, fd);
ft_putstr_fd("=", fd);
ft_putstr_fd(((t_env*)(current->content))->value, fd);
write(fd, "\n", 1);
current = current->next;
}
}
int strcmp_alphabet(char *s1, char *s2)
{
int i;
if (!s1 || !s2)
return (-2);
i = 0;
while (s1[i] && s2[i])
{
if (s1[i] < s2[i])
return (0);
else if (s1[i] > s2[i])
return (1);
i++;
}
return (-1);
}
void ft_double_swap(void *a, void *b)
{
void *c;
c = a;
a = b;
b = c;
}
void exchange(void *a, void *b, void *c)
{
void *d;
d = a;
a = b;
b = c;
c = d;
}
char *get_value(char *str)
{
char *s;
int i;
int start;
s = ft_calloc(ft_strlen(str), sizeof(char));
start = get_index(str, '=');
i = start;
while (str[++i])
s[i - start - 1] = str[i];
return (s);
}
void env_del(void *ptr)
{
t_env *content;
content = ptr;
free(content->key);
free(content->value);
free(content);
}
char *get_key(char *str)
{
char *s;
int i;
s = ft_calloc(ft_strlen(str), sizeof(char));
i = -1;
while (str[++i] != '=')
s[i] = str[i];
return (s);
}
void swap_env_3(void **a, void **b, void **c)
{
void *d;
d = *a;
*a = *b;
*b = *c;
*c = d;
}
void swap_env(void **a, void **b)
{
void *c;
c = *a;
*a = *b;
*b = c;
}
void add_sort(t_list **head, t_env *var)
{
@ -18,8 +153,7 @@ void add_sort(t_list **head, t_env *var)
t_env *last;
current = *head;
while (current->next != NULL
&& ft_strcmp(var->key, ((t_env *)(current->content))->key) > 0)
while (current->next != NULL && strcmp_alphabet(var->key, ((t_env*)(current->content))->key) != 0)
current = current->next;
if (current->content == NULL)
current->content = var;
@ -34,11 +168,7 @@ void add_sort(t_list **head, t_env *var)
}
}
if (current->next == NULL)
{
current->next = ft_calloc(1, sizeof(t_list));
if (!current->next)
return ;
}
}
char *get_value_by_key(char *key, t_list **head)
@ -78,10 +208,7 @@ int create_value_by_key(char *key, char *value, t_list **head)
t_env *content;
if (set_value_by_key(key, value, head) == 0)
{
free(key);
return (0);
}
content = ft_calloc(1, sizeof(t_env));
if (content == NULL)
return (1);
@ -91,6 +218,25 @@ int create_value_by_key(char *key, char *value, t_list **head)
return (0);
}
char **env_to_strs(t_list **head)
{
t_list *current;
t_env *content;
char **env;
int i;
current = *head;
env = ft_calloc(ft_lstsize(*head), sizeof(char *));
i = 0;
while (current->content)
{
content = current->content;
env[i++] = ft_strmerger(3, content->key, "=", content->value);
current = current->next;
}
return (env);
}
t_list **init_env(char **env)
{
t_list **head;
@ -102,10 +248,7 @@ t_list **init_env(char **env)
return (NULL);
*head = ft_calloc(1, sizeof(t_list));
if (*head == NULL)
{
free(head);
return (NULL);
}
i = -1;
while (env[++i])
{
@ -118,3 +261,12 @@ t_list **init_env(char **env)
}
return (head);
}
/*int main(int argc, char *argv[], char **env)
{
t_list **new;
new = init_env(env);
ft_printf("%S", env_to_strs(new));
return (0);
}*/

37
env/env.h vendored
View File

@ -1,37 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* env.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: cchauvet <cchauvet@student.42angouleme.fr +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/03/27 13:42:01 by cchauvet #+# #+# */
/* Updated: 2023/03/27 13:42:02 by cchauvet ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef ENV_H
# define ENV_H
# include <stdbool.h>
# include "../libftx/libft/list.h"
# include "../data/data.h"
typedef struct s_env
{
char *key;
char *value;
} t_env;
char *ft_env_filler(t_data *data, const char *str);
void env_del(void *content);
t_list **init_env(char **env);
char **env_to_strs(t_list **head);
int create_value_by_key(char *key, char *value, t_list **head);
int create_value_by_key_dup(char *key, char *value, t_list **head);
int set_value_by_key(char *key, char *value, t_list **head);
char *get_value_by_key(char *key, t_list **head);
void env_del(void *ptr);
int delete_by_key(char *key, t_list **head);
int possible_key(char *key);
#endif

77
env/env2.c vendored
View File

@ -1,77 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* env2.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: erey-bet <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/03/09 19:59:03 by erey-bet #+# #+# */
/* Updated: 2023/04/18 13:26:31 by erey-bet ### ########.fr */
/* */
/* ************************************************************************** */
#include "env_private.h"
int get_index(char *s, char c)
{
int i;
i = -1;
while (s[++i])
if (s[i] == c)
return (i);
return (-1);
}
void swap_env_3(void **a, void **b, void **c)
{
void *d;
d = *a;
*a = *b;
*b = *c;
*c = d;
}
void swap_env(void **a, void **b)
{
void *c;
c = *a;
*a = *b;
*b = c;
}
void env_del(void *ptr)
{
t_env *content;
if (ptr == NULL)
return ;
content = ptr;
if (content->key != NULL)
free(content->key);
if (content->key != NULL)
free(content->value);
if (content != NULL)
free(content);
}
char **env_to_strs(t_list **head)
{
t_list *current;
t_env *content;
char **env;
int i;
current = *head;
env = ft_calloc(ft_lstsize(*head), sizeof(char *));
i = 0;
while (current->content)
{
content = current->content;
env[i++] = ft_strmerger(3, content->key, "=", content->value);
current = current->next;
}
return (env);
}

109
env/env3.c vendored
View File

@ -1,109 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* env3.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: erey-bet <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/02/17 17:25:09 by erey-bet #+# #+# */
/* Updated: 2023/04/07 13:21:54 by erey-bet ### ########.fr */
/* */
/* ************************************************************************** */
#include "env_private.h"
char *get_value(char *str)
{
char *s;
int i;
int start;
s = ft_calloc(ft_strlen(str), sizeof(char));
start = get_index(str, '=');
i = start;
while (str[++i])
s[i - start - 1] = str[i];
return (s);
}
char *get_key(char *str)
{
char *s;
int i;
s = ft_calloc(ft_strlen(str), sizeof(char));
i = -1;
while (str[++i] != '=')
s[i] = str[i];
return (s);
}
int create_value_by_key_dup(char *key, char *value, t_list **env)
{
char *key_dup;
char *value_dup;
if (set_value_by_key(key, value, env) == 0)
return (0);
key_dup = ft_strdup(key);
if (key_dup == NULL)
return (1);
if (value != NULL)
{
value_dup = ft_strdup(value);
if (value_dup == NULL)
{
free(key);
return (1);
}
}
else
value_dup = value;
if (create_value_by_key(key_dup, value_dup, env))
return (1);
return (0);
}
int delete_by_key(char *key, t_list **head)
{
t_list *last;
t_list *current;
current = *head;
last = NULL;
while (current->next != NULL)
{
if (ft_strcmp(((t_env *)current->content)->key, key) == 0)
{
free(((t_env *)current->content)->key);
free(((t_env *)current->content)->value);
free(current->content);
if (last && last->next)
last->next = current->next;
else
*head = current->next;
free(current);
return (0);
}
last = current;
current = current->next;
}
return (1);
}
int possible_key(char *key)
{
int i;
i = -1;
if (ft_isdigit(key[i + 1]))
return (0);
while (key[++i + 1])
if (!ft_isalnum(key[i]) && key[i] != '_')
return (0);
if (key[i] == '+')
return (2);
else if (!ft_isalnum(key[i]) && key[i] != '_')
return (0);
return (1);
}

117
env/env_fill.c vendored
View File

@ -1,117 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* env_fill.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: cchauvet <cchauvet@student.42angoulem +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/02/16 16:29:08 by cchauvet #+# #+# */
/* Updated: 2023/04/05 15:09:46 by alouis-j ### ########.fr */
/* */
/* ************************************************************************** */
#include "./env_private.h"
static char *ft_getkey(const char *str)
{
size_t i;
char *key;
if (ft_strncmp(str, "$$", 2) == 0)
key = ft_strdup("$");
else if (ft_strncmp(str, "$?", 2) == 0)
key = ft_strdup("?");
else if (str[1] == '\0')
key = ft_strdup("");
else
{
i = 1;
while (str[i] != '\0' && !ft_is_in("$?\'\" ", str[i]))
i++;
key = ft_strndup(str + 1, i - 1);
}
if (key == NULL)
ft_eprintf("bozoshell: malloc failed\n");
return (key);
}
static char *ft_getvalue(t_data *data, char *key)
{
char *value;
if (ft_strcmp(key, "?") == 0)
value = ft_itoa(*data->exit_code);
else if (ft_strcmp(key, "$") == 0)
value = ft_strdup("PID");
else if (key[0] == '\0')
value = ft_strdup("$");
else
{
value = get_value_by_key(key, data->env);
if (value == NULL)
value = ft_strdup("");
else
value = ft_strdup(value);
}
if (value == NULL)
ft_eprintf("bozoshell: malloc failed\n");
return (value);
}
static char *ft_getvalue_by_str(t_data *data, const char *str,
size_t *key_len)
{
char *key;
char *value;
key = ft_getkey(str);
if (key == NULL)
return (NULL);
*key_len = ft_strlen(key) + 1;
value = ft_getvalue(data, key);
free(key);
return (value);
}
char *ft_str_formator(t_data *data, char *str, size_t *i)
{
char *value;
size_t key_len;
char *out;
value = ft_getvalue_by_str(data, str + *i, &key_len);
if (value == NULL)
return (NULL);
out = ft_strreplace(str, value, *i, key_len + *i);
*i = *i + ft_strlen(value);
free(value);
return (out);
}
char *ft_env_filler(t_data *data, const char *str)
{
char *out;
char *temp;
size_t i;
out = ft_strdup(str);
if (out == NULL)
return (NULL);
i = 0;
while (out[i] != '\0')
{
while (ft_is_in_quote(out, i) == 1)
i++;
while (out[i] == '$')
{
temp = ft_str_formator(data, out, &i);
if (temp == NULL)
return (NULL);
free(out);
out = temp;
}
if (out[i] != '\0')
i++;
}
return (out);
}

26
env/env_private.h vendored
View File

@ -1,26 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* env_private.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: cchauvet <cchauvet@student.42angouleme.fr +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/03/27 13:40:24 by cchauvet #+# #+# */
/* Updated: 2023/03/27 13:40:25 by cchauvet ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef ENV_PRIVATE_H
# define ENV_PRIVATE_H
# include "./env.h"
# include "../libftx/libftx.h"
# include "../utils/utils.h"
void swap_env_3(void **a, void **b, void **c);
void swap_env(void **a, void **b);
char *get_value(char *str);
char *get_key(char *str);
int get_index(char *str, char c);
char *ft_env_filler(t_data *data, const char *str);
#endif

76
env_fill.c Normal file
View File

@ -0,0 +1,76 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* env_fill.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: cchauvet <cchauvet@student.42angoulem +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/02/16 16:29:08 by cchauvet #+# #+# */
/* Updated: 2023/02/17 13:41:51 by cchauvet ### ########.fr */
/* */
/* ************************************************************************** */
#include "libftx/libftx.h"
#include "minishell.h"
#include "utils/utils.h"
static char *ft_get_value(t_list **env, const char *str, size_t start,
size_t stop)
{
char *key;
char *value;
key = ft_strndup(str + start, stop);
if (key == NULL)
{
ft_eprintf("minishell: malloc failed\n");
return (NULL);
}
value = get_value_by_key(key, env);
if (value == NULL)
value = "";
free(key);
return (value);
}
char *ft_env_filler(t_list **env, const char *str)
{
size_t i;
size_t y;
char *out;
char *temp;
char *value;
out = ft_strdup(str);
if (out == NULL)
{
ft_eprintf("minishell: malloc failed\n");
return (NULL);
}
i = 0;
while (out[i] != '\0')
{
while (ft_is_in_quote(out, i) == 1)
i++;
while (out[i] == '$')
{
y = i + 1;
while (out[y] != '\0' && out[y] != '$' && out[y] != ' ')
y++;
value = ft_get_value(env, out, i + 1, y - i - 1);
if (value == NULL)
return (NULL);
temp = ft_strreplace(out, value, i, y);
free(out);
if (temp == NULL)
{
ft_eprintf("minishell: malloc failed\n");
return (NULL);
}
out = temp;
}
if (out[i] != '\0')
i++;
}
return (out);
}

116
execution.c Normal file
View File

@ -0,0 +1,116 @@
#include "libftx/libftx.h"
#include "minishell.h"
#include "utils/utils.h"
#include <unistd.h>
static char *ft_get_executable_path(char *executable_name, t_list **env)
{
char *path;
char *temp;
char **tab;
size_t i;
path = NULL;
if (executable_name[0] == '.' || executable_name[0] == '/')
{
path = ft_strdup(executable_name);
if (path == NULL)
{
ft_eprintf("minishell: malloc failed\n");
return (NULL);
}
if (access(path, X_OK) == 0)
{
ft_eprintf("minishell: %s: permission denied\n", path);
return (NULL);
}
}
else
{
tab = ft_split(get_value_by_key("PATH", env), ':');
if (tab == NULL)
return (NULL);
i = 0;
while (tab[i] != NULL)
{
temp = ft_strmerger(3, tab[i], "/", executable_name);
if (temp == NULL)
{
ft_freer_tab_ultimate(1, tab);
free(executable_name);
ft_eprintf("minishell: malloc failed\n");
}
if (access(temp, X_OK) == 0)
{
path = temp;
break ;
}
free(temp);
i++;
}
if (path == NULL)
{
ft_eprintf("%s: command not found\n", executable_name);
}
ft_freer_tab_ultimate(1, tab);
}
return (path);
}
static int ft_excutor(t_cmd *cmd, t_list **env)
{
int pid;
int return_value;
char **tab;
if (cmd->fd_in == -1 || cmd->fd_out == -1)
return (1);
pid = fork();
if (pid == -1)
return (1);
if (pid == 0)
{
tab = env_to_strs(env);
if (tab == NULL)
return (1);
tab = NULL;
dup2(cmd->fd_out, 1);
dup2(cmd->fd_in, 0);
execve(cmd->executable, cmd->args, tab);
}
else
waitpid(pid, &return_value, 0);
return (return_value);
}
int ft_cmds_executor(t_list **cmds, t_list **env)
{
t_cmd *content;
t_list *current;
int fds[2];
current = *cmds;
while (current != NULL)
{
content = current->content;
if (current->next != NULL)
{
if (pipe(fds) == -1)
{
ft_eprintf("minishell: pipe failed\n");
return (1);
}
content->fd_out = fds[1];
((t_cmd *) current->next->content)->fd_in = fds[0];
}
content->executable = ft_get_executable_path(content->executable, env);
if (content->executable != NULL)
ft_excutor(content, env);
if (content->fd_in != 0)
close(content->fd_in);
if (content->fd_out != 1 && content->fd_out != 2)
close(content->fd_out);
current = current->next;
}
return (0);
}

119
execution/execution.c
View File

@ -1,119 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* execution.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: cchauvet <cchauvet@student.42angoulem +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/02/21 12:45:16 by cchauvet #+# #+# */
/* Updated: 2023/04/18 13:00:08 by erey-bet ### ########.fr */
/* */
/* ************************************************************************** */
#include "execution_private.h"
static int ft_execute_own_cmd(t_data *data, t_cmd *cmd)
{
int return_code;
if (ft_strcmp(cmd->executable, "pwd") == 0)
return_code = pwd(cmd->fd_out[0]);
else if (ft_strcmp(cmd->executable, "env") == 0)
return_code = print_env(data->env, cmd->fd_out[0]);
else if (ft_strcmp(cmd->executable, "export") == 0)
return_code = ft_export(data->env, cmd->args + 1, cmd->fd_out[0]);
else if (ft_strcmp(cmd->executable, "cd") == 0)
return_code = (move_folder(cmd->args + 1, data->env, cmd->fd_out[0]));
else if (ft_strcmp(cmd->executable, "unset") == 0)
return_code = (unset(data->env, cmd->args, cmd->fd_out[0]));
else if (ft_strcmp(cmd->executable, "echo") == 0)
return_code = (echo(cmd->fd_out[0], cmd->args + 1));
else
{
return_code = ft_exit(cmd->args + 1, *data->exit_code);
if (return_code >= 0)
{
*data->exit_code = return_code;
return (-2);
}
}
*data->exit_code = return_code;
return (return_code);
}
static bool ft_executor(t_data *data, t_cmd *cmd, char **env)
{
if (cmd->fd_in[0] == -1 || cmd->fd_out[0] == -1 || cmd->executable == NULL)
return (0);
cmd->pid = fork();
if (cmd->pid == -1)
return (1);
if (cmd->pid == 0)
{
signal(SIGQUIT, SIG_DFL);
signal(SIGINT, SIG_DFL);
dup2(cmd->fd_in[0], 0);
dup2(cmd->fd_out[0], 1);
ft_lstiter(*data->cmds, ft_cmdcloser);
execve(cmd->executable, cmd->args, env);
return (1);
}
signal(SIGQUIT, SIG_IGN);
signal(SIGINT, SIG_IGN);
return (0);
}
static int ft_cmd_executor(t_data *data, t_cmd *cmd)
{
int exit_code;
char **env;
if (cmd->own_cmd == 1)
{
exit_code = ft_execute_own_cmd(data, cmd);
ft_closer(cmd->fd_in);
ft_closer(cmd->fd_out);
if (exit_code == -2)
return (1);
}
else
{
env = env_to_strs(data->env);
if (env == NULL)
return (1);
exit_code = ft_executor(data, cmd, env);
ft_closer(cmd->fd_in);
ft_closer(cmd->fd_out);
ft_freer_tab_ultimate(1, env);
if (exit_code == 1)
return (1);
}
return (0);
}
int ft_cmds_executor(t_data *data)
{
int fds[2];
t_list *current;
t_cmd *content;
current = *data->cmds;
while (current != NULL)
{
content = current->content;
fds[0] = -1;
if (current->next != NULL)
{
if (pipe(fds) == -1)
return (1);
ft_add_fd(content->fd_out, fds[1]);
ft_add_fd(((t_cmd *)(current->next->content))->fd_in, fds[0]);
}
if (content->fd_in[0] == -2 || content->fd_out[0] == -2)
ft_mega_closer(content->fd_in, content->fd_out);
else if (ft_cmd_executor(data, content))
return (1);
current = current->next;
}
return (0);
}

19
execution/execution.h
View File

@ -1,19 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* execution.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: cchauvet <cchauvet@student.42angouleme.fr +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/03/28 15:46:52 by cchauvet #+# #+# */
/* Updated: 2023/03/28 15:46:53 by cchauvet ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef EXECUTION_H
# define EXECUTION_H
# include "../data/data.h"
int ft_cmds_executor(t_data *data);
#endif

24
execution/execution_private.h
View File

@ -1,24 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* execution_private.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: cchauvet <cchauvet@student.42angouleme.fr +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/03/28 15:45:53 by cchauvet #+# #+# */
/* Updated: 2023/04/05 15:15:56 by alouis-j ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef EXECUTION_PRIVATE_H
# define EXECUTION_PRIVATE_H
# include <signal.h>
# include "../signal/signal.h"
# include "../data/data.h"
# include "../libftx/libftx.h"
# include "../cmd/cmd.h"
# include "../env/env.h"
# include "../builtins/builtins.h"
# include "../utils/utils.h"
#endif

59
redirection/file.c → file.c
View File

@ -6,13 +6,14 @@
/* By: cchauvet <cchauvet@student.42angoulem +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/02/15 17:36:11 by cchauvet #+# #+# */
/* Updated: 2023/04/05 15:12:41 by alouis-j ### ########.fr */
/* Updated: 2023/02/15 17:41:13 by cchauvet ### ########.fr */
/* */
/* ************************************************************************** */
#include "./redirection_private.h"
#include "minishell.h"
#include <unistd.h>
int ft_file_is_readable(t_data *data, const char *path)
int ft_file_is_readable(const char *path)
{
int readable;
int fd;
@ -20,63 +21,59 @@ int ft_file_is_readable(t_data *data, const char *path)
fd = open(path, O_RDONLY);
if (fd == -1)
{
*data->exit_code = 1;
ft_eprintf("bozoshell: %s: No such file or directory\n", path);
return (0);
ft_eprintf("minishell: %s: No such file or directory\n", path);
return (-1);
}
readable = read(fd, "", 0);
if (readable == -1)
{
*data->exit_code = 1;
ft_eprintf("bozoshell: %s: Permission denied\n", path);
return (0);
ft_eprintf("minishell: %s: Permission denied\n", path);
return (-1);
}
close(fd);
return (1);
return (fd);
}
int ft_file_is_writable(t_data *data, const char *path)
int ft_file_is_writable(const char *path)
{
int writeable;
int fd;
fd = open(path, O_WRONLY | O_TRUNC | O_CREAT, 0644);
fd = open(path, O_WRONLY | O_CREAT | O_TRUNC, 0644);
if (fd == -1)
{
*data->exit_code = 1;
ft_eprintf("bozoshell: %s: Permission denied\n", path);
return (0);
ft_eprintf("minishell: %s: Permission denied\n", path);
return (-1);
}
writeable = write(fd, "", 0);
if (writeable == -1)
{
*data->exit_code = 1;
ft_eprintf("bozoshell: %s: Permission denied\n", path);
return (0);
ft_eprintf("minishell: %s: Permission denied\n", path);
return (-1);
}
close(fd);
return (1);
return (fd);
}
int ft_file_is_appendable(t_data *data, const char *path)
int ft_file_is_appendable(const char *path)
{
int writeable;
int fd;
fd = open(path, O_WRONLY | O_APPEND | O_CREAT, 0644);
fd = open(path, O_WRONLY | O_CREAT | O_APPEND, 0644);
if (fd == -1)
{
*data->exit_code = 1;
ft_eprintf("bozoshell: %s: Permission denied\n", path);
return (0);
ft_eprintf("minishell: %s: Permission denied\n", path);
return (-1);
}
writeable = write(fd, "", 0);
if (writeable == -1)
{
*data->exit_code = 1;
ft_eprintf("bozoshell: %s: Permission denied\n", path);
return (0);
ft_eprintf("minishell: %s: Permission denied\n", path);
return (-1);
}
close(fd);
return (1);
return (fd);
}
int ft_file_is_executable(const char *path)
{
return (access(path, X_OK) == 0);
}

19
format/format.h
View File

@ -1,19 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* format.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: cchauvet <cchauvet@student.42angouleme.fr +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/03/28 15:44:56 by cchauvet #+# #+# */
/* Updated: 2023/03/28 15:44:57 by cchauvet ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef FORMAT_H
# define FORMAT_H
# include "../data/data.h"
char *ft_formater(t_data *data, const char *str);
#endif

18
format/format_private.h
View File

@ -1,18 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* format_private.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: cchauvet <cchauvet@student.42angouleme.fr +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/03/28 15:44:59 by cchauvet #+# #+# */
/* Updated: 2023/03/28 15:45:00 by cchauvet ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef FORMAT_PRIVATE_H
# define FORMAT_PRIVATE_H
# include "../libftx/libftx.h"
# include "../utils/utils.h"
#endif

33
utils/ft_change_exit_code.c → heredoc.c
View File

@ -1,27 +1,36 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_change_exit_code.c :+: :+: :+: */
/* heredoc.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: cchauvet <cchauvet@student.42angoulem +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/02/24 19:04:04 by cchauvet #+# #+# */
/* Updated: 2023/02/24 19:05:57 by cchauvet ### ########.fr */
/* Created: 2023/02/17 15:36:26 by cchauvet #+# #+# */
/* Updated: 2023/02/17 16:21:02 by cchauvet ### ########.fr */
/* */
/* ************************************************************************** */
#include "../minishell.h"
#include "libftx/libftx.h"
#include "minishell.h"
int ft_change_exit_code(t_data *data, int new_value)
int ft_heredoc(char *stop)
{
char *exit_code_str;
int fds[2];
char *line;
data->exit_code = new_value;
exit_code_str = ft_itoa(new_value);
if (exit_code_str == NULL)
pipe(fds);
line = readline("> ");
while (line != NULL)
{
ft_eprintf("bozoshell: malloc failed\n");
return (1);
if (ft_strcmp(line, stop) == 0)
{
free(line);
break ;
}
return (0);
ft_putendl_fd(line, fds[1]);
free(line);
line = readline("> ");
}
close(fds[1]);
return (fds[0]);
}

113
infile.c Normal file
View File

@ -0,0 +1,113 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* infile.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: cchauvet <cchauvet@student.42angoulem +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/02/15 17:52:10 by cchauvet #+# #+# */
/* Updated: 2023/02/17 13:19:09 by cchauvet ### ########.fr */
/* */
/* ************************************************************************** */
#include "libftx/libftx.h"
#include "minishell.h"
#include "utils/utils.h"
static int ft_infile_is_valid(const char *line)
{
char **tab;
size_t i;
tab = ft_split_quoted(line, ' ');
if (tab == NULL)
{
ft_eprintf("minishell: malloc failed\n");
return (0);
}
if (tab[0] == NULL)
return (1);
i = 0;
while (tab[i + 1] != NULL)
i++;
if (tab[i][0] == '<')
{
ft_eprintf("minishell: %s: must be followed by an infile\n", tab[i]);
ft_freer_tab_ultimate(1, tab);
return (0);
}
ft_freer_tab_ultimate(1, tab);
return (1);
}
static int ft_get_infile(const char *line)
{
size_t i;
int fd;
char **tab;
tab = ft_split_quoted(line, ' ');
if (tab == NULL)
{
ft_eprintf("minishell: malloc failed\n");
return (-2);
}
fd = 0;
i = 0;
while (tab[i + 1] != NULL)
{
if (tab[i][0] == '<')
if (fd != 0)
close(fd);
if (ft_strcmp("<", tab[i]) == 0)
fd = ft_file_is_readable(ft_quote_remover(tab[i + 1]));
else if (ft_strcmp("<<", tab[i]) == 0)
fd = ft_heredoc(tab[i + 1]);
i++;
}
ft_freer_tab_ultimate(1, tab);
return (fd);
}
static int ft_remove_infile(char *line)
{
size_t i;
size_t y;
char **tab;
tab = ft_split_quoted(line, ' ');
if (tab == NULL)
{
ft_eprintf("minishell: malloc failed\n");
return (1);
}
i = 0;
y = 0;
while (tab[i] != NULL)
{
if (tab[i][0] == '<')
{
ft_strshift(line + y, -1 * (ft_strlen(tab[i]) + 1));
i++;
ft_strshift(line + y, -1 * (ft_strlen(tab[i]) + 1));
}
else
y = y + ft_strlen(tab[i]);
i++;
}
ft_freer_tab_ultimate(1, tab);
return (0);
}
int ft_infile(char *line)
{
int fd;
if (ft_infile_is_valid(line) == 0)
return (-2);
fd = ft_get_infile(line);
if (fd == -2)
return (-2);
ft_remove_infile(line);
return (fd);
}

12
libftx/extra/ft_swap.c
View File

@ -1,15 +1,3 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_swap.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: cchauvet <cchauvet@student.42angouleme.fr +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/03/27 13:43:25 by cchauvet #+# #+# */
/* Updated: 2023/03/27 13:43:26 by cchauvet ### ########.fr */
/* */
/* ************************************************************************** */
#include "extra.h"
void ft_swap(void *a, void *b)

BIN
libftx/extra/ft_ultoa.o Normal file
View File

Binary file not shown.

2
libftx/gnl/Makefile
View File

@ -36,4 +36,4 @@ fclean: clean
re: fclean all
.PHONY: all clean fclean re
.PHONY: all bonus clean fclean re

BIN
libftx/gnl/get_next_line_utils.o Normal file
View File

Binary file not shown.

17
libftx/libft/libft.h
View File

@ -14,7 +14,6 @@
# define LIBFT_H
# include <stdlib.h>
# include <unistd.h>
# include "./list.h"
void *ft_cancel(void **tab, size_t len);
int ft_atoi(const char *nptr);
@ -53,4 +52,20 @@ void ft_putstr_fd(char *s, int fd);
void ft_putendl_fd(char *s, int fd);
void ft_putnbr_fd(int n, int fd);
typedef struct s_list
{
void *content;
struct s_list *next;
} t_list;
t_list *ft_lstnew(void *content);
void ft_lstadd_front(t_list **lst, t_list *nouveau);
int ft_lstsize(t_list *lst);
t_list *ft_lstlast(t_list *lst);
void ft_lstadd_back(t_list **lst, t_list *nouveau);
void ft_lstdelone(t_list *lst, void (*del)(void *));
void ft_lstclear(t_list **lst, void (*del)(void *));
void ft_lstiter(t_list *lst, void (*f)(void *));
t_list *ft_lstmap(t_list *lst, void *(*f)(void *), void (*del)(void *));
#endif

32
libftx/libft/list.h
View File

@ -1,32 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* list.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: cchauvet <cchauvet@student.42angouleme.fr +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/03/27 13:43:53 by cchauvet #+# #+# */
/* Updated: 2023/03/27 13:43:54 by cchauvet ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef LIST_H
# define LIST_H
typedef struct s_list
{
void *content;
struct s_list *next;
} t_list;
t_list *ft_lstnew(void *content);
void ft_lstadd_front(t_list **lst, t_list *nouveau);
int ft_lstsize(t_list *lst);
t_list *ft_lstlast(t_list *lst);
void ft_lstadd_back(t_list **lst, t_list *nouveau);
void ft_lstdelone(t_list *lst, void (*del)(void *));
void ft_lstclear(t_list **lst, void (*del)(void *));
void ft_lstiter(t_list *lst, void (*f)(void *));
t_list *ft_lstmap(t_list *lst, void *(*f)(void *), void (*del)(void *));
#endif

91
libftx/libftx.h
View File

@ -6,7 +6,7 @@
/* By: cchauvet <cchauvet@student.42angoulem +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/09/26 14:47:54 by cchauvet #+# #+# */
/* Updated: 2023/02/21 13:28:19 by cchauvet ### ########.fr */
/* Updated: 2023/02/17 16:24:42 by cchauvet ### ########.fr */
/* */
/* ************************************************************************** */
@ -15,13 +15,10 @@
# include <stdlib.h>
# include <unistd.h>
# include <stdarg.h>
# include "./libft/libft.h"
char *ft_ultoa_base(unsigned long long n, char *base);
int ft_printf(const char *format, ...);
int ft_eprintf(const char *format, ...);
int ft_dprintf(int fd, const char *format, ...);
int ft_dprintf(int fd, const char *format, ...);
char *get_next_line(int fd);
size_t ft_random_generator(size_t start, size_t stop);
void ft_freer_tab_ultimate(size_t len, ...);
@ -40,41 +37,57 @@ void ft_swap(void *a, void *b);
void ft_swap_int(int *a, int *b);
void ft_swap_char(char *a, char *b);
/* void *ft_cancel(void **tab, size_t len); */
/* int ft_atoi(const char *nptr); */
/* void ft_bzero(void *s, size_t n); */
/* void *ft_calloc(size_t nmemb, size_t size); */
/* int ft_isalnum(int c); */
/* int ft_isalpha(int c); */
/* int ft_isascii(int c); */
/* int ft_isdigit(int c); */
/* int ft_isprint(int c); */
/* void *ft_memchr(const void *s, int c, size_t n); */
/* int ft_memcmp(const void *s1, const void *s2, size_t n); */
/* void *ft_memcpy(void *dest, const void *src, size_t n); */
/* void *ft_memmove(void *dest, const void *src, size_t n); */
/* void *ft_memset(void *s, int c, size_t n); */
/* char *ft_strchr(const char *s, int c); */
/* char *ft_strdup(const char *s); */
/* size_t ft_strlcat(char *dst, const char *src, size_t size); */
/* size_t ft_strlcpy(char *dst, const char *src, size_t size); */
/* size_t ft_strlen(const char *s); */
/* int ft_strncmp(const char *s1, const char *s2, size_t n); */
/* char *ft_strnstr(const char *big, const char *little, size_t len); */
/* char *ft_strrchr(const char *s, int c); */
/* int ft_tolower(int c); */
/* int ft_toupper(int c); */
void *ft_cancel(void **tab, size_t len);
int ft_atoi(const char *nptr);
void ft_bzero(void *s, size_t n);
void *ft_calloc(size_t nmemb, size_t size);
int ft_isalnum(int c);
int ft_isalpha(int c);
int ft_isascii(int c);
int ft_isdigit(int c);
int ft_isprint(int c);
void *ft_memchr(const void *s, int c, size_t n);
int ft_memcmp(const void *s1, const void *s2, size_t n);
void *ft_memcpy(void *dest, const void *src, size_t n);
void *ft_memmove(void *dest, const void *src, size_t n);
void *ft_memset(void *s, int c, size_t n);
char *ft_strchr(const char *s, int c);
char *ft_strdup(const char *s);
size_t ft_strlcat(char *dst, const char *src, size_t size);
size_t ft_strlcpy(char *dst, const char *src, size_t size);
size_t ft_strlen(const char *s);
int ft_strncmp(const char *s1, const char *s2, size_t n);
char *ft_strnstr(const char *big, const char *little, size_t len);
char *ft_strrchr(const char *s, int c);
int ft_tolower(int c);
int ft_toupper(int c);
/* char *ft_substr(char const *s, unsigned int start, size_t len); */
/* char *ft_strjoin(char const *s1, char const *s2); */
/* char *ft_strtrim(char const *s1, char const *set); */
/* char **ft_split(char const *s, char c); */
/* char *ft_itoa(int n); */
/* char *ft_strmapi(char const *s, char (*f)(unsigned int, char)); */
/* void ft_striteri(char *s, void (*f)(unsigned int, char*)); */
/* void ft_putchar_fd(char c, int fd); */
/* void ft_putstr_fd(char *s, int fd); */
/* void ft_putendl_fd(char *s, int fd); */
/* void ft_putnbr_fd(int n, int fd); */
char *ft_substr(char const *s, unsigned int start, size_t len);
char *ft_strjoin(char const *s1, char const *s2);
char *ft_strtrim(char const *s1, char const *set);
char **ft_split(char const *s, char c);
char *ft_itoa(int n);
char *ft_strmapi(char const *s, char (*f)(unsigned int, char));
void ft_striteri(char *s, void (*f)(unsigned int, char*));
void ft_putchar_fd(char c, int fd);
void ft_putstr_fd(char *s, int fd);
void ft_putendl_fd(char *s, int fd);
void ft_putnbr_fd(int n, int fd);
typedef struct s_list
{
void *content;
struct s_list *next;
} t_list;
t_list *ft_lstnew(void *content);
void ft_lstadd_front(t_list **lst, t_list *nouveau);
int ft_lstsize(t_list *lst);
t_list *ft_lstlast(t_list *lst);
void ft_lstadd_back(t_list **lst, t_list *nouveau);
void ft_lstdelone(t_list *lst, void (*del)(void *));
void ft_lstclear(t_list **lst, void (*del)(void *));
void ft_lstiter(t_list *lst, void (*f)(void *));
t_list *ft_lstmap(t_list *lst, void *(*f)(void *), void (*del)(void *));
#endif

13
libftx/printf/ft_printf.c
View File

@ -6,7 +6,7 @@
/* By: cchauvet <cchauvet@student.42angoulem +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/10/06 22:01:28 by cchauvet #+# #+# */
/* Updated: 2023/02/21 13:27:31 by cchauvet ### ########.fr */
/* Updated: 2022/10/12 16:34:31 by cchauvet ### ########.fr */
/* */
/* ************************************************************************** */
@ -22,14 +22,3 @@ int ft_printf(const char *format, ...)
va_end(va);
return (i);
}
int ft_dprintf(int fd, const char *format, ...)
{
va_list va;
int i;
va_start(va, format);
i = ft_vdprintf(fd, format, va);
va_end(va);
return (i);
}

3
libftx/printf/ft_printf.h
View File

@ -6,7 +6,7 @@
/* By: cchauvet <cchauvet@student.42angoulem +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/09/26 14:47:54 by cchauvet #+# #+# */
/* Updated: 2023/02/21 13:27:51 by cchauvet ### ########.fr */
/* Updated: 2023/02/17 16:29:18 by cchauvet ### ########.fr */
/* */
/* ************************************************************************** */
@ -32,7 +32,6 @@ int ft_dprintarg(int fd, int c, va_list va);
int ft_dprintstrtab(int fd, char **tab);
int ft_printf(const char *format, ...);
int ft_dprintf(int fd, const char *format, ...);
int ft_eprintf(const char *format, ...);
int ft_vdprintf(int fd, const char *format, va_list va);

BIN
libftx/printf/libftprintf.a Normal file
View File

Binary file not shown.

155
main.c
View File

@ -6,110 +6,145 @@
/* By: cchauvet <cchauvet@student.42angoulem +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/02/16 15:16:14 by cchauvet #+# #+# */
/* Updated: 2023/04/18 12:59:43 by erey-bet ### ########.fr */
/* Updated: 2023/02/17 16:06:02 by cchauvet ### ########.fr */
/* */
/* ************************************************************************** */
#include "data/data.h"
#include "env/env.h"
#include "libftx/libft/libft.h"
#include "libftx/libft/list.h"
#include "libftx/libftx.h"
#include "bozoshell.h"
#include "signal/signal.h"
#include <stdlib.h>
#include "minishell.h"
static char *ft_get_user_input(void)
static char *ft_get_user_input(t_list **env)
{
char *line;
char *prompt;
char *pwd;
pwd = get_pwd();
if (pwd == NULL)
return (NULL);
prompt = ft_strmerger(2, pwd, "$ ");
free(pwd);
prompt = ft_strmerger(2, get_value_by_key("PWD", env), "$ ");
if (prompt == NULL)
{
ft_eprintf("bozoshell: malloc failed\n");
ft_eprintf("minishell: malloc failed\n");
return (NULL);
}
line = readline(prompt);
if (line != NULL && ft_strcmp(line, "") != 0)
add_history(line);
free(prompt);
if (line == NULL)
ft_printf("exit\n");
return (line);
}
static int ft_minishell(t_data *data, char *line)
static int ft_minishell(t_list **env, char *line)
{
t_list **cmds;
char *line_clean;
int infile;
int outfile;
if (ft_syntax_verif(data, line))
return (0);
line_clean = ft_formater(data, line);
if (line_clean == NULL || line_clean[0] == '\0')
return (0);
if (ft_cmds_parser(data, line_clean))
line_clean = ft_normalizer(line);
if (line_clean == NULL)
return (1);
if (ft_syntatic_verif(line_clean))
{
free(line_clean);
return (0);
}
free(line_clean);
if (ft_cmds_executor(data) == 1)
return (1);
ft_lstiter(*data->cmds, ft_cmdwaiter);
ft_lstclear(data->cmds, ft_cmddel);
}
outfile = ft_outfile(line_clean);
if (outfile == -2)
{
free(line_clean);
return (1);
}
infile = ft_infile(line_clean);
if (infile == -2)
{
close(outfile);
free(line_clean);
return (1);
}
cmds = ft_parse_cmds(line_clean, env, infile, outfile);
if (cmds == NULL)
{
close(outfile);
close(infile);
ft_lstclear(cmds, ft_cmddel);
free(cmds);
free(line_clean);
return (1);
}
if (ft_cmds_executor(cmds, env) == 1)
{
close(outfile);
close(infile);
ft_lstclear(cmds, ft_cmddel);
free(cmds);
free(line_clean);
return (1);
}
return (0);
}
int ft_init_data(t_data *data, char **env)
#if DEBUG
int main(int ac, char **av, char **env)
{
data->exit_code = ft_get_exit_code();
data->cmds = malloc(sizeof(t_cmd *));
if (data->cmds == NULL)
{
ft_eprintf("bozoshell: malloc failed\n");
t_data data;
if (ac == 1)
return (1);
data.env = init_env(env);
if (data.env == NULL)
return (1);
free(data.env);
return (1);
}
*data->cmds = NULL;
data->env = init_env(env);
if (data->env == NULL)
if (ft_minishell(data.env, av[1]) == 1)
{
ft_eprintf("bozoshell: malloc failed\n");
free(data->cmds);
ft_lstclear(data.env, env_del);
free(data.env);
return (1);
}
ft_lstclear(data.env, env_del);
free(data.env);
free(line);
return (0);
}
#else
int main(int ac, char **av, char **env)
{
t_data data;
char *line;
(void) ac;
(void) av;
signal(SIGINT, ft_ctrlc);
signal(SIGQUIT, SIG_IGN);
if (ft_init_data(&data, env))
data.env = init_env(env);
if (data.env == NULL)
return (1);
line = ft_get_user_input();
while (line != NULL)
{
if (ft_minishell(&data, line) == 1)
break ;
free(line);
line = ft_get_user_input();
line = ft_get_user_input(data.env);
if (line == NULL)
break ;
}
ft_lstclear(data.cmds, ft_cmddel);
free(data.cmds);
{
ft_lstclear(data.env, env_del);
free(data.env);
return (*data.exit_code);
return (1);
}
while (line != NULL)
{
if (ft_minishell(data.env, line) == 1)
{
ft_lstclear(data.env, env_del);
free(data.env);
free(line);
return (1);
}
free(line);
line = ft_get_user_input(data.env);
if (line == NULL)
{
ft_lstclear(data.env, env_del);
free(data.env);
return (1);
}
}
ft_lstclear(data.env, env_del);
free(data.env);
}
#endif

67
minishell.h Normal file
View File

@ -0,0 +1,67 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* minishell.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: cchauvet <cchauvet@student.42angoulem +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/02/14 13:45:30 by cchauvet #+# #+# */
/* Updated: 2023/02/17 14:29:56 by cchauvet ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef MINISHELL_H
# define MINISHELL_H
# include "libftx/libftx.h"
# include "utils/utils.h"
# include <sys/types.h>
# include <sys/stat.h>
# include <fcntl.h>
# include <sys/wait.h>
# include <stdio.h>
# include <readline/readline.h>
# include <readline/history.h>
# define DEBUG 0
t_list **init_env(char **env);
int set_value_by_key(char *key, char *value, t_list **env);
char *get_value_by_key(char *key, t_list **head);
int ft_syntatic_verif(const char *str);
int ft_file_is_readable(const char *path);
int ft_file_is_writable(const char *path);
int ft_file_is_appendable(const char *path);
char *ft_get_file_path(const char *infile);
int ft_infile(char *line);
int ft_outfile(char *line);
int ft_heredoc(char *stop);
size_t ft_seglen_quoted(const char *str, char c);
int ft_cmds_executor(t_list **cmds, t_list **env);
char **ft_split_quoted(const char *s, char c);
void ft_cmddel(void *content);
void env_del(void *content);
t_list **ft_parse_cmds(char *line, t_list **env, int infile, int outfile);
int ft_cmd_filler(t_list *current, char **args, t_list **env);
char *ft_normalizer(char *str);
char *ft_env_filler(t_list **env, const char *str);
char **env_to_strs(t_list **head);
typedef struct s_cmd
{
int fd_in;
int fd_out;
char *executable;
char **args;
} t_cmd;
typedef struct s_data
{
t_list **env;
int heredoc;
} t_data;
typedef struct s_env
{
void *key;
void *value;
} t_env;
#endif

112
outfile.c Normal file
View File

@ -0,0 +1,112 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* outfile.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: cchauvet <cchauvet@student.42angoulem +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/02/15 18:01:07 by cchauvet #+# #+# */
/* Updated: 2023/02/17 13:19:46 by cchauvet ### ########.fr */
/* */
/* ************************************************************************** */
#include "libftx/libftx.h"
#include "minishell.h"
static int ft_outfile_is_valid(const char *line)
{
char **tab;
size_t i;
tab = ft_split_quoted(line, ' ');
if (tab == NULL)
{
ft_eprintf("minishell: malloc failed\n");
return (0);
}
if (tab[0] == NULL)
return (1);
i = 0;
while (tab[i + 1] != NULL)
i++;
if (tab[i][0] == '>')
{
ft_eprintf("minishell: %s: must be followed by an infile\n", tab[i]);
ft_freer_tab_ultimate(1, tab);
return (0);
}
ft_freer_tab_ultimate(1, tab);
return (1);
}
static int ft_get_outfile(const char *line)
{
size_t i;
int fd;
char **tab;
tab = ft_split_quoted(line, ' ');
if (tab == NULL)
{
ft_eprintf("minishell: malloc failed\n");
return (-2);
}
fd = 1;
i = 0;
while (tab[i + 1] != NULL)
{
if (tab[i][0] == '>')
if (fd != 1)
close(fd);
if (ft_strcmp(">", tab[i]) == 0)
fd = ft_file_is_writable(ft_quote_remover(tab[i + 1]));
else if (ft_strcmp(">>", tab[i]) == 0)
fd = ft_file_is_appendable(ft_quote_remover(tab[i + 1]));
i++;
}
ft_freer_tab_ultimate(1, tab);
return (fd);
}
static int ft_remove_outfile(char *line)
{
size_t i;
size_t y;
char **tab;
tab = ft_split_quoted(line, ' ');
if (tab == NULL)
{
ft_eprintf("minishell: malloc failed\n");
return (1);
}
i = 0;
y = 0;
while (tab[i] != NULL)
{
if (tab[i][0] == '>')
{
ft_strshift(line + y, -1 * (ft_strlen(tab[i]) + 1));
i++;
ft_strshift(line + y, -1 * (ft_strlen(tab[i]) + 1));
}
else
y = y + ft_strlen(tab[i]);
i++;
}
ft_freer_tab_ultimate(1, tab);
return (0);
}
int ft_outfile(char *line)
{
int fd;
if (ft_outfile_is_valid(line) == 0)
return (-2);
fd = ft_get_outfile(line);
if (fd == -2)
return (-2);
ft_remove_outfile(line);
return (fd);
}

127
parse/parse.c
View File

@ -1,127 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* parse.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: cchauvet <cchauvet@student.42angouleme.fr +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/03/27 13:44:38 by cchauvet #+# #+# */
/* Updated: 2023/04/11 16:17:19 by cchauvet ### ########.fr */
/* */
/* ************************************************************************** */
#include "./parse_private.h"
static int ft_args_parse(char *cmd_str, t_cmd *cmd)
{
char **tab;
size_t i;
tab = ft_split_charset_quoted(cmd_str, "\t ");
if (tab == NULL)
return (1);
i = 0;
while (tab[i] != NULL)
{
ft_quote_remover(tab[i]);
i++;
}
cmd->args = tab;
return (0);
}
static int ft_executable_parse(t_data *data, t_cmd *cmd)
{
bool own;
char *path;
path = cmd->args[0];
own = 0;
if (cmd->args[0] == NULL)
{
ft_closer(cmd->fd_in);
ft_closer(cmd->fd_out);
}
else if (ft_strcmp(cmd->args[0], "env") == 0 || (ft_strcmp(cmd->args[0],
"export") == 0) || (ft_strcmp(cmd->args[0], "echo") == 0)
|| (ft_strcmp(cmd->args[0], "unset") == 0) || (ft_strcmp(cmd->args[0],
"exit") == 0) || (ft_strcmp(cmd->args[0], "pwd") == 0)
|| (ft_strcmp(cmd->args[0], "cd") == 0))
own = 1;
else
{
path = ft_get_executable(data, cmd->args[0]);
if (path == NULL)
return (1);
}
cmd->own_cmd = own;
cmd->executable = path;
return (0);
}
int ft_cmd_adder(t_data *data, t_cmd *cmd)
{
t_list *element;
element = ft_lstnew(cmd);
if (element == NULL)
{
ft_cmddel(cmd);
return (1);
}
ft_lstadd_back(data->cmds, element);
return (0);
}
int ft_cmd_parser(t_data *data, char *cmd_str)
{
t_cmd *cmd;
cmd = ft_calloc(sizeof(t_cmd), 1);
if (cmd == NULL)
{
ft_eprintf("bozoshell: malloc failed\n");
return (1);
}
if (ft_redirection(data, cmd, cmd_str))
{
ft_cmddel(cmd);
return (1);
}
if (ft_args_parse(cmd_str, cmd))
{
ft_cmddel(cmd);
return (1);
}
ft_executable_parse(data, cmd);
return (ft_cmd_adder(data, cmd));
}
int ft_cmds_parser(t_data *data, const char *line)
{
char **tab;
ssize_t i;
tab = ft_split_charset_quoted(line, "|");
if (tab == NULL)
{
ft_eprintf("bozoshell: malloc failed\n");
return (1);
}
i = -1;
while (tab[++i] != NULL)
{
if (ft_cmd_parser(data, tab[i]))
{
ft_freer_tab_ultimate(1, tab);
return (1);
}
}
if (*data->cmds != NULL)
{
ft_add_fd(((t_cmd *)(*data->cmds)->content)->fd_in, 0);
ft_add_fd(((t_cmd *)(ft_lstlast(*data->cmds))->content)->fd_out, 1);
}
ft_freer_tab_ultimate(1, tab);
return (0);
}

19
parse/parse.h
View File

@ -1,19 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* parse.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: cchauvet <cchauvet@student.42angouleme.fr +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/03/28 15:42:38 by cchauvet #+# #+# */
/* Updated: 2023/03/28 15:42:39 by cchauvet ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef PARSE_H
# define PARSE_H
# include "../data/data.h"
int ft_cmds_parser(t_data *data, const char *line);
#endif

21
parse/parse_private.h
View File

@ -1,21 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* parse_private.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: cchauvet <cchauvet@student.42angouleme.fr +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/03/28 15:42:44 by cchauvet #+# #+# */
/* Updated: 2023/03/28 15:42:45 by cchauvet ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef PARSE_PRIVATE_H
# define PARSE_PRIVATE_H
# include "../redirection/redirection.h"
# include "../libftx/libftx.h"
# include "../utils/utils.h"
# include "../env/env.h"
# include "../data/data.h"
# include "../cmd/cmd.h"
#endif

151
redirection/check.c
View File

@ -1,151 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* check.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: cchauvet <cchauvet@student.42angouleme.fr +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/03/29 17:32:06 by cchauvet #+# #+# */
/* Updated: 2023/04/17 11:15:38 by cchauvet ### ########.fr */
/* */
/* ************************************************************************** */
#include "./redirection_private.h"
#include <stdbool.h>
#include "../signal/signal.h"
#include <signal.h>
static bool ft_check_heredoc(t_data *data, t_cmd *cmd,
char *redirection_identifier, char *redirection)
{
int fd;
if (ft_strcmp(redirection_identifier, "<<") == 0)
{
if (cmd->fd_in[0] == -2)
return (0);
signal(SIGINT, ft_ctrlc_heredoc);
fd = ft_heredoc(data, redirection);
signal(SIGINT, ft_ctrlc);
if (fd == -2)
return (1);
else
{
if (cmd->fd_in[0] > 2)
close(cmd->fd_in[0]);
cmd->fd_in[0] = fd;
}
}
return (0);
}
static bool ft_check_infile(t_data *data, t_cmd *cmd,
char *redirection_identifier, char *redirection)
{
int fd;
if (ft_strcmp(redirection_identifier, "<") == 0)
{
if (cmd->fd_in[0] == -2)
return (0);
if (ft_file_is_readable(data, redirection))
{
fd = open(redirection, O_RDONLY);
if (cmd->fd_in[0] > 2)
close(cmd->fd_in[0]);
cmd->fd_in[0] = fd;
}
else
{
if (cmd->fd_in[0] > 2)
close(cmd->fd_in[0]);
cmd->fd_in[0] = -2;
return (0);
}
}
return (0);
}
static bool ft_check_outfile(t_data *data, t_cmd *cmd,
char *redirection_identifier, char *redirection)
{
int fd;
if (ft_strcmp(redirection_identifier, ">") == 0)
{
if (cmd->fd_out[0] == -2)
return (0);
if (ft_file_is_writable(data, redirection))
{
fd = open(redirection,
O_WRONLY | O_TRUNC | O_CREAT, 0644);
if (cmd->fd_out[0] > 2)
close(cmd->fd_out[0]);
cmd->fd_out[0] = fd;
}
else
{
if (cmd->fd_out[0] > 2)
close(cmd->fd_out[0]);
cmd->fd_out[0] = -2;
return (0);
}
}
return (0);
}
static bool ft_check_outfile_append(t_data *data, t_cmd *cmd,
char *redirection_identifier, char *redirection)
{
int fd;
if (ft_strcmp(redirection_identifier, ">>") == 0)
{
if (cmd->fd_out[0] == -2)
return (0);
if (ft_file_is_appendable(data, redirection))
{
fd = open(redirection,
O_WRONLY | O_APPEND | O_CREAT, 0644);
if (cmd->fd_out[0] > 2)
close(cmd->fd_out[0]);
cmd->fd_out[0] = fd;
}
else
{
if (cmd->fd_out[0] > 2)
close(cmd->fd_out[0]);
cmd->fd_out[0] = -2;
}
}
return (0);
}
bool ft_check_redirection(t_data *data, t_cmd *cmd,
char *redirection_identifier, char *redirection)
{
char *str;
bool out;
if (ft_is_in("<>", redirection_identifier[0])
&& ft_is_in("<>", redirection[0]))
{
ft_eprintf("bozoshell: %s: invalid redirection file\n", redirection);
return (1);
}
str = ft_strdup(redirection);
if (str == NULL)
{
ft_eprintf("bozoshell: malloc failed\n");
return (1);
}
ft_quote_remover(str);
out = 0;
if (ft_check_heredoc(data, cmd, redirection_identifier, str)
|| ft_check_infile(data, cmd, redirection_identifier, str)
|| ft_check_outfile(data, cmd, redirection_identifier, str)
|| ft_check_outfile_append(data, cmd, redirection_identifier, str))
out = 1;
free(str);
return (out);
}

93
redirection/heredoc.c
View File

@ -1,93 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* heredoc.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: cchauvet <cchauvet@student.42angoulem +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/02/17 15:36:26 by cchauvet #+# #+# */
/* Updated: 2023/04/17 12:14:11 by cchauvet ### ########.fr */
/* */
/* ************************************************************************** */
#include "./redirection_private.h"
#include <readline/readline.h>
#include <unistd.h>
static bool ft_fd_is_closed(int fd)
{
int fd2;
fd2 = dup(fd);
if (fd2 == -1)
return (1);
close(fd2);
return (0);
}
static int ft_format_and_write(t_data *data, const char *str, int fd)
{
char *line_clean;
line_clean = ft_env_filler(data, str);
if (line_clean == NULL)
return (1);
ft_putendl_fd(line_clean, fd);
free(line_clean);
return (0);
}
int ft_heredoc2(t_data *data, char *line, char *stop, int fds[2])
{
if (line == NULL)
{
if (ft_fd_is_closed(0))
{
close(fds[0]);
fds[0] = -2;
return (1);
}
else
{
ft_eprintf("\nbozoshell: warning: here-document at line 1%s",
"delimited by end-of-file (wanted `adfsd')\n");
return (1);
}
}
if (ft_strcmp(line, stop) == 0)
return (1);
if (ft_format_and_write(data, line, fds[1]))
{
close(fds[0]);
fds[0] = -2;
return (1);
}
return (0);
}
int ft_heredoc(t_data *data, char *stop)
{
int fds[2];
int stdin_bak;
char *line;
stdin_bak = dup(0);
if (stdin_bak == -1)
return (1);
if (pipe(fds))
{
close(stdin_bak);
return (1);
}
line = readline("> ");
while (ft_heredoc2(data, line, stop, fds) == 0)
{
free(line);
line = readline("> ");
}
free(line);
close(fds[1]);
dup2(stdin_bak, 0);
close(stdin_bak);
return (fds[0]);
}

115
redirection/redirection.c
View File

@ -1,115 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* redirection.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: cchauvet <cchauvet@student.42angouleme.fr +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/03/27 13:44:22 by cchauvet #+# #+# */
/* Updated: 2023/04/13 13:26:06 by cchauvet ### ########.fr */
/* */
/* ************************************************************************** */
#include "redirection_private.h"
int ft_replace_file(t_data *data, char **tab)
{
size_t i;
char *redirection;
i = 0;
while (tab[i] != NULL)
{
if (ft_is_in("<>", tab[i][0]))
{
i++;
redirection = ft_env_filler(data, tab[i]);
if (redirection == NULL)
return (1);
free(tab[i]);
tab[i] = redirection;
ft_quote_remover(tab[i]);
}
i++;
}
return (0);
}
static void ft_skip(char *str, size_t *i, ssize_t *start)
{
while (str[*i] == str[*start])
(*i)++;
while (str[*i] == ' ')
(*i)++;
while (str[*i] != '\0' && (str[*i] != ' '
|| ft_is_in_quote(str, *i)))
(*i)++;
}
static void ft_remove_redirection(char *cmd_str)
{
size_t i;
ssize_t start;
i = 0;
while (cmd_str[i] != '\0')
{
start = -1;
while ((ft_is_in_quote(cmd_str, i) || !ft_is_in("<>", cmd_str[i]))
&& cmd_str[i] != '\0')
i++;
if (ft_is_in("<>", cmd_str[i]))
start = i;
else
continue ;
ft_skip(cmd_str, &i, &start);
if (start != -1)
{
ft_strshift(cmd_str + start, -1 * (i - start));
i = start;
}
}
}
int ft_set_redirection(t_data *data, t_cmd *cmd, char **tab)
{
size_t i;
i = 0;
while (tab[i + 1] != NULL)
{
if (ft_check_redirection(data, cmd, tab[i], tab[i + 1]))
return (1);
i++;
}
if (ft_is_in("<>", tab[i][0]))
{
ft_eprintf("bozoshell: %s: must be followed by a file\n", tab[i]);
return (1);
}
return (0);
}
int ft_redirection(t_data *data, t_cmd *cmd, char *cmd_str)
{
char **tab;
cmd->fd_in[0] = -1;
cmd->fd_in[1] = -1;
cmd->fd_out[0] = -1;
cmd->fd_out[1] = -1;
tab = ft_split_charset_quoted(cmd_str, " \t");
if (tab == NULL)
{
ft_eprintf("bozoshell: malloc failed\n");
return (1);
}
ft_remove_redirection(cmd_str);
if (ft_set_redirection(data, cmd, tab))
{
ft_freer_tab_ultimate(1, tab);
return (1);
}
ft_freer_tab_ultimate(1, tab);
return (0);
}

21
redirection/redirection.h
View File

@ -1,21 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* redirection.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: cchauvet <cchauvet@student.42angouleme.fr +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/03/27 13:44:19 by cchauvet #+# #+# */
/* Updated: 2023/03/27 13:44:20 by cchauvet ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef REDIRECTION_H
# define REDIRECTION_H
# include "../data/data.h"
# include "../cmd/cmd.h"
int ft_redirection(t_data *data, t_cmd *cmd, char *cmd_str);
int *ft_get_heredoc(void);
#endif

32
redirection/redirection_private.h
View File

@ -1,32 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* redirection_private.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: cchauvet <cchauvet@student.42angouleme.fr +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/03/27 13:44:31 by cchauvet #+# #+# */
/* Updated: 2023/03/29 19:19:21 by cchauvet ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef REDIRECTION_PRIVATE_H
# define REDIRECTION_PRIVATE_H
# include <sys/stat.h>
# include <fcntl.h>
# include <stddef.h>
# include <unistd.h>
# include "../libftx/libftx.h"
# include "../data/data.h"
# include "../env/env.h"
# include "../utils/utils.h"
# include "../cmd/cmd.h"
int ft_file_is_readable(t_data *data, const char *path);
int ft_file_is_writable(t_data *data, const char *path);
bool ft_check_redirection(t_data *data, t_cmd *cmd,
char *redirection_identifier, char *redirection);
int ft_file_is_appendable(t_data *data, const char *path);
int ft_heredoc(t_data *data, char *stop);
#endif

36
signal/signal.c
View File

@ -1,36 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* signal.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: cchauvet <cchauvet@student.42angouleme.fr +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/03/28 15:59:01 by cchauvet #+# #+# */
/* Updated: 2023/04/17 11:23:21 by cchauvet ### ########.fr */
/* */
/* ************************************************************************** */
#include "signal_private.h"
void ft_ctrlc_heredoc(int num)
{
close(0);
ft_putchar_fd('\n', 1);
(void) num;
}
void ft_ctrlc(int num)
{
rl_replace_line("", 0);
rl_on_new_line();
ft_putchar_fd('\n', 1);
rl_redisplay();
*ft_get_exit_code() = 130;
(void) num;
}
void ft_quit(int num)
{
(void) num;
ft_printf("Quit (core dumped)\n");
}

20
signal/signal.h
View File

@ -1,20 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* signal.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: cchauvet <cchauvet@student.42angouleme.fr +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/03/28 16:02:31 by cchauvet #+# #+# */
/* Updated: 2023/04/17 11:14:28 by cchauvet ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef SIGNAL_H
# define SIGNAL_H
void ft_quit(int num);
void ft_ctrlc(int num);
void ft_ctrlc_heredoc(int num);
#endif

22
signal/signal_private.h
View File

@ -1,22 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* signal_private.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: cchauvet <cchauvet@student.42angouleme.fr +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/03/28 15:59:42 by cchauvet #+# #+# */
/* Updated: 2023/04/05 15:05:00 by alouis-j ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef SIGNAL_PRIVATE_H
# define SIGNAL_PRIVATE_H
# include <signal.h>
# include <stdio.h>
# include <readline/readline.h>
# include <unistd.h>
# include "../libftx/libftx.h"
# include "../data/data.h"
# include "../redirection/redirection.h"
#endif

61
format/format.c → spacer.c
View File

@ -1,35 +1,23 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* format.c :+: :+: :+: */
/* spacer.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: cchauvet <cchauvet@student.42angoulem +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/02/15 13:35:50 by cchauvet #+# #+# */
/* Updated: 2023/03/31 15:22:21 by alouis-j ### ########.fr */
/* Updated: 2023/02/16 16:26:15 by cchauvet ### ########.fr */
/* */
/* ************************************************************************** */
#include "./format_private.h"
static int ft_replace(char **str, size_t i)
{
char *temp;
temp = ft_strreplace(*str, " ", i, i);
free(*str);
if (temp == NULL)
{
ft_eprintf("bozoshell: malloc failed\n");
return (1);
}
*str = temp;
return (0);
}
#include "libftx/libftx.h"
#include "minishell.h"
#include "utils/utils.h"
static char *ft_spacer_after(const char *str)
{
char *out;
char *temp;
size_t i;
out = ft_strdup(str);
@ -38,18 +26,18 @@ static char *ft_spacer_after(const char *str)
i = 1;
while (out[i] != '\0')
{
while (ft_is_in_quote(out, i - 1))
while (ft_is_in_quote(out, i))
i++;
if (out[i - 1] == '\0' || out[i] == '\0')
break ;
if (ft_is_in("><|", out[i - 1]))
{
while (out[i] == out[i - 1])
while (str[i] == out[i - 1])
i++;
if (ft_replace(&out, i))
temp = ft_strreplace(out, " ", i, i);
free(out);
out = temp;
if (out == NULL)
return (NULL);
}
if (out[i] != '\0')
i++;
}
return (out);
@ -58,27 +46,30 @@ static char *ft_spacer_after(const char *str)
static char *ft_spacer_before(const char *str)
{
char *out;
ssize_t i;
char *temp;
size_t i;
out = ft_strdup(str);
if (out == NULL)
return (NULL);
i = -1;
while (out[++i] != '\0')
i = 0;
while (out[i + 1] != '\0')
{
while (ft_is_in_quote(out, i + 1))
while (ft_is_in_quote(out, i))
i++;
if (out[i] == '\0')
break ;
if (ft_is_in("><|", out[i + 1]))
{
while (out[i] == ' ')
i++;
while (out[i] == out[i + 1])
i++;
if (ft_replace(&out, i + 1))
temp = ft_strreplace(out, " ", i + 1, i + 1);
free(out);
out = temp;
if (out == NULL)
return (NULL);
}
i++;
}
return (out);
}
@ -93,8 +84,6 @@ static void ft_space_simplifier(char *str)
{
if (ft_is_in_quote(str, i))
i++;
if (str[i] != '\0')
break ;
y = 0;
while (str[y + i] == ' ')
y++;
@ -107,7 +96,7 @@ static void ft_space_simplifier(char *str)
}
}
char *ft_formater(t_data *data, const char *str)
char *ft_normalizer(char *str)
{
char *out;
char *temp;
@ -124,7 +113,5 @@ char *ft_formater(t_data *data, const char *str)
ft_space_simplifier(out);
if (out[ft_strlen(out) - 1] == ' ')
out[ft_strlen(out) - 1] = '\0';
temp = ft_env_filler(data, out);
free(out);
return (temp);
return (out);
}

98
syntatics.c Normal file
View File

@ -0,0 +1,98 @@
#include "libftx/libftx.h"
#include "minishell.h"
#include "utils/utils.h"
static int ft_quote_verif(const char *str)
{
if (ft_is_in_quote(str, ft_strlen(str)))
{
ft_eprintf("minishell: Quote is note closed");
return (1);
}
else
return (0);
}
static int ft_pipe_is_alone(const char *str)
{
size_t i;
int check;
check = 0;
i = 0;
while (str[i] != '\0')
{
while (str[i] == ' ')
i++;
if (str[i] == '\0')
break ;
if (str[i] != '|')
check = 1;
else
{
if (check == 0)
{
ft_eprintf("minishell: Pipe must be followed and ");
ft_eprintf("preced by a command or redirection\n");
return (1);
}
check = 0;
}
i++;
}
if (check == 0)
{
ft_eprintf("minishell: Pipe must be followed and ");
ft_eprintf("preced by a command or redirection\n");
}
return (check == 0);
}
static int ft_special_char_dub(const char *str)
{
size_t i;
size_t y;
i = 0;
while (str[i] != '\0')
{
while (ft_is_in_quote(str, i))
i++;
if (ft_is_in("|<>", str[i]))
{
y = 0;
while (str[i] == str[i + y])
y++;
if ((y > 2 && (str[i] == '>' || str[i] == '<'))
|| (y > 1 && str[i] == '|'))
{
ft_eprintf("minishell: to many %c in a row", str, str[i]);
return (1);
}
i = i + y;
}
else
i++;
}
return (0);
}
int ft_empty_verif(const char *str)
{
size_t i;
i = 0;
while (str[i] == ' ')
i++;
if (str[i] == '\0')
ft_eprintf("minishell: %s: command not found \n", str);
return (str[i] == '\0');
}
int ft_syntatic_verif(const char *str)
{
return (ft_quote_verif(str)
|| ft_empty_verif(str)
|| ft_pipe_is_alone(str)
|| ft_special_char_dub(str));
}

106
syntax/syntax.c
View File

@ -1,106 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* syntax.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: cchauvet <cchauvet@student.42angoulem +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/02/21 13:00:05 by cchauvet #+# #+# */
/* Updated: 2023/04/07 11:07:52 by alouis-j ### ########.fr */
/* */
/* ************************************************************************** */
#include "../libftx/libftx.h"
#include "../utils/utils.h"
static int ft_quote_verif(const char *str)
{
if (ft_is_in_quote(str, ft_strlen(str)))
{
ft_eprintf("bozoshell: Quote is not closed\n");
return (1);
}
else
return (0);
}
static int ft_pipe_is_alone(const char *str)
{
ssize_t i;
int check;
check = 0;
i = -1;
while (str[++i] != '\0')
{
while (str[i] == ' ' || ft_is_in_quote(str, i))
i++;
if (str[i] == '\0')
break ;
if (str[i] != '|')
check = 1;
else
{
if (check == 0)
break ;
check = 0;
}
}
if (check == 0)
ft_eprintf("bozoshell: Pipe must be followed and %s",
"preced by a command or redirection\n");
return (check == 0);
}
static int ft_special_char_dub(const char *str)
{
size_t i;
size_t y;
i = 0;
while (str[i] != '\0')
{
while (ft_is_in_quote(str, i))
i++;
if (ft_is_in("|<>", str[i]))
{
y = 0;
while (str[i] == str[i + y])
y++;
if ((y > 2 && (str[i] == '>' || str[i] == '<'))
|| (y > 1 && str[i] == '|'))
{
ft_eprintf("bozoshell: too many %s in a row\n", str);
return (1);
}
i = i + y;
}
else if (str[i] != '\0')
i++;
}
return (0);
}
static int ft_empty_verif(const char *str)
{
size_t i;
i = 0;
while (str[i] == ' ' || str[i] == '\t')
i++;
return (str[i] == '\0');
}
int ft_syntax_verif(t_data *data, const char *str)
{
if (ft_empty_verif(str))
return (1);
if (ft_quote_verif(str)
|| ft_pipe_is_alone(str)
|| ft_special_char_dub(str))
{
*data->exit_code = 2;
return (1);
}
return (0);
}

19
syntax/syntax.h
View File

@ -1,19 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* syntax.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: cchauvet <cchauvet@student.42angouleme.fr +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/03/28 15:42:54 by cchauvet #+# #+# */
/* Updated: 2023/03/28 15:42:55 by cchauvet ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef SYNTAX_H
# define SYNTAX_H
# include "../data/data.h"
int ft_syntax_verif(t_data *data, const char *str);
#endif

1
t Normal file
View File

@ -0,0 +1 @@
bozt

BIN
builtins/.nfs000000000ab804b60000004a → utils/.ft_is_a_quote.c.swp
View File

Binary file not shown.

40
utils/fd.c
View File

@ -1,40 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* fd.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: cchauvet <cchauvet@student.42angouleme.fr +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/03/27 13:39:58 by cchauvet #+# #+# */
/* Updated: 2023/03/29 18:51:58 by cchauvet ### ########.fr */
/* */
/* ************************************************************************** */
#include "./utils.h"
#include <stdio.h>
void ft_closer(int fds[2])
{
if (fds[0] > 2)
{
close(fds[0]);
}
if (fds[1] > 2)
{
close(fds[1]);
}
}
void ft_mega_closer(int fds1[2], int fds2[2])
{
ft_closer(fds1);
ft_closer(fds2);
}
void ft_add_fd(int fds[2], int fd)
{
if (fds[0] == -1)
fds[0] = fd;
else
fds[1] = fd;
}

50
utils/ft_atoi_check.c
View File

@ -1,50 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_atoi_check.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: erey-bet <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/07/21 08:21:05 by erey-bet #+# #+# */
/* Updated: 2023/04/04 13:40:43 by erey-bet ### ########.fr */
/* */
/* ************************************************************************** */
#include "utils.h"
static int ft_isspace(char c)
{
if (c == ' ' || c == '\f'
||c == '\n' || c == '\r' || c == '\t' || c == '\v')
return (1);
return (0);
}
int ft_atoi_check(const char *nptr)
{
int64_t result;
int sign;
while (ft_isspace(*nptr))
nptr++;
sign = 1;
if (*nptr == '+' || *nptr == '-')
{
if (*nptr == '-')
sign = -1;
nptr++;
}
result = 0;
while (*nptr >= '0' && *nptr <= '9')
{
result = result * 10 + (*nptr++ - '0') * sign;
if ((result < 0 && sign == 1)
|| (result > 0 && sign == -1))
return (2);
}
if (*nptr--)
return (1);
if (*nptr == '-' || *nptr == '+')
return (1);
return (0);
}

115
utils/ft_get_executable.c
View File

@ -1,115 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_get_executable.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: cchauvet <cchauvet@student.42angouleme.fr +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/03/27 13:39:48 by cchauvet #+# #+# */
/* Updated: 2023/04/05 15:09:29 by alouis-j ### ########.fr */
/* */
/* ************************************************************************** */
#include "./utils.h"
#include <unistd.h>
char *ft_get_executable_with_path(t_data *data, const char *name)
{
char *path;
if (access(name, F_OK) != 0)
{
*data->exit_code = 127;
ft_eprintf("bozoshell: %s: No such file or directery\n", name);
return (NULL);
}
if (access(name, X_OK) != 0)
{
*data->exit_code = 126;
ft_eprintf("bozoshell: %s: permission denied\n", name);
return (NULL);
}
path = ft_strdup(name);
if (path == NULL)
{
ft_eprintf("bozoshell: malloc failed\n");
return (NULL);
}
return (path);
}
static char **ft_get_paths(t_data *data, const char *name)
{
char *paths;
char **tab;
paths = get_value_by_key("PATH", data->env);
if (paths == NULL)
{
*data->exit_code = 127;
ft_eprintf("bozoshell: %s: command not found\n", name);
return (NULL);
}
tab = ft_split(paths, ':');
if (tab == NULL)
{
ft_eprintf("bozoshell: malloc failed\n");
return (NULL);
}
return (tab);
}
static char *ft_file_is_executable(const char *path, const char *name)
{
char *out;
out = ft_strmerger(3, path, "/", name);
if (out == NULL)
{
ft_eprintf("bozoshell: malloc failed\n");
free(out);
return (NULL);
}
if (access(out, X_OK) == 0)
return (out);
free(out);
return (NULL);
}
static char *ft_get_executable_without_path(t_data *data, const char *name)
{
char **paths;
char *path;
size_t i;
paths = ft_get_paths(data, name);
if (paths == NULL)
return (NULL);
path = NULL;
i = 0;
while (paths[i] != NULL)
{
path = ft_file_is_executable(paths[i], name);
if (path != NULL)
break ;
i++;
}
ft_freer_tab_ultimate(1, paths);
if (path == NULL)
{
*data->exit_code = 127;
ft_eprintf("bozoshell: %s: command not found\n", name);
}
return (path);
}
char *ft_get_executable(t_data *data, const char *name)
{
char *path;
if (name[0] == '.' || name[0] == '/')
path = ft_get_executable_with_path(data, name);
else
path = ft_get_executable_without_path(data, name);
return (path);
}

BIN
utils/ft_getstr.o Normal file
View File

Binary file not shown.

43
utils/ft_is_in_quote.c
View File

@ -1,40 +1,29 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_is_in_quote.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: cchauvet <cchauvet@student.42angouleme.fr +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/03/30 15:39:25 by cchauvet #+# #+# */
/* Updated: 2023/03/30 15:52:10 by cchauvet ### ########.fr */
/* */
/* ************************************************************************** */
#include "utils.h"
int ft_is_in_quote(const char *str, size_t n)
{
size_t double_quoted;
size_t simple_quoted;
size_t i;
ssize_t start;
start = -1;
double_quoted = 0;
simple_quoted = 0;
i = 0;
while (str[i] != '\0')
while (str[i] != '\0' && i < n)
{
if (i == n)
break ;
if (str[i] == '\"' || str[i] == '\'')
if (str[i] == '"')
{
if (start == -1)
start = i;
else if (str[i] == str[start])
start = -1;
if (simple_quoted == 0)
double_quoted = !double_quoted;
}
if (str[i] == '\'')
{
if (double_quoted == 0)
simple_quoted = !simple_quoted;
}
i++;
}
if (start == -1)
return (0);
if (str[start] == '\'')
return (1);
return (2);
return (simple_quoted == 1 + (double_quoted == 1) * 2);
}

BIN
utils/ft_printn.o Normal file
View File

Binary file not shown.

25
utils/ft_quote_remover.c
View File

@ -6,20 +6,12 @@
/* By: cchauvet <cchauvet@student.42angoulem +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/02/15 14:12:00 by cchauvet #+# #+# */
/* Updated: 2023/03/29 15:11:44 by cchauvet ### ########.fr */
/* Updated: 2023/02/16 13:20:50 by cchauvet ### ########.fr */
/* */
/* ************************************************************************** */
#include "utils.h"
static void ft_remove_quote_and_reset(char *str, ssize_t *start, ssize_t *stop)
{
ft_strshift(str + *start, -1);
ft_strshift(str + *stop - 1, -1);
*start = -1;
*stop = -1;
}
char *ft_quote_remover(char *str)
{
size_t i;
@ -27,7 +19,6 @@ char *ft_quote_remover(char *str)
ssize_t stop;
start = -1;
stop = -1;
i = 0;
while (str[i] != '\0')
{
@ -36,15 +27,17 @@ char *ft_quote_remover(char *str)
if (start == -1)
start = i;
else if (str[i] == str[start])
stop = i;
}
if (stop != -1)
{
ft_remove_quote_and_reset(str, &start, &stop);
i = i - 1;
stop = i;
break ;
}
}
else
i++;
}
if (start != -1)
{
ft_strshift(str, -1);
ft_strshift(str + stop - 1, -1);
}
return (str);
}

90
utils/ft_split_charset_quoted.c
View File

@ -1,90 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_split_charset_quoted.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: erey-bet <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/04/11 14:50:26 by erey-bet #+# #+# */
/* Updated: 2023/04/14 15:53:49 by erey-bet ### ########.fr */
/* */
/* ************************************************************************** */
#include "utils.h"
int new_strs(char ***strs, const char *to_split, int *i, int *j)
{
if (ft_strlen((*strs)[(*i)]) <= 0)
return (0);
(*i)++;
(*j) = 0;
(*strs)[(*i)] = ft_calloc(sizeof(char),
(ft_strlen(to_split) + 1));
if (!(*strs)[(*i)])
return (1);
return (0);
}
int get_strs(const char *to_split, const char *charset, char ***strs, int *i)
{
int j;
int x;
int y;
int check;
x = -1;
j = 0;
while (to_split[++x])
{
y = -1;
check = 1;
while (charset[++y])
{
if (to_split[x] == charset[y] && !ft_is_in_quote(to_split, x))
{
check = 0;
if (new_strs(strs, to_split, i, &j))
return (1);
}
}
if (check)
(*strs)[(*i)][j++] = to_split[x];
}
return (0);
}
void free_set_null(char ***strs, int i)
{
if (ft_strlen((*strs)[i]) == 0)
{
free((*strs)[i]);
(*strs)[i] = NULL;
}
}
char **ft_split_charset_quoted(const char *to_split, const char *charset)
{
char **strs;
int i;
strs = ft_calloc(sizeof(char *), (ft_strlen(to_split) + 1));
if (!strs)
return (NULL);
i = 0;
strs[0] = ft_calloc(sizeof(char), (ft_strlen(to_split) + 1));
if (!strs[0])
{
free(strs);
return (NULL);
}
if (get_strs(to_split, charset, &strs, &i))
{
i = -1;
while (strs[++i])
free(strs[i]);
free(strs);
return (NULL);
}
free_set_null(&strs, i);
return (strs);
}

75
utils/ft_split_quoted.c Normal file
View File

@ -0,0 +1,75 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_split_quoted.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: cchauvet <cchauvet@student.42angoulem +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/10/05 19:04:34 by cchauvet #+# #+# */
/* Updated: 2023/02/15 14:25:56 by cchauvet ### ########.fr */
/* */
/* ************************************************************************** */
#include "utils.h"
size_t ft_seglen_quoted(const char *str, char c)
{
size_t len;
size_t i;
len = 0;
i = 0;
while (str[i] != 0)
{
while ((str[i] == c || ft_is_in_quote(str, i)) && str[i] != 0)
i++;
if (str[i] != 0)
len++;
while ((str[i] != c || ft_is_in_quote(str, i)) && str[i] != 0)
i++;
}
return (len);
}
static char **ft_segsplitter(char **tab, size_t len, const char *s, char c)
{
size_t tab_index;
size_t let_i;
size_t start;
tab_index = 0;
let_i = 0;
start = 0;
if (tab == NULL || s == NULL)
return (NULL);
while (tab_index < len)
{
while ((s[let_i] == c || ft_is_in_quote(s, let_i)) && s[let_i] != 0)
let_i++;
start = let_i;
while ((s[let_i] != c || ft_is_in_quote(s, let_i)) && s[let_i] != 0)
let_i++;
tab[tab_index] = ft_substr(s, start, let_i - start);
if (tab[tab_index] == NULL)
return (ft_cancel((void *)tab, tab_index));
tab_index++;
}
return (tab);
}
char **ft_split_quoted(const char *s, char c)
{
size_t len;
char **tab;
if (s == NULL)
return (NULL);
len = ft_seglen_quoted(s, c);
tab = malloc((len + 1) * sizeof(char *));
if (tab == NULL)
return (NULL);
tab[len] = NULL;
if (ft_segsplitter(tab, len, s, c) == NULL)
return (NULL);
return (tab);
}

12
utils/ft_strnchr.c
View File

@ -1,15 +1,3 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strnchr.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: cchauvet <cchauvet@student.42angoulem +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/02/21 12:59:06 by cchauvet #+# #+# */
/* Updated: 2023/02/21 12:59:07 by cchauvet ### ########.fr */
/* */
/* ************************************************************************** */
#include "utils.h"
ssize_t ft_strnchr(const char *str, char c)

12
utils/ft_strncpy.c
View File

@ -1,15 +1,3 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strncpy.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: cchauvet <cchauvet@student.42angoulem +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/02/21 12:59:16 by cchauvet #+# #+# */
/* Updated: 2023/02/21 12:59:19 by cchauvet ### ########.fr */
/* */
/* ************************************************************************** */
#include "utils.h"
size_t ft_strncpy(char *dst, const char *src, size_t n)

18
utils/ft_strreplace.c
View File

@ -1,25 +1,11 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strreplace.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: cchauvet <cchauvet@student.42angoulem +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/02/21 12:46:20 by cchauvet #+# #+# */
/* Updated: 2023/02/21 12:58:44 by cchauvet ### ########.fr */
/* */
/* ************************************************************************** */
#include "utils.h"
char *ft_strreplace(const char *str, const char *fill,
size_t start, size_t stop)
char *ft_strreplace(const char *str, const char *fill, size_t start, size_t stop)
{
char *out;
size_t sum;
out = malloc((ft_strlen(str) + ft_strlen(fill) -\
(stop - start) + 1 * sizeof(char)));
out = malloc((ft_strlen(str) + ft_strlen(fill) - (stop - start) + 1 * sizeof(char)));
if (out == NULL)
return (NULL);
ft_strncpy(out, str, start);

11
utils/utils.h
View File

@ -6,7 +6,7 @@
/* By: cchauvet <cchauvet@student.42angoulem +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/02/14 14:46:40 by cchauvet #+# #+# */
/* Updated: 2023/04/11 16:55:16 by cchauvet ### ########.fr */
/* Updated: 2023/02/16 16:13:47 by cchauvet ### ########.fr */
/* */
/* ************************************************************************** */
@ -14,8 +14,6 @@
# define UTILS_H
# include <stdlib.h>
# include "../libftx/libftx.h"
# include "../data/data.h"
# include "../env/env.h"
size_t ft_strncpy(char *dst, const char *src, size_t n);
int ft_is_in_quote(const char *str, size_t n);
@ -24,13 +22,8 @@ char *ft_strreplace(const char *str, const char *fill,
ssize_t ft_strnchr(const char *str, char c);
char *ft_getstr(const char *str, size_t n);
int ft_str_is_empty(const char *str);
char **ft_split_charset_quoted(const char *s, const char *charset);
char **ft_split_quoted(const char *s, char c);
void ft_strshift(char *str, int shift);
char *ft_quote_remover(char *str);
int ft_atoi_check(const char *nptr);
char *ft_get_executable(t_data *data, const char *name);
void ft_closer(int fds[2]);
void ft_mega_closer(int fds1[2], int fds2[2]);
void ft_add_fd(int fds[2], int fd);
#endif