minishell

typedef enum e_token_type
{
	T_WORD, T_PIPE, T_REDIR_IN, T_REDIR_OUT,
	T_REDIR_APPEND, T_REDIR_HEREDOC,
	T_AND, T_OR, T_LPAREN, T_RPAREN, T_EOF
}				t_token_type;

typedef struct s_token      /* un token de l'input */
{
	char			*value;     /* texte du token (NULL pour opérateurs) */
	t_token_type	type;       /* type du token */
	struct s_token	*next;
}				t_token;

typedef struct s_redir      /* une redirection */
{
	t_token_type	type;       /* < > >> << */
	char			*file;      /* nom du fichier / délimiteur */
	struct s_redir	*next;
}				t_redir;

typedef struct s_cmd        /* une commande dans le pipeline */
{
	char			**argv;     /* arguments (argv[0] = commande) */
	t_redir		*redirs;    /* liste chaînée de redirections */
	int			op_before;  /* opérateur AVANT cette commande (T_AND/T_OR/T_PIPE) */
	struct s_cmd	*next;
}				t_cmd;

typedef struct s_shell      /* état global du shell */
{
	char	**env;              /* copie de l'environnement */
	int	exit_status;        /* $? — statut de la dernière commande */
	int	running;            /* 1 = shell actif, 0 = exit demandé */
}				t_shell;

while (shell.running)
{
	input = readline(PROMPT);       /* affiche le prompt */
	if (input == NULL)               /* ctrl-D = EOF */
	{
		write(1, "exit\n", 5);
		break ;
	}
	if (input[0] != '\0')
		ms_process_input(input, &shell);
	free(input);                     /* pas de leak */
}

int	read_word(t_token **tokens, char *input, int *i)
{
	int		start;
	char	*word;

	start = *i;
	while (input[*i] != '\0' && input[*i] != ' ' && input[*i] != '\t'
		&& input[*i] != '|' && input[*i] != '<' && input[*i] != '>'
		&& input[*i] != '&' && input[*i] != '(' && input[*i] != ')')
	{
		if (input[*i] == '\'' || input[*i] == '"')
		{
			if (read_quoted(input, i, input[*i]) != 0)
				return (1);
		}
		else
			(*i)++;
	}
	if (*i > start)
	{
		word = ft_strndup(input + start, *i - start);
		add_token(tokens, new_token(word, T_WORD));
	}
	return (0);
}

static int	is_operator(t_token_type type)
{
	if (type == T_PIPE || type == T_AND || type == T_OR)
		return (1);
	return (0);
}

static int	is_redir(t_token_type type)
{
	if (type == T_REDIR_IN || type == T_REDIR_OUT
		|| type == T_REDIR_APPEND || type == T_REDIR_HEREDOC)
		return (1);
	return (0);
}

int	ms_check_syntax(t_token *tokens)
{
	t_token	*cur;
	t_token	*prev;

	if (tokens == NULL)
		return (0);
	cur = tokens;
	prev = NULL;
	while (cur != NULL)
	{
		if (is_operator(cur->type) && (prev == NULL
				|| is_operator(prev->type) || is_redir(prev->type)))
			return (ms_syntax_error_msg(...));
		if (is_redir(cur->type) && (cur->next == NULL
				|| cur->next->type != T_WORD))
			return (ms_syntax_error_msg(...));
		prev = cur;
		cur = cur->next;
	}
	if (prev != NULL && is_operator(prev->type))
		return (ms_syntax_error_msg("newline"));
	return (0);
}

char	*expand_dollar(char *str, int *i, t_shell *shell)
{
	char	*name;
	int		start;
	int		braces;

	braces = 0;
	(*i)++;
	if (str[*i] == '{' && (*i)++)   /* ${VAR} syntax */
		braces = 1;
	if (str[*i] == '?')            /* $? = exit status */
	{
		(*i)++;
		return (ft_itoa(shell->exit_status));
	}
	start = *i;
	while (str[*i] != '\0' && (ft_isalnum(str[*i]) || str[*i] == '_'))
		(*i)++;
	if (braces && str[*i] == '}')
		(*i)++;
	if (*i == start)
		return (ft_strdup("$"));    /* $ seul = littéral */
	name = ft_strndup(str + start, *i - start - braces);
	return (get_var_value(name, shell));
}

int	match_pattern(char *pattern, char *str)
{
	if (*pattern == '\0' && *str == '\0')
		return (1);
	if (*pattern == '*')
	{
		while (*pattern == '*')
			pattern++;
		if (*pattern == '\0')
			return (1);           /* * à la fin = match tout */
		while (*str != '\0')
		{
			if (match_pattern(pattern, str))
				return (1);
			str++;
		}
		return (match_pattern(pattern, str));
	}
	if (*pattern == '\0' || *str == '\0')
		return (0);
	if (*pattern == *str)
		return (match_pattern(pattern + 1, str + 1));
	return (0);
}

int	ms_parse(t_cmd **cmds, t_token *tokens)
{
	t_cmd	*cur;
	t_cmd	*new;
	int		op_before;

	*cmds = NULL;
	cur = NULL;
	op_before = 0;
	while (tokens != NULL)
	{
		if (parse_command(&new, &tokens, op_before) != 0)
			return (1);
		if (new->argv == NULL && new->redirs == NULL)
		{
			free(new);
			break ;
		}
		if (*cmds == NULL)
			*cmds = new;
		else
			cur->next = new;
		cur = new;
		advance_op(&tokens, &op_before);  /* stocke T_AND/T_OR/T_PIPE */
	}
	return (0);
}

int	run_pipeline_loop(t_cmd **cmds, t_shell *shell, int count)
{
	t_cmd	*cur;
	int		prev_fd;
	int		pipefd[2];
	int		i;

	cur = *cmds;
	prev_fd = -1;
	i = -1;
	while (++i < count)
	{
		if (i < count - 1 && do_fork(cur, shell, &prev_fd, pipefd))
			return (1);
		if (i >= count - 1 && do_fork(cur, shell, &prev_fd, NULL))
			return (1);
		if (i < count - 1)
			prev_fd = pipefd[0];
		cur = cur->next;
	}
	if (prev_fd >= 0)
		close(prev_fd);
	*cmds = cur;
	return (0);
}

int	exec_builtin_in_parent(t_cmd *cmd, t_shell *shell)
{
	int	saved_in;
	int	saved_out;
	int	ret;

	saved_in = dup(STDIN_FILENO);
	saved_out = dup(STDOUT_FILENO);
	if (ms_redirect(cmd->redirs) != 0)
		ret = 1;
	else
		ret = ms_exec_builtin(cmd, shell);
	dup2(saved_in, STDIN_FILENO);
	dup2(saved_out, STDOUT_FILENO);
	close(saved_in);
	close(saved_out);
	return (ret);
}

int	ms_execute(t_cmd *cmds, t_shell *shell)
{
	t_cmd	*cur;
	int		skip;

	cur = cmds;
	while (cur != NULL)
	{
		skip = 0;
		if (cur->op_before == T_AND && shell->exit_status != 0)
			skip = 1;              /* && : skip si échec */
		else if (cur->op_before == T_OR && shell->exit_status == 0)
			skip = 1;              /* || : skip si succès */
		if (!skip)
			exec_pipeline(&cur, shell);
		else
			cur = cur->next;
	}
	return (0);
}

int	ms_heredoc(char *delimiter)
{
	char	*line;
	int		fd[2];

	if (pipe(fd) < 0)
		return (ms_perror("pipe"));
	while (1)
	{
		line = readline("> ");
		if (line == NULL)
			break ;
		if (ft_strcmp(line, delimiter) == 0)
		{
			free(line);
			break ;
		}
		write(fd[1], line, ft_strlen(line));
		write(fd[1], "\n", 1);
		free(line);
	}
	close(fd[1]);
	return (fd[0]);   /* retourne le fd de lecture */
}

NAME        = minishell
CC          = cc
CFLAGS      = -Wall -Wextra -Werror -g
LDFLAGS     = /usr/lib/x86_64-linux-gnu/libreadline.so.8

LIBFT_DIR   = libft
LIBFT       = $(LIBFT_DIR)/libft.a
INCLUDES    = -I includes -I $(LIBFT_DIR)

# Compilation par .o (incrémental, pas de re-link)
%.o:        %.c $(HEADERS)
            $(CC) $(CFLAGS) $(INCLUDES) -c $< -o $@

# Link final avec libft + readline
$(NAME):    $(OBJS) $(LIBFT) $(HEADERS)
            $(CC) $(CFLAGS) $(INCLUDES) $(OBJS) $(LIBFT) $(LDFLAGS) -o $(NAME)

# Compile la libft via son propre Makefile
$(LIBFT):
            make -C $(LIBFT_DIR)