我正在尝试创建一个minishell项目。我已经完成了将命令解析为列表/令牌的过程。当我使用管道执行命令时，我会遇到一些奇怪的行为。例如，如果我在minishell中键入“echo hi| wc”输出是正确的，但是之后显示了一个空行，我仍然可以在它返回到我原来的进程之前，在其中输入另一个命令来执行。是否挂在一个进程中？

➜  minishell git:() ✗ make; ./minishell
$> echo hi | wc
$>        1       1       3
echo test
test
$>

另外，考虑到我下面的代码，我担心它会等待一个进程完成后再继续下一个进程。例如，如果我执行下面的命令，它应该首先立即返回Makefile的单词计数结果，然后继续睡眠，但似乎我的代码首先睡眠，然后返回结果。如何确保我的代码完全像在bash中一样执行？

➜  minishell git:() ✗ make; ./minishell
$> sleep 6 | cat Makefile | wc
$>      149     499    4252

我提供了下面的片段，如果需要，可以分享任何进一步的信息。由于代码的大小，我不能提供一个最小的可复制的样本。任何帮助将不胜感激！（请忽略注解掉的部分，即“网格”，它不应该影响代码性能。

int GLOBAL_ERROR = 0;

 void   close_pipes(int pipes[1000][2] , int lines)
{
    int i;

    i = 0;
    while (i < lines - 1)
    {
        close(pipes[i][0]);
        close(pipes[i][1]);
        i++;
    }
}

int assign_pi(t_mhstruct **mh)
{
    t_token *current;
    int     idx;

    current = (*mh)->token;
    idx = 0;
    while (current)
    {
        while (current->type != PIPELINE && current)
        {
            current->pi = idx;
            if (current->next)
                current = current->next;
            else
                break;
        }
        if (current)
            current = current->next;
        idx++;
    }   
    return (idx);
}

int get_args_size_pipes(t_token *tmp)
{
    int     i;

    i = 0;
    if (!tmp)
        return (0);
    while (tmp && tmp->type != PIPELINE)
    {
        i++;
        tmp = tmp->next;
    }
    return (i);
}

char    **get_args_pipes(t_token *token, t_mhstruct *mh)
{
    char    **out;
    int     i;
    (void) mh;

    i =get_args_size_pipes(token);
    out = (char **)malloc((i + 1) * sizeof(char *));
    if (!out)
        return (NULL);
    i = 0;
    while (token && token->type != PIPELINE)
    {
        out[i] = ft_strdup(token->data);
        token = token->next;
        i++;
    }
    out[i] = NULL;
    return (out);
}

void    execve_commands_pipes(t_token *curr, t_mhstruct *mh)
{
    char    **arg;
    char    **env;
    char    *path;
    int     out;
    int     pid;

    path = NULL;
    out = 0;
    env = get_env_array(mh);
    arg = get_args_pipes(curr, mh);
    if (check_path(arg[0], env, &path) == 0)
    {
        if (access(arg[0], R_OK) == 0)
            path = arg[0];
        else
        {
            free(env);
            free(arg);
            return (pr_err(mh, 127, gemsg(mh->emsg[11], mh->emsg[12], arg[0])));
        }
    }
    pid = fork();
    if (pid == 0)
        execve(path, arg, env);
    waitpid(pid, &GLOBAL_ERROR, 0);
    return;
}

void    set_pipe(t_token *curr, int pipes[1000][2], int i, int lines, int screen)
{

    (void) curr;
    (void) screen;
    if (i == 0)
    {
        close(pipes[i][0]);
        dup2(pipes[i][1], STDOUT_FILENO);
        close(pipes[i][1]);
    
    }
    else if (i != 0 && i != lines - 1)
    {
        dup2(pipes[i - 1][0], STDIN_FILENO);
        close(pipes[i - 1][0]);
        dup2(pipes[i][1], STDOUT_FILENO);
        close(pipes[i][1]);
    }
    else if (i == lines - 1)
    {
        close(pipes[i - 1][1]);
        dup2(pipes[i - 1][0], STDIN_FILENO);
        close(pipes[i - 1][0]);
    }
    
}

void    do_pipe_forks(t_mhstruct **mh, int pipes[1000][2], int  i, int  lines, int screen)
{
    int     pid;
    t_token *curr;
    (void) screen;
    curr = (*mh)->token;
    while (curr && curr->pi != i)
        curr = curr->next;
    pid = fork();
    if (pid == 0)
    {
        
        set_pipe(curr, pipes, i, lines, screen);
        close_pipes(pipes, lines - 1);
        execve_commands_pipes(curr, *mh);
        exit(1);
    }
}

void    do_pipes(t_mhstruct **mh, char **grid, int lines)
{
    int screen = dup(STDOUT_FILENO);
    int i;
    int pipes[1000][2];
    (void) grid;
    
    i = 0;
    while (i < lines - 1) 
    {
        pipe(pipes[i]);
        i++;
    }
    i = 0;
    while (i < lines)
    {
        do_pipe_forks(mh, pipes, i, lines, screen);
        i++;
    }
    close_pipes(pipes, lines);
}

int launch_pipes(t_mhstruct **mh)
{
    int     lines;
    char    **grid = NULL;
    
    lines = assign_pi(mh);

    // grid = (char **)malloc(sizeof(char **) * (lines + 1));
    // if (!grid)
    //  return (1);
    // create_grid(grid, lines, mh);
    do_pipes(mh, grid, lines);

    // free_all(grid);
    return (0);
}