实现简单的命令行解析器 (#49)

Cargo.toml

@@ -17,3 +17,5 @@ num_enum_derive = "0.7.1"
 path-clean = "1.0.1"
 crossterm = "0.27.0"
 colored = "2.1.0"
+which = "6.0.3"
+concat-idents = "1.1.5"

src/env.rs

@@ -1,109 +1,24 @@
 use std::{
-    collections::HashMap,
-    fmt,
     fs::File,
     io::{Read, Write},
-    ops::{Deref, DerefMut},
     path::Path,
 };
 
 pub const ROOT_PATH: &str = "/";
-pub const ENV_FILE_PATH: &str = "/etc/profile";
 
-#[derive(Clone, Debug)]
-pub struct EnvEntry {
-    /// 环境变量的名称
-    name: String,
-    /// 环境变量值的原始字符串，多个值之间使用':'分隔
-    origin: String,
-    /// 值分割后的集合
-    collection: Vec<String>,
-}
-
-impl EnvEntry {
-    pub fn new(env: String) -> Option<EnvEntry> {
-        let split_result = env.split('=').collect::<Vec<&str>>();
-        if split_result.len() != 2 || split_result.contains(&"") {
-            return None;
-        }
-
-        let name = split_result.get(0).unwrap().to_string();
-        let origin = split_result.get(1).unwrap().to_string();
-
-        let collection = origin
-            .split(':')
-            .filter_map(|str| {
-                let path = String::from(str);
-                if Path::new(&path).is_dir() {
-                    Some(path)
-                } else {
-                    None
-                }
-            })
-            .collect::<Vec<String>>();
-
-        Some(EnvEntry {
-            name,
-            origin,
-            collection,
-        })
-    }
-
-    #[allow(dead_code)]
-    pub fn name(&self) -> &String {
-        &self.name
-    }
-
-    pub fn origin(&self) -> &String {
-        &self.origin
-    }
-
-    #[allow(dead_code)]
-    pub fn collection(&self) -> &Vec<String> {
-        &self.collection
-    }
-}
-
-impl fmt::Display for EnvEntry {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{}={}", self.name, self.origin)
-    }
-}
-
-pub struct Env(HashMap<String, EnvEntry>);
-
-static mut ENV: Option<Env> = None;
-
-impl Deref for Env {
-    type Target = HashMap<String, EnvEntry>;
-
-    fn deref(&self) -> &Self::Target {
-        &self.0
-    }
-}
+pub struct EnvManager;
 
-impl DerefMut for Env {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.0
-    }
-}
+impl EnvManager {
+    pub const ENV_FILE_PATH: &str = "/etc/profile";
 
-impl Env {
-    /// 初始化环境变量结构体
+    /// 初始化环境变量相关信息
     pub fn init() {
-        // unsafe { ENV = Some(std::sync::Mutex::new(Env(HashMap::new()))) };
-        unsafe { ENV = Some(Env(HashMap::new())) };
         Self::read_env();
     }
 
-    /// 获取Env引用
-    pub fn env() -> &'static mut Env {
-        unsafe { ENV.as_mut().unwrap() }
-    }
-
     /// 初始化环境变量文件
     pub fn init_envfile() {
-        let mut file = File::create(ENV_FILE_PATH).unwrap();
+        let mut file = File::create(Self::ENV_FILE_PATH).unwrap();
         file.write_all("PATH=/bin:/usr/bin:/usr/local/bin\n".as_bytes())
             .unwrap();
         file.write_all("PWD=/\n".as_bytes()).unwrap();
@@ -112,50 +27,21 @@ impl Env {
     /// 读取环境变量文件
     /// 如果文件不存在则创建
     pub fn read_env() {
-        let env = unsafe { ENV.as_mut().unwrap() };
-
-        if !Path::new(ENV_FILE_PATH).exists() {
-            Env::init_envfile();
+        if !Path::new(Self::ENV_FILE_PATH).exists() {
+            Self::init_envfile();
         }
-        let mut file = File::open(ENV_FILE_PATH).unwrap();
+
+        let mut file = File::open(Self::ENV_FILE_PATH).unwrap();
         let mut buf: Vec<u8> = Vec::new();
         file.read_to_end(&mut buf).unwrap();
 
         for str in String::from_utf8(buf).unwrap().split('\n') {
-            if let Some(entry) = EnvEntry::new(str.to_string()) {
-                env.insert(entry.name.clone(), entry);
+            if let Some(index) = str.find('=') {
+                std::env::set_var(&str[..index], &str[index + 1..]);
             }
         }
     }
 
-    pub fn get(key: &String) -> Option<&EnvEntry> {
-        let env = unsafe { ENV.as_ref().unwrap() };
-        env.0.get(key)
-    }
-
-    pub fn insert(key: String, value: String) {
-        if let Some(entry) = EnvEntry::new(value) {
-            Self::env().insert(key, entry);
-        }
-    }
-
-    /// 获取PATH环境变量的值（已分割）
-    pub fn path() -> Vec<String> {
-        let env = Self::env();
-        env.get("PATH").unwrap().collection.clone()
-        // paths
-        //     .split(':')
-        //     .filter_map(|str| {
-        //         let path = String::from(str);
-        //         if Path::new(&path).is_dir() {
-        //             Some(path)
-        //         } else {
-        //             None
-        //         }
-        //     })
-        //     .collect::<Vec<String>>()
-    }
-
     pub fn current_dir() -> String {
         std::env::current_dir()
             .expect("Error getting current directory")
@@ -163,38 +49,4 @@ impl Env {
             .unwrap()
             .to_string()
     }
-
-    /// 从环境变量搜索路径，返回第一个匹配的绝对路径
-    pub fn search_path_from_env(path: &String) -> Option<String> {
-        let mut absolute_path = String::new();
-        if !path.contains('/') {
-            let mut dir_collection = Env::path();
-            dir_collection.insert(0, Self::current_dir());
-            for dir in dir_collection {
-                let possible_path = format!("{}/{}", dir, path);
-                if Path::new(&possible_path).is_file() {
-                    absolute_path = possible_path;
-                    break;
-                }
-            }
-            if absolute_path.is_empty() {
-                return None;
-            } else {
-                return Some(absolute_path);
-            }
-        } else if Path::new(path).exists() {
-            return Some(path.clone());
-        } else {
-            return None;
-        }
-    }
-
-    /// 返回所有环境变量的集合
-    pub fn get_all() -> Vec<(String, String)> {
-        let mut vec = Vec::new();
-        for (name, entry) in Self::env().iter() {
-            vec.push((name.clone(), entry.origin.clone()));
-        }
-        vec
-    }
 }

src/main.rs

@@ -11,11 +11,13 @@ mod keycode;
 
 mod env;
 
-use env::Env;
+mod parser;
+
+use env::EnvManager;
 use shell::Shell;
 
 fn main() {
-    Env::init();
+    EnvManager::init();
     let mut shell = Shell::new();
     shell.exec();
     return;

src/parser.rs

@@ -0,0 +1,652 @@
+use std::{
+    collections::HashMap,
+    io::ErrorKind,
+    os::fd::{AsRawFd, FromRawFd},
+    process::{Child, ChildStdout, Stdio},
+    sync::{Arc, Mutex},
+};
+
+use regex::Regex;
+
+#[derive(Debug)]
+pub enum Token {
+    Word(String),   // 普通的命令或选项
+    Symbol(String), // 特殊符号
+}
+
+#[derive(Debug, Clone)]
+pub enum CommandType {
+    Simple, // 简单命令
+    Redirect {
+        target: RedirectTarget,
+        mode: RedirectMode,
+    }, // 重定向命令
+    Pipe,   // 管道命令
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Copy)]
+pub enum ConnectType {
+    Simple, // 普通连接
+    And,    // 与连接
+    Or,     // 或连接
+}
+
+#[derive(Debug, Clone)]
+pub struct Command {
+    name: String,
+    args: Vec<String>,
+    cmd_type: CommandType,
+    conn_type: ConnectType,
+}
+
+impl Command {
+    pub fn new(
+        name: &String,
+        args: &[String],
+        cmd_type: CommandType,
+        conn_type: ConnectType,
+    ) -> Command {
+        Self {
+            name: name.clone(),
+            args: args.to_vec(),
+            cmd_type,
+            conn_type,
+        }
+    }
+
+    pub fn execute(&self) {}
+}
+
+#[derive(Debug, Clone)]
+pub enum RedirectTarget {
+    File(String),
+    FileDiscriptor(i32),
+}
+
+impl RedirectTarget {
+    pub fn from_string(str: &String) -> Option<RedirectTarget> {
+        if str.starts_with("&") {
+            if let Ok(fd) = str.split_at(1).1.parse::<i32>() {
+                Some(RedirectTarget::FileDiscriptor(fd))
+            } else {
+                None
+            }
+        } else {
+            Some(RedirectTarget::File(str.clone()))
+        }
+    }
+}
+
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+pub enum RedirectMode {
+    Overwrite,
+    Append,
+}
+
+impl RedirectMode {
+    pub fn from_string(str: &String) -> Option<RedirectMode> {
+        match str.as_str() {
+            ">" => Some(RedirectMode::Overwrite),
+            ">>" => Some(RedirectMode::Append),
+            _ => None,
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub enum ParseError {
+    UnexpectedInput(String),
+    UnsupportedToken(String),
+    UnexpectedToken(String),
+}
+
+impl ParseError {
+    pub fn handle(&self) {
+        match self {
+            ParseError::UnexpectedInput(str) => eprintln!("Unexpected input: \"{str}\""),
+            ParseError::UnsupportedToken(str) => eprintln!("Unsupported token: \"{str}\""),
+            ParseError::UnexpectedToken(str) => eprintln!("Unexpected token: \"{str}\""),
+        }
+    }
+}
+
+pub struct Parser;
+
+impl Parser {
+    fn parse_env(str: &str) -> String {
+        std::env::var(str).unwrap_or(String::new())
+    }
+
+    fn lexer(input: &str) -> Result<Vec<Token>, ParseError> {
+        let mut tokens = Vec::new();
+
+        // 匹配环境变量的正则表达式
+        let env_token = Regex::new(r#"\$\{(\w[\w\d_]*)\}"#).unwrap();
+
+        // 使用具体的符号组合来匹配
+        let regex_token =
+            Regex::new(r#"([^'";|&$\s]+)|(["'].*?["'])|(&&|\|\||<<|>>|[<>|&;])"#).unwrap();
+
+        // 预先替换"${}"包围的环境变量
+        let remaining_input = env_token
+            .replace_all(input, |captures: &regex::Captures| {
+                Self::parse_env(&captures[1])
+            })
+            .into_owned();
+
+        let mut remaining_input = remaining_input.trim();
+
+        while !remaining_input.is_empty() {
+            if let Some(mat) = regex_token.find(remaining_input) {
+                let token_str = mat.as_str();
+                if token_str.starts_with('"') || token_str.starts_with('\'') {
+                    tokens.push(Token::Word(token_str[1..token_str.len() - 1].to_string()));
+                } else if token_str.starts_with('$') {
+                    tokens.push(Token::Word(Self::parse_env(&token_str[1..])));
+                } else if token_str == ">>"
+                    || token_str == ">"
+                    || token_str == "<<"
+                    || token_str == "<"
+                    || token_str == "|"
+                    || token_str == "&"
+                    || token_str == ";"
+                    || token_str == "&&"
+                    || token_str == "||"
+                {
+                    if token_str == "<" || token_str == "<<" {
+                        return Err(ParseError::UnsupportedToken(token_str.to_string()));
+                    }
+                    tokens.push(Token::Symbol(token_str.to_string()));
+                } else {
+                    tokens.push(Token::Word(token_str.to_string()));
+                }
+
+                remaining_input = &remaining_input[mat.end()..].trim();
+            } else {
+                return Err(ParseError::UnexpectedInput(remaining_input.to_string()));
+            }
+        }
+        Ok(tokens)
+    }
+
+    fn parser(tokens: Vec<Token>) -> Result<Vec<Pipeline>, ParseError> {
+        let mut commands = Vec::new();
+        let mut current_command: Vec<String> = Vec::new();
+        let mut pipelines = Vec::new();
+        let mut redirect_object: (Option<RedirectMode>, Option<RedirectTarget>) = (None, None);
+
+        for token in tokens {
+            match token {
+                Token::Word(ref word) => {
+                    if let (Some(_), None) = redirect_object {
+                        redirect_object.1 = RedirectTarget::from_string(word);
+                    } else {
+                        current_command.push(word.to_string());
+                    }
+                }
+
+                Token::Symbol(symbol) => {
+                    match symbol.as_str() {
+                        ">" | ">>" => {
+                            // 重定向符号不能重复出现
+                            if redirect_object.0.is_some() {
+                                return Err(ParseError::UnexpectedToken(symbol));
+                            } else {
+                                redirect_object.0 = RedirectMode::from_string(&symbol);
+                            }
+                        }
+                        "|" | "&" | "||" | "&&" | ";" => {
+                            if let Some((name, args)) = current_command.split_first() {
+                                let mut cmd_type =
+                                    if let (Some(mode), Some(ref target)) = redirect_object {
+                                        CommandType::Redirect {
+                                            target: target.clone(),
+                                            mode,
+                                        }
+                                    } else {
+                                        CommandType::Simple
+                                    };
+
+                                let conn_type = match symbol.as_str() {
+                                    "|" => {
+                                        // 重定向优先级高于管道
+                                        if let CommandType::Simple = cmd_type {
+                                            cmd_type = CommandType::Pipe;
+                                        }
+                                        ConnectType::Simple
+                                    }
+                                    "&" | ";" => ConnectType::Simple,
+                                    "||" => ConnectType::Or,
+                                    "&&" => ConnectType::And,
+                                    _ => todo!(),
+                                };
+
+                                commands.push(Command::new(name, args, cmd_type, conn_type));
+                                current_command.clear();
+
+                                if symbol == "&" {
+                                    pipelines.push(Pipeline::new(&commands, true));
+                                    commands.clear();
+                                }
+                            } else {
+                                // 这些符号之前必须有word作为命令被分隔，否则这些符号是没有意义的
+                                return Err(ParseError::UnexpectedToken(symbol));
+                            }
+                        }
+                        _ => todo!(),
+                    }
+                }
+            }
+        }
+
+        // 处理最后一个命令
+        if let Some((name, args)) = current_command.split_first() {
+            commands.push(Command::new(
+                name,
+                args,
+                if let (Some(mode), Some(ref target)) = redirect_object {
+                    CommandType::Redirect {
+                        target: target.clone(),
+                        mode,
+                    }
+                } else {
+                    CommandType::Simple
+                },
+                ConnectType::Simple,
+            ));
+        }
+
+        if !commands.is_empty() {
+            pipelines.push(Pipeline::new(&commands, false));
+        }
+
+        Ok(pipelines)
+    }
+
+    pub fn parse(input: &str) -> Result<Vec<Pipeline>, ParseError> {
+        // 解析输入并生成token列表
+        let tokens = Self::lexer(input)?;
+        // println!("tokens: {tokens:?}");
+
+        // 解析 tokens 生成命令流水线
+        Self::parser(tokens)
+    }
+}
+
+#[allow(dead_code)]
+#[derive(Debug)]
+pub struct ExecuteError {
+    name: String,
+    err_type: ExecuteErrorType,
+}
+
+impl ExecuteError {
+    pub fn handle(&self, prompt: Option<String>) {
+        if let Some(prompt) = prompt {
+            eprint!("{}: ", prompt);
+        }
+        eprint!("{}: ", self.name);
+        match &self.err_type {
+            ExecuteErrorType::CommandNotFound => eprintln!("Command not found"),
+            ExecuteErrorType::FileNotFound(file) => eprintln!("Not a file or directory: {}", file),
+            ExecuteErrorType::NotDir(ref path) => eprintln!("Not a Directory: {path}"),
+            ExecuteErrorType::NotFile(ref path) => eprintln!("Not a File: {path}"),
+            ExecuteErrorType::PermissionDenied(ref file) => eprintln!("File open denied: {file}"),
+            ExecuteErrorType::ExecuteFailed => eprintln!("Command execute failed"),
+            ExecuteErrorType::ExitWithCode(exit_code) => {
+                eprintln!("Command exit with code: {}", exit_code)
+            }
+            ExecuteErrorType::ProcessTerminated => eprintln!("Process terminated"),
+            ExecuteErrorType::FileOpenFailed(file) => {
+                eprintln!("File open failed: {}", file.clone())
+            }
+            ExecuteErrorType::TooManyArguments => eprintln!("Too many arguments"),
+            ExecuteErrorType::TooFewArguments => eprintln!("Too few arguments"),
+            ExecuteErrorType::InvalidArgument(arg) => eprintln!("Invalid argument: {}", arg),
+        }
+    }
+}
+
+#[allow(dead_code)]
+#[derive(Debug, Clone)]
+pub enum ExecuteErrorType {
+    CommandNotFound,
+    FileNotFound(String),
+    NotDir(String),
+    NotFile(String),
+    PermissionDenied(String),
+    ExecuteFailed,
+    ProcessTerminated,
+    ExitWithCode(i32),
+    FileOpenFailed(String),
+    TooManyArguments,
+    TooFewArguments,
+    InvalidArgument(String),
+}
+
+pub enum RedirectStdout {
+    Stdout(Option<ChildStdout>),
+    RawPipe(i32),
+}
+
+impl RedirectStdout {
+    pub fn as_raw_fd(&mut self) -> i32 {
+        match self {
+            RedirectStdout::Stdout(child_stdout) => child_stdout.take().unwrap().as_raw_fd(),
+            RedirectStdout::RawPipe(fd) => *fd,
+        }
+    }
+
+    pub fn as_std(&mut self) -> Stdio {
+        match self {
+            RedirectStdout::Stdout(child_stdout) => Stdio::from(child_stdout.take().unwrap()),
+            RedirectStdout::RawPipe(fd) => unsafe { Stdio::from_raw_fd(*fd) },
+        }
+    }
+}
+
+impl From<i32> for RedirectStdout {
+    fn from(value: i32) -> Self {
+        RedirectStdout::RawPipe(value)
+    }
+}
+
+impl From<Option<ChildStdout>> for RedirectStdout {
+    fn from(mut value: Option<ChildStdout>) -> Self {
+        RedirectStdout::Stdout(value.take())
+    }
+}
+
+#[derive(Debug)]
+pub struct Pipeline {
+    commands: Vec<Command>, // 存储一系列命令
+    backend: bool,
+}
+
+type CommandMap = HashMap<String, fn(&Vec<String>) -> Result<(), ExecuteErrorType>>;
+
+impl Pipeline {
+    pub fn new(commands: &Vec<Command>, backend: bool) -> Pipeline {
+        Self {
+            commands: commands.to_vec(),
+            backend,
+        }
+    }
+
+    pub fn execute(&self, internal_commands: Option<Arc<Mutex<CommandMap>>>) -> Vec<Child> {
+        // 前一个命令是否为管道输出
+        let mut stdout: Option<RedirectStdout> = None;
+        // 提前推断下条命令的布尔值，为None代表下条命令需要运行
+        let mut result_next: Option<bool> = None;
+        let mut children: Vec<Child> = Vec::new();
+        let mut err: Option<ExecuteErrorType> = None;
+
+        for cmd in self.commands.iter() {
+            if let Some(result) = result_next {
+                // 如果前面已经推导出本条命令的布尔值，则本条命令不需要执行，并继续推断下条命令
+                if (result && cmd.conn_type == ConnectType::And)
+                    || (!result && cmd.conn_type == ConnectType::Or)
+                {
+                    // 如果true遇到||或false遇到&&，则下条命令的布尔值相同
+                    // 如果true遇到&&或false遇到||，继承中断，设为None以执行后续命令
+                    result_next = None;
+                }
+                continue;
+            }
+
+            let mut internal = false;
+            if let Some(ref map) = internal_commands {
+                let map = map.lock().unwrap();
+                if let Some(f) = map.get(&cmd.name) {
+                    // 找到内部命令，优先执行，设置标记
+                    internal = true;
+
+                    // child_fd
+                    let child_fd = if self.backend {
+                        unsafe { libc::fork() }
+                    } else {
+                        0
+                    };
+
+                    // 为子进程或前台运行
+                    if child_fd == 0 {
+                        let mut old_stdin: Option<i32> = None;
+                        let mut old_stdout: Option<i32> = None;
+
+                        // 如果上条命令为管道，将标准输入重定向
+                        if let Some(mut redirect_stdout) = stdout {
+                            unsafe {
+                                old_stdin = Some(libc::dup(libc::STDIN_FILENO));
+                                libc::dup2(redirect_stdout.as_raw_fd(), libc::STDIN_FILENO);
+                                stdout = None;
+                            }
+                        }
+
+                        // 根据命令类型重定向标准输出
+                        match cmd.cmd_type {
+                            CommandType::Simple => {}
+                            CommandType::Pipe => unsafe {
+                                let mut pipe: [i32; 2] = [0; 2];
+                                libc::pipe2(pipe.as_mut_ptr(), libc::O_CLOEXEC);
+                                stdout = Some(RedirectStdout::from(pipe[0]));
+
+                                old_stdout = Some(libc::dup(libc::STDOUT_FILENO));
+
+                                libc::dup2(pipe[1], libc::STDOUT_FILENO);
+                            },
+                            CommandType::Redirect {
+                                ref target,
+                                ref mode,
+                            } => unsafe {
+                                let mut pipe: [i32; 2] = [0; 2];
+                                libc::pipe2(pipe.as_mut_ptr(), libc::O_CLOEXEC);
+                                stdout = Some(RedirectStdout::from(pipe[0]));
+
+                                old_stdout = Some(libc::dup(libc::STDOUT_FILENO));
+
+                                let append = match mode {
+                                    RedirectMode::Overwrite => false,
+                                    RedirectMode::Append => true,
+                                };
+
+                                match target {
+                                    RedirectTarget::File(file) => {
+                                        match std::fs::OpenOptions::new()
+                                            .write(true)
+                                            .append(append)
+                                            .create(true)
+                                            .open(file)
+                                        {
+                                            Ok(file) => {
+                                                libc::dup2(file.as_raw_fd(), libc::STDIN_FILENO);
+                                            }
+
+                                            Err(_) => {
+                                                err = Some(ExecuteErrorType::FileOpenFailed(
+                                                    file.clone(),
+                                                ));
+                                            }
+                                        };
+                                    }
+                                    RedirectTarget::FileDiscriptor(fd) => {
+                                        libc::dup2(*fd, libc::STDIN_FILENO);
+                                    }
+                                }
+                            },
+                        }
+
+                        // 如果之前没有出错，执行命令
+                        if err.is_none() {
+                            match f(&cmd.args) {
+                                Ok(_) => err = None,
+                                Err(err_type) => err = Some(err_type),
+                            }
+                        }
+
+                        // 还原标准输出
+                        unsafe {
+                            if let Some(old_stdin) = old_stdin {
+                                libc::dup2(old_stdin, libc::STDIN_FILENO);
+                            }
+
+                            if let Some(old_stdout) = old_stdout {
+                                libc::dup2(old_stdout, libc::STDOUT_FILENO);
+                            }
+                        }
+                    } else if child_fd < 0 {
+                        err = Some(ExecuteErrorType::ExecuteFailed)
+                    }
+
+                    // 后台命令且当前进程为父进程
+                    if self.backend && !child_fd == 0 {
+                        err = match unsafe { libc::waitpid(child_fd, std::ptr::null_mut(), 0) } {
+                            -1 => Some(ExecuteErrorType::ExecuteFailed),
+                            _ => None,
+                        }
+                    }
+                }
+            };
+
+            // 没找到执行内部命令的标记，尝试作为外部命令执行
+            if !internal {
+                let path = if cmd.name.contains('/') {
+                    // 为路径，获取规范的绝对路径
+                    if let Ok(path) = std::fs::canonicalize(&cmd.name) {
+                        if path.is_file() {
+                            Ok(path)
+                        } else {
+                            // 路径不为文件，返回错误
+                            Err(ExecuteErrorType::NotFile(cmd.name.clone()))
+                        }
+                    } else {
+                        Err(ExecuteErrorType::CommandNotFound)
+                    }
+                } else {
+                    // 不为路径，从环境变量中查找命令
+                    which::which(&cmd.name).map_err(|_| ExecuteErrorType::CommandNotFound)
+                };
+
+                // println!("path: {:?}", path);
+
+                match path {
+                    Err(e) => err = Some(e),
+                    Ok(real_path) => {
+                        let mut child_command = std::process::Command::new(real_path);
+                        child_command.args(cmd.args.clone());
+                        child_command.current_dir(std::env::current_dir().unwrap());
+                        if stdout.is_some() {
+                            child_command.stdin(stdout.take().unwrap().as_std());
+                        }
+
+                        match &cmd.cmd_type {
+                            CommandType::Simple => {}
+                            CommandType::Redirect { target, mode } => {
+                                let append = match mode {
+                                    RedirectMode::Overwrite => false,
+                                    RedirectMode::Append => true,
+                                };
+                                match target {
+                                    RedirectTarget::File(file) => {
+                                        match std::fs::OpenOptions::new()
+                                            .write(true)
+                                            .append(append)
+                                            .create(true)
+                                            .open(file)
+                                        {
+                                            Ok(file) => {
+                                                child_command.stdout(file);
+                                            }
+                                            Err(_) => {
+                                                err = Some(ExecuteErrorType::FileOpenFailed(
+                                                    file.clone(),
+                                                ));
+                                            }
+                                        };
+                                    }
+                                    RedirectTarget::FileDiscriptor(fd) => {
+                                        child_command.stdout(unsafe { Stdio::from_raw_fd(*fd) });
+                                    }
+                                }
+                            }
+                            CommandType::Pipe => {
+                                // 标准输出重定向到管道
+                                child_command.stdout(Stdio::piped());
+                            }
+                        }
+
+                        if err.is_none() {
+                            match child_command.spawn() {
+                                Ok(mut child) => {
+                                    // 如果为管道命令，记录下来
+                                    if let CommandType::Pipe = cmd.cmd_type {
+                                        stdout = Some(RedirectStdout::Stdout(child.stdout.take()));
+                                    }
+
+                                    // println!("exec command: {child_command:#?}");
+
+                                    match child.wait() {
+                                        Ok(exit_status) => match exit_status.code() {
+                                            Some(exit_code) => {
+                                                if exit_code != 0 {
+                                                    err = Some(ExecuteErrorType::ExitWithCode(
+                                                        exit_code,
+                                                    ));
+                                                }
+                                            }
+                                            None => err = Some(ExecuteErrorType::ProcessTerminated),
+                                        },
+                                        Err(_) => err = Some(ExecuteErrorType::ExecuteFailed),
+                                    };
+
+                                    children.push(child);
+                                }
+
+                                Err(e) => match e.kind() {
+                                    ErrorKind::PermissionDenied => {
+                                        err = Some(ExecuteErrorType::PermissionDenied(
+                                            cmd.name.clone(),
+                                        ))
+                                    }
+                                    _ => eprintln!("Error occurred: {}", e.kind()),
+                                },
+                            }
+                        }
+                    }
+                }
+            }
+
+            // 预计算下条命令的结果
+            result_next = match err {
+                Some(ref e) => {
+                    ExecuteError {
+                        name: cmd.name.clone(),
+                        err_type: e.clone(),
+                    }
+                    .handle(if internal {
+                        Some("internal command".to_string())
+                    } else {
+                        None
+                    });
+                    if cmd.conn_type == ConnectType::And {
+                        Some(false)
+                    } else {
+                        None
+                    }
+                }
+                None => {
+                    if cmd.conn_type == ConnectType::Or {
+                        Some(true)
+                    } else {
+                        None
+                    }
+                }
+            }
+        }
+
+        children
+    }
+
+    pub fn backend(&self) -> bool {
+        self.backend
+    }
+}

src/shell/command/help.rs

@@ -1,16 +1,35 @@
-pub struct Help {}
-
-impl Help {
-    pub fn shell_help(cmd: &str) {
-        match cmd {
-            "cd" => Self::shell_help_cd(),
-            "exec" => Self::shell_help_exec(),
-            "reboot" => Self::shell_help_reboot(),
-            "compgen" => Self::shell_help_compgen(),
-            "complete" => Self::shell_help_complete(),
-
-            _ => {}
-        };
+use std::{collections::HashMap, sync::Mutex};
+
+type HelpMap = HashMap<String, fn() -> ()>;
+
+macro_rules! help {
+    ($cmd:expr,$func:expr) => {
+        ($cmd.to_string(), $func as fn() -> ())
+    };
+}
+
+static mut HELP_MAP: Option<Mutex<HelpMap>> = None;
+
+#[derive(Debug)]
+pub struct Helper;
+
+impl Helper {
+    pub unsafe fn help() {
+        let map = HELP_MAP.as_ref().unwrap().lock().unwrap();
+        for (name, func) in map.iter() {
+            print!("{name}:",);
+            func();
+        }
+    }
+
+    pub unsafe fn init() {
+        HELP_MAP = Some(Mutex::new(HelpMap::new()));
+        let mut map = HELP_MAP.as_ref().unwrap().lock().unwrap();
+
+        let mut insert = |tuple: (String, fn() -> ())| map.insert(tuple.0, tuple.1);
+
+        insert(help!("cd", Self::shell_help_cd));
+        insert(help!("exec", Self::shell_help_exec));
     }
 
     fn shell_help_cd() {
@@ -20,10 +39,4 @@ impl Help {
     fn shell_help_exec() {
         println!("exec: exec file");
     }
-
-    fn shell_help_reboot() {}
-
-    fn shell_help_compgen() {}
-
-    fn shell_help_complete() {}
 }

src/shell/command/mod.rs

@@ -1,345 +1,140 @@
-use help::Help;
-use path_clean::PathClean;
-use regex::{Captures, Regex};
-use std::{format, fs::File, io::Read, path::Path, print, println};
+use help::Helper;
+use std::collections::HashMap;
+use std::sync::{Arc, Mutex};
+use std::{fs::File, io::Read, print};
 
-use crate::env::{Env, ROOT_PATH};
-use crate::shell::Shell;
+use crate::env::{EnvManager, ROOT_PATH};
+use crate::parser::ExecuteErrorType;
 
 mod help;
 
-#[derive(Debug, PartialEq, Eq, Clone)]
-enum CommandType {
-    InternalCommand(BuildInCmd),
-    ExternalCommand(String),
+macro_rules! build {
+    ($cmd:expr,$func:expr) => {
+        (
+            $cmd.to_string(),
+            $func as fn(&Vec<String>) -> Result<(), ExecuteErrorType>,
+        )
+    };
 }
 
-#[derive(Debug, PartialEq, Eq, Clone)]
-pub struct Command {
-    args: Vec<String>,
-    cmd_type: CommandType,
-    run_backend: bool,
-}
-
-#[allow(dead_code)]
-#[derive(Debug, PartialEq, Eq, Clone)]
-pub enum CommandError {
-    CommandNotFound(String),
-    InvalidArgument(String),
-    WrongArgumentCount(usize),
-    EnvironmentVariableNotFound(String),
-    PathNotFound(String),
-    FileNotFound(String),
-    DirectoryNotFound(String),
-    NotDirectory(String),
-    NotFile(String),
-    UnclosedQuotation(usize),
-    UnableGetArg,
-    EmptyCommand,
-}
-
-impl CommandError {
-    pub fn handle(e: CommandError) {
-        match e {
-            CommandError::CommandNotFound(command) => {
-                println!("cannot find command: {}", command)
-            }
-            CommandError::InvalidArgument(argument) => {
-                println!("invalid argument: {}", argument)
-            }
-            CommandError::WrongArgumentCount(count) => {
-                println!("argument count incorrect: {}", count)
-            }
-            CommandError::EnvironmentVariableNotFound(env) => {
-                println!("environment variable not found: {}", env);
-            }
-            CommandError::PathNotFound(path) => {
-                println!("cannot found file or dirctory: {}", path)
-            }
-            CommandError::FileNotFound(path) => {
-                println!("cannot found file: {}", path)
-            }
-            CommandError::DirectoryNotFound(path) => {
-                println!("cannot found dirctory: {}", path)
-            }
-            CommandError::NotDirectory(path) => {
-                println!("path is not a dirctory: {}", path)
-            }
-            CommandError::NotFile(path) => {
-                println!("path is not a file: {}", path)
-            }
-            CommandError::UnclosedQuotation(index) => {
-                println!("command exists unclosed quotation at index: {}", index)
-            }
-            CommandError::UnableGetArg => {
-                println!("unable to get argument")
-            }
-            CommandError::EmptyCommand => println!("try to construct an empty command"),
-        }
-    }
-}
-
-impl Command {
-    fn new(name: String, args: Vec<String>, run_backend: bool) -> Result<Command, CommandError> {
-        for BuildInCmd(cmd) in BuildInCmd::BUILD_IN_CMD {
-            if name == *cmd {
-                return Ok(Command {
-                    args,
-                    cmd_type: CommandType::InternalCommand(BuildInCmd(cmd)),
-                    run_backend,
-                });
-            }
-        }
-
-        return Ok(Command {
-            args,
-            cmd_type: CommandType::ExternalCommand(name),
-            run_backend,
-        });
-    }
-
-    pub fn parse(str: String) -> Result<Vec<Command>, CommandError> {
-        let iter = str.chars();
-        let mut fragments: Vec<String> = Vec::new();
-        let mut stack: String = String::with_capacity(str.len());
-        let mut left_quote: char = ' ';
-        let mut left_quote_index: usize = 0;
-        let mut commands: Vec<Command> = Vec::new();
-        for (index, ch) in iter.enumerate() {
-            //存在未闭合的左引号，此时除能够配对的引号外，任何字符都加入栈中
-            if left_quote != ' ' {
-                if ch == left_quote {
-                    left_quote = ' ';
-                } else {
-                    stack.push(ch);
-                }
-            } else {
-                //不存在未闭合的左引号
-                if ch == '\'' || ch == '\"' {
-                    //字符为引号，记录下来
-                    left_quote = ch;
-                    left_quote_index = index;
-                } else if ch == ' ' && !stack.is_empty() {
-                    //字符为空格且栈中不为空，该空格视作命令段之间的分割线
-                    //将栈中字符作为一个命令段加入集合，之后重置栈
-                    fragments.push(stack.to_string());
-                    stack.clear();
-                } else if ch == ';' || ch == '&' {
-                    // ;和&视作命令之间的分隔，且&标志命令后台运行
-                    // 使用命令段构造一条命令
-                    if !stack.is_empty() {
-                        fragments.push(stack.to_string());
-                        stack.clear();
-                    }
-                    if !fragments.is_empty() {
-                        match Self::build_command_from_fragments(&fragments, ch == '&') {
-                            Ok(command) => commands.push(command),
-                            Err(e) => return Err(e),
-                        }
-                    }
-
-                    fragments.clear();
-                } else {
-                    //其他字符都作为普通字符加入栈中
-                    stack.push(ch);
-                }
-            }
-        }
-        //结束时如果栈不为空
-        if !stack.is_empty() {
-            if left_quote == ' ' {
-                //不存在未闭合的引号，将栈中剩余内容作为命令段加入集合，并构造命令
-                fragments.push(stack.to_string());
-                match Self::build_command_from_fragments(&fragments, false) {
-                    Ok(command) => commands.push(command),
-                    Err(e) => return Err(e),
-                }
-            } else {
-                //存在未闭合的引号，返回此引号的下标
-                return Err(CommandError::UnclosedQuotation(left_quote_index));
-            }
-        }
-        Ok(commands)
-    }
-
-    fn build_command_from_fragments(
-        fragments: &Vec<String>,
-        run_backend: bool,
-    ) -> Result<Command, CommandError> {
-        if fragments.len() == 0 {
-            return Err(CommandError::EmptyCommand);
-        }
+type CommandMap = HashMap<String, fn(&Vec<String>) -> Result<(), ExecuteErrorType>>;
 
-        let mut iter = fragments.into_iter();
-
-        let name = iter.next().unwrap();
-        let re: Regex = Regex::new(r"\$[\w_]+").unwrap();
-        let replacement = |caps: &Captures| -> String {
-            match Env::get(&String::from(&caps[0][1..])) {
-                Some(entry) => entry.origin().clone(),
-                None => String::from(&caps[0]),
-            }
-        };
-        let mut args: Vec<String> = Vec::new();
-        for arg in iter.collect::<Vec<&String>>().iter() {
-            let arg = re.replace_all(arg.as_str(), &replacement).to_string();
-            match re.captures(arg.as_str()) {
-                Some(caps) => {
-                    return Err(CommandError::EnvironmentVariableNotFound(String::from(
-                        caps.get(0).unwrap().as_str(),
-                    )))
-                }
-                None => args.push(arg),
-            }
-        }
-        Command::new(name.clone(), args, run_backend)
-    }
-}
-
-#[derive(Debug, PartialEq, Eq, Clone)]
-pub struct BuildInCmd(pub &'static str);
+static mut BUILD_IN_CMD: Option<Arc<Mutex<CommandMap>>> = None;
+#[derive(Debug)]
+pub struct BuildInCmd;
 
 impl BuildInCmd {
-    pub const BUILD_IN_CMD: &'static [BuildInCmd] = &[
-        BuildInCmd("cd"),
-        BuildInCmd("exec"),
-        BuildInCmd("reboot"),
-        BuildInCmd("free"),
-        BuildInCmd("help"),
-        BuildInCmd("export"),
-        BuildInCmd("compgen"),
-        BuildInCmd("complete"),
-    ];
-}
-
-impl Shell {
-    pub fn exec_internal_command(
-        &mut self,
-        cmd: &str,
-        args: &Vec<String>,
-    ) -> Result<(), CommandError> {
-        match cmd {
-            "cd" => self.shell_cmd_cd(args),
-            "exec" => self.shell_cmd_exec(args),
-            "reboot" => self.shell_cmd_reboot(args),
-            "free" => self.shell_cmd_free(args),
-            "help" => self.shell_cmd_help(args),
-            "export" => self.shell_cmd_export(args),
-            "compgen" => self.shell_cmd_compgen(args),
-            "complete" => self.shell_cmd_complete(args),
-
-            _ => Err(CommandError::CommandNotFound(String::from(cmd))),
-        }
-    }
-
-    pub fn exec_external_command(&mut self, path: String, args: &Vec<String>) {
-        let mut full_args = args.clone();
-        full_args.insert(0, path.clone());
-        self.shell_cmd_exec(&full_args).unwrap_or_else(|e| {
-            let err = match e {
-                CommandError::FileNotFound(rp) => CommandError::CommandNotFound(rp),
-                _ => e,
-            };
-            CommandError::handle(err);
-        })
-    }
-
-    pub fn exec_command(&mut self, mut command: Command) {
-        if command.run_backend {
-            command.args.push("&".to_string());
-        }
-
-        match &command.cmd_type {
-            CommandType::ExternalCommand(path) => {
-                self.exec_external_command(path.to_string(), &command.args);
-            }
+    // pub const BUILD_IN_CMD: &'static [BuildInCmd] = &[
+    // BuildInCmd("cd"),
+    // BuildInCmd("exec"),
+    // BuildInCmd("reboot"),
+    // BuildInCmd("free"),
+    // BuildInCmd("help"),
+    // BuildInCmd("export"),
+    // BuildInCmd("compgen"),
+    // BuildInCmd("complete"),
+    // ];
+
+    pub fn map() -> Option<Arc<Mutex<CommandMap>>> {
+        unsafe { BUILD_IN_CMD.clone() }
+    }
+
+    pub unsafe fn init() {
+        BUILD_IN_CMD = Some(Arc::new(Mutex::new(CommandMap::new())));
+        let mut map = BUILD_IN_CMD.as_ref().unwrap().lock().unwrap();
+        let mut insert = |tuple: (String, fn(&Vec<String>) -> Result<(), ExecuteErrorType>)| {
+            map.insert(tuple.0, tuple.1)
+        };
 
-            CommandType::InternalCommand(BuildInCmd(cmd)) => {
-                match self.exec_internal_command(cmd, &command.args) {
-                    Ok(_) => {}
-                    Err(e) => CommandError::handle(e),
-                }
-                if command.args.contains(&String::from("--help")) {
-                    Help::shell_help(cmd);
-                }
-            }
-        }
+        insert(build!("cd", Self::shell_cmd_cd));
+        insert(build!("exec", Self::shell_cmd_exec));
+        insert(build!("reboot", Self::shell_cmd_reboot));
+        insert(build!("help", Self::shell_cmd_help));
+        insert(build!("free", Self::shell_cmd_free));
+        insert(build!("export", Self::shell_cmd_export));
     }
 
-    fn shell_cmd_cd(&mut self, args: &Vec<String>) -> Result<(), CommandError> {
+    pub fn shell_cmd_cd(args: &Vec<String>) -> Result<(), ExecuteErrorType> {
         let path = match args.len() {
             0 => String::from(ROOT_PATH),
-            1 => self.is_dir(args.get(0).unwrap())?,
-            _ => return Err(CommandError::WrongArgumentCount(args.len())),
+            1 => match std::fs::canonicalize(args.get(0).unwrap()) {
+                Ok(path) => {
+                    if !path.is_dir() {
+                        return Err(ExecuteErrorType::NotDir(path.to_str().unwrap().to_string()));
+                    }
+                    path.to_str().unwrap().to_string()
+                }
+                Err(_) => return Err(ExecuteErrorType::FileNotFound(args.get(0).unwrap().clone())),
+            },
+            _ => return Err(ExecuteErrorType::TooManyArguments),
         };
-        self.chdir(&path);
+        if let Err(_) = std::env::set_current_dir(&path) {
+            return Err(ExecuteErrorType::ExecuteFailed);
+        }
         Ok(())
     }
 
-    pub fn shell_cmd_exec(&mut self, args: &Vec<String>) -> Result<(), CommandError> {
-        if args.len() <= 0 {
-            return Err(CommandError::WrongArgumentCount(args.len()));
-        }
-
-        let path = args.get(0).unwrap();
-        let real_path = match Env::search_path_from_env(path) {
-            Some(str) => str,
-            None => return Err(CommandError::FileNotFound(path.clone())),
-        };
-
-        // 如果文件不存在，返回错误
-        if !Path::new(&real_path).is_file() {
-            // println!("{}: command not found", real_path);
-            return Err(CommandError::NotFile(real_path.clone()));
-        }
-
-        let mut args = args.split_first().unwrap().1;
-        let run_backend = if let Some(last) = args.last() {
-            if last == "&" {
-                args = &args[..args.len() - 1];
-                true
+    pub fn shell_cmd_exec(args: &Vec<String>) -> Result<(), ExecuteErrorType> {
+        if let Some((name, args)) = args.split_first() {
+            let real_path = if name.contains('/') {
+                // 为路径，获取规范的绝对路径
+                if let Ok(path) = std::fs::canonicalize(name) {
+                    if path.is_file() {
+                        Ok(path)
+                    } else {
+                        // 路径不为文件，返回错误
+                        Err(ExecuteErrorType::NotFile(name.clone()))
+                    }
+                } else {
+                    Err(ExecuteErrorType::CommandNotFound)
+                }
             } else {
-                false
-            }
-        } else {
-            false
-        };
-
-        crossterm::terminal::disable_raw_mode().expect("failed to disable raw mode");
-
-        let mut child = std::process::Command::new(real_path)
-            .args(args)
-            .current_dir(Env::current_dir())
-            .envs(Env::get_all())
-            .spawn()
-            .expect("Failed to execute command");
-
-        if !run_backend {
-            unsafe {
-                libc::tcsetpgrp(libc::STDIN_FILENO, child.id() as i32);
-                let _ = child.wait();
-                libc::tcsetpgrp(libc::STDIN_FILENO, std::process::id() as i32);
+                // 不为路径，从环境变量中查找命令
+                which::which(name).map_err(|_| ExecuteErrorType::CommandNotFound)
+            }?;
+
+            let mut err: Option<ExecuteErrorType> = None;
+
+            match std::process::Command::new(real_path)
+                .args(args)
+                .current_dir(EnvManager::current_dir())
+                .spawn()
+            {
+                Ok(mut child) => match child.wait() {
+                    Ok(exit_status) => match exit_status.code() {
+                        Some(exit_code) => {
+                            if exit_code != 0 {
+                                err = Some(ExecuteErrorType::ExitWithCode(exit_code));
+                            }
+                        }
+                        None => err = Some(ExecuteErrorType::ProcessTerminated),
+                    },
+                    Err(_) => err = Some(ExecuteErrorType::ExecuteFailed),
+                },
+                Err(_) => todo!(),
+            };
+            return if let Some(err) = err {
+                Err(err)
+            } else {
+                Ok(())
             };
         } else {
-            self.add_backend_task(child);
+            return Err(ExecuteErrorType::TooFewArguments);
         }
-
-        crossterm::terminal::enable_raw_mode().expect("failed to enable raw mode");
-        return Ok(());
     }
 
-    fn shell_cmd_reboot(&self, args: &Vec<String>) -> Result<(), CommandError> {
+    fn shell_cmd_reboot(args: &Vec<String>) -> Result<(), ExecuteErrorType> {
         if args.len() == 0 {
             unsafe { libc::syscall(libc::SYS_reboot, 0, 0, 0, 0, 0, 0) };
             return Ok(());
         } else {
-            return Err(CommandError::WrongArgumentCount(args.len()));
+            return Err(ExecuteErrorType::TooManyArguments);
         }
     }
 
-    fn shell_cmd_free(&self, args: &Vec<String>) -> Result<(), CommandError> {
+    fn shell_cmd_free(args: &Vec<String>) -> Result<(), ExecuteErrorType> {
         if args.len() == 1 && args.get(0).unwrap() != "-m" {
-            return Err(CommandError::InvalidArgument(
+            return Err(ExecuteErrorType::InvalidArgument(
                 args.get(0).unwrap().to_string(),
             ));
         }
@@ -404,88 +199,29 @@ impl Shell {
         Ok(())
     }
 
-    fn shell_cmd_help(&self, args: &Vec<String>) -> Result<(), CommandError> {
+    fn shell_cmd_help(args: &Vec<String>) -> Result<(), ExecuteErrorType> {
         if args.len() == 0 {
-            for BuildInCmd(cmd) in BuildInCmd::BUILD_IN_CMD {
-                Help::shell_help(cmd)
-            }
+            unsafe { Helper::help() };
             return Ok(());
         }
-        return Err(CommandError::WrongArgumentCount(args.len()));
+        return Err(ExecuteErrorType::TooManyArguments);
     }
 
-    fn shell_cmd_export(&self, args: &Vec<String>) -> Result<(), CommandError> {
+    fn shell_cmd_export(args: &Vec<String>) -> Result<(), ExecuteErrorType> {
         if args.len() == 1 {
             let pair = args.get(0).unwrap().split('=').collect::<Vec<&str>>();
 
             if pair.len() == 2 && !pair.contains(&"") {
                 let name = pair.get(0).unwrap().to_string();
                 let value = pair.get(1).unwrap().to_string();
-                Env::insert(name, value);
+                std::env::set_var(name, value);
                 return Ok(());
             } else {
-                return Err(CommandError::InvalidArgument(args.get(0).unwrap().clone()));
+                return Err(ExecuteErrorType::InvalidArgument(
+                    args.get(0).unwrap().clone(),
+                ));
             }
         }
-        return Err(CommandError::WrongArgumentCount(args.len()));
-    }
-
-    fn shell_cmd_compgen(&self, _args: &Vec<String>) -> Result<(), CommandError> {
-        //TODO
-        Ok(())
-    }
-
-    fn shell_cmd_complete(&self, _args: &Vec<String>) -> Result<(), CommandError> {
-        //TODO
-        Ok(())
-    }
-
-    fn path_format(&self, path: &String) -> Result<String, CommandError> {
-        let mut abs_path = path.clone();
-        if !path.starts_with('/') {
-            abs_path = format!("{}/{}", Env::current_dir(), path);
-        }
-        let path = Path::new(&abs_path).clean();
-        let mut fmt_path = path.to_str().unwrap().to_string();
-        let replacement = |_caps: &regex::Captures| -> String { String::from("/") };
-        let re = regex::Regex::new(r"\/{2,}").unwrap();
-        fmt_path = re.replace_all(fmt_path.as_str(), replacement).to_string();
-        return Ok(fmt_path);
-    }
-
-    #[allow(dead_code)]
-    fn is_file(&self, path_str: &String) -> Result<String, CommandError> {
-        match self.path_format(path_str) {
-            Ok(path_str) => {
-                let path = Path::new(&path_str);
-                if !path.is_file() {
-                    return Err(CommandError::NotFile(path_str.clone()));
-                };
-                Ok(path_str)
-            }
-            Err(_) => Err(CommandError::FileNotFound(path_str.clone())),
-        }
-    }
-
-    #[allow(dead_code)]
-    fn is_dir(&self, path_str: &String) -> Result<String, CommandError> {
-        match self.path_format(path_str) {
-            Ok(path_str) => {
-                let path = Path::new(&path_str);
-                if !path.is_dir() {
-                    return Err(CommandError::NotDirectory(path_str.clone()));
-                };
-                Ok(path_str)
-            }
-            Err(_) => Err(CommandError::DirectoryNotFound(path_str.clone())),
-        }
-    }
-
-    #[allow(dead_code)]
-    fn is_file_or_dir(&self, path_str: &String) -> Result<String, CommandError> {
-        match self.path_format(path_str) {
-            Ok(path_str) => Ok(path_str),
-            Err(_) => Err(CommandError::PathNotFound(path_str.clone())),
-        }
+        return Err(ExecuteErrorType::TooManyArguments);
     }
 }

src/shell/mod.rs

@@ -1,23 +1,27 @@
 use std::{
     cell::RefCell,
-    collections::HashMap,
     fs::{self, File, OpenOptions},
     io::{BufRead, BufReader, Read, Write},
     ops::Deref,
-    path::Path,
     print,
     process::Child,
     rc::Rc,
 };
 
-use crate::keycode::{FunctionKeySuffix, SpecialKeycode};
+use crate::{
+    keycode::{FunctionKeySuffix, SpecialKeycode},
+    parser::{Parser, Pipeline},
+};
 
 use colored::Colorize;
-use command::{BuildInCmd, Command, CommandError};
+use command::BuildInCmd;
 use printer::Printer;
+use thread_manager::ThreadManager;
 
 mod printer;
 
+mod thread_manager;
+
 pub mod command;
 
 const DEFAULT_HISTORY_COMMANDS_PATH: &str = "/history_commands.txt";
@@ -27,28 +31,39 @@ pub struct Shell {
     history_commands: Vec<Rc<RefCell<Vec<u8>>>>,
     history_path: String,
     printer: Printer,
-    backend_task: HashMap<usize, Child>,
-    window_size: Option<WindowSize>,
+    backend_thread: ThreadManager<Pipeline, Child>,
 }
 
 impl Shell {
     pub fn new() -> Shell {
+        if BuildInCmd::map().is_none() {
+            unsafe { BuildInCmd::init() };
+        }
+
         let mut shell = Shell {
             history_commands: Vec::new(),
             history_path: DEFAULT_HISTORY_COMMANDS_PATH.to_string(),
             printer: Printer::new(&Rc::new(RefCell::new(Vec::new()))),
-            backend_task: HashMap::new(),
-            window_size: WindowSize::new(),
+            backend_thread: Self::create_backend_thread(),
         };
         shell.read_commands();
         shell
     }
 
-    pub fn chdir(&mut self, new_dir: &String) {
-        let path = Path::new(&new_dir);
-        if let Err(e) = std::env::set_current_dir(&path) {
-            eprintln!("Error changing directory: {}", e);
-        }
+    fn create_backend_thread() -> ThreadManager<Pipeline, Child> {
+        ThreadManager::new(|| {
+            let (p_s, c_r) = std::sync::mpsc::channel::<Pipeline>();
+            let (c_s, p_r) = std::sync::mpsc::channel::<Child>();
+            let map = BuildInCmd::map();
+            let func = move || loop {
+                if let Ok(pipeline) = c_r.recv() {
+                    for child in pipeline.execute(map.clone()) {
+                        let _ = c_s.send(child);
+                    }
+                };
+            };
+            (p_s, p_r, func)
+        })
     }
 
     pub fn exec(&mut self) {
@@ -89,17 +104,44 @@ impl Shell {
             if !command_bytes.iter().all(|&byte| byte == b' ') {
                 self.exec_commands_in_line(&command_bytes);
             }
-            self.detect_task_done();
         }
     }
 
     fn exec_commands_in_line(&mut self, command_bytes: &Vec<u8>) {
-        match Command::parse(String::from_utf8(command_bytes.clone()).unwrap()) {
-            Ok(commands) => commands
-                .into_iter()
-                .for_each(|command| self.exec_command(command)),
-            Err(e) => CommandError::handle(e),
+        // match Command::parse(String::from_utf8(command_bytes.clone()).unwrap()) {
+        //     Ok(commands) => commands
+        //         .into_iter()
+        //         .for_each(|command| self.exec_command(command)),
+        //     Err(e) => CommandError::handle(e),
+        // }
+
+        // 解析命令
+        let input_command = String::from_utf8(command_bytes.clone()).unwrap();
+        let pipelines = Parser::parse(&input_command).unwrap();
+
+        let mut foreground_pipelines = Vec::new();
+
+        // 后台pipeline发送给子线程执行
+        for pipeline in pipelines {
+            if pipeline.backend() {
+                let _ = self.backend_thread.send(pipeline);
+            } else {
+                foreground_pipelines.push(pipeline);
+            }
+        }
+
+        crossterm::terminal::disable_raw_mode().expect("failed to disable raw mode");
+
+        // 顺序执行所有前台pipeline
+        for pipeline in &foreground_pipelines {
+            for mut child in pipeline.execute(BuildInCmd::map().clone()) {
+                let _ = child.wait();
+            }
         }
+
+        crossterm::terminal::enable_raw_mode().expect("failed to enable raw mode");
+
+        foreground_pipelines.clear();
     }
 
     pub fn read_commands(&mut self) {
@@ -318,27 +360,6 @@ impl Shell {
             stdout.flush().unwrap();
         }
     }
-
-    fn add_backend_task(&mut self, child: Child) {
-        let mut job_id = 1;
-        while self.backend_task.contains_key(&job_id) {
-            job_id += 1;
-        }
-
-        println!("[{}] {}", job_id, child.id());
-        self.backend_task.insert(job_id, child);
-    }
-
-    fn detect_task_done(&mut self) {
-        self.backend_task.retain(|job_id, task| {
-            if let Ok(Some(status)) = task.try_wait() {
-                println!("[{}] done with status: {}", job_id, status);
-                false
-            } else {
-                true
-            }
-        })
-    }
 }
 
 #[allow(dead_code)]
@@ -347,6 +368,7 @@ struct WindowSize {
     col: usize,
 }
 
+#[allow(dead_code)]
 impl WindowSize {
     pub fn new() -> Option<Self> {
         let mut ws: libc::winsize = unsafe { std::mem::zeroed() };
@@ -370,9 +392,9 @@ impl WindowSize {
 
 pub fn complete_command(command: &str) -> (&str, Vec<String>) {
     let mut candidates: Vec<String> = Vec::new();
-    for BuildInCmd(cmd) in BuildInCmd::BUILD_IN_CMD {
+    for (cmd, _) in BuildInCmd::map().as_ref().unwrap().lock().unwrap().iter() {
         if cmd.starts_with(command) {
-            candidates.push(String::from(*cmd));
+            candidates.push(String::from(cmd));
         }
     }
     ("", candidates)

src/shell/thread_manager.rs

@@ -0,0 +1,58 @@
+use std::{
+    sync::mpsc::{Receiver, RecvError, SendError, Sender},
+    thread::{self, JoinHandle, ThreadId},
+};
+
+pub struct ThreadManager<S, R> {
+    handle: Option<JoinHandle<()>>,
+    sender: Sender<S>,
+    receiver: Receiver<R>,
+}
+
+impl<S, R> ThreadManager<S, R> {
+    pub fn new<F>(f: impl FnOnce() -> (Sender<S>, Receiver<R>, F)) -> ThreadManager<S, R>
+    where
+        F: FnOnce() -> (),
+        F: Send + 'static,
+    {
+        let (s, r, func) = f();
+        let handle = thread::spawn(func);
+
+        Self {
+            handle: Some(handle),
+            sender: s,
+            receiver: r,
+        }
+    }
+
+    pub fn send(&self, item: S) -> Result<(), SendError<S>> {
+        self.sender.send(item)
+    }
+
+    pub fn receiver(&self) -> Result<R, RecvError> {
+        self.receiver.recv()
+    }
+
+    pub fn id(&self) -> Option<ThreadId> {
+        Some(self.handle.as_ref()?.thread().id())
+    }
+
+    pub fn name(&self) -> Option<&str> {
+        self.handle.as_ref()?.thread().name()
+    }
+
+    pub fn join(&mut self) -> Result<(), ()> {
+        if self.handle.is_none() {
+            return Ok(());
+        }
+        self.handle.take().unwrap().join().map_err(|_| ())
+    }
+
+    pub fn is_finished(&mut self) -> bool {
+        if let Some(ref handle) = self.handle {
+            handle.is_finished()
+        } else {
+            true
+        }
+    }
+}