添加功能，优化部分代码，修复已知错误 (#42)

* 代码格式化

* 修复未输入内容时按下tab键会重复打印提示信息的错误

* 完善环境变量模块

* 使用Command重写exec方法

* 实现外部程序的后台运行

* 修复参数读取问题

* 优化代码

* 修改Makefile

* 添加make check

* 添加rust-toolchain

* 还原makefile、toolchain

* 修改工具链版本为nightly-2024-07-23

* 修复exec时未关闭raw模式的问题

Cargo.toml

@@ -8,7 +8,6 @@ authors = [ "MemoryShore <1353318529@qq.com>" ]
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-lazy_static = "1.4.0"
 regex = "1.10.2"
 libc = "0.2"
 num-traits = "0.2"

rust-toolchain.toml

@@ -1,4 +1,4 @@
 [toolchain]
-channel = "nightly-2023-08-15"
+channel = "nightly-2024-07-23"
 components = ["rust-src", "rustfmt"]
 targets = [ "x86_64-unknown-linux-musl" ]

src/env.rs

@@ -1,22 +1,106 @@
 use std::{
     collections::HashMap,
+    fmt,
     fs::File,
     io::{Read, Write},
+    ops::{Deref, DerefMut},
     path::Path,
-    string::String,
-    vec::Vec,
 };
 
 pub const ROOT_PATH: &str = "/";
 pub const ENV_FILE_PATH: &str = "/etc/profile";
 
-pub struct Env(std::collections::HashMap<String, String>);
+#[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,
+        })
+    }
 
-lazy_static! {
-    static ref ENV: std::sync::Mutex<Env> = std::sync::Mutex::new(Env(HashMap::new()));
+    #[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
+    }
+}
+
+impl DerefMut for Env {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
 }
 
 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();
@@ -28,52 +112,89 @@ impl Env {
     /// 读取环境变量文件
     /// 如果文件不存在则创建
     pub fn read_env() {
-        let mut env = ENV.lock().unwrap();
+        let env = unsafe { ENV.as_mut().unwrap() };
+
         if !Path::new(ENV_FILE_PATH).exists() {
             Env::init_envfile();
         }
         let mut file = File::open(ENV_FILE_PATH).unwrap();
         let mut buf: Vec<u8> = Vec::new();
         file.read_to_end(&mut buf).unwrap();
-        for (name, value) in String::from_utf8(buf)
-            .unwrap()
-            .split('\n')
-            .filter_map(|str| {
-                let v = str.split('=').collect::<Vec<&str>>();
-                if v.len() == 2 && !v.contains(&"") {
-                    Some((*v.get(0).unwrap(), *v.get(1).unwrap()))
-                } else {
-                    None
-                }
-            })
-            .collect::<Vec<(&str, &str)>>()
-        {
-            env.0.insert(String::from(name), String::from(value));
+
+        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);
+            }
         }
     }
 
-    pub fn get(key: &String) -> Option<String> {
-        let env = &mut ENV.lock().unwrap().0;
-        env.get(key).map(|value| value.clone())
+    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) {
-        ENV.lock().unwrap().0.insert(key, value);
+        if let Some(entry) = EnvEntry::new(value) {
+            Self::env().insert(key, entry);
+        }
     }
 
+    /// 获取PATH环境变量的值（已分割）
     pub fn path() -> Vec<String> {
-        let env = &ENV.lock().unwrap().0;
-        let paths = env.get("PATH").unwrap();
-        paths
-            .split(':')
-            .filter_map(|str| {
-                let path = String::from(str);
-                if Path::new(&path).is_dir() {
-                    Some(path)
-                } else {
-                    None
+        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")
+            .to_str()
+            .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;
                 }
-            })
-            .collect::<Vec<String>>()
+            }
+            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

@@ -1,11 +1,7 @@
 #![allow(non_snake_case)]
-#![feature(core_intrinsics)]
 
 extern crate libc;
 
-#[macro_use]
-extern crate lazy_static;
-
 #[macro_use]
 extern crate num_derive;
 
@@ -19,7 +15,7 @@ use env::Env;
 use shell::Shell;
 
 fn main() {
-    Env::read_env();
+    Env::init();
     let mut shell = Shell::new();
     shell.exec();
     return;

src/shell/command/mod.rs

@@ -1,9 +1,7 @@
 use help::Help;
 use path_clean::PathClean;
 use regex::{Captures, Regex};
-use std::intrinsics::unlikely;
-use std::io::Read;
-use std::{format, fs::File, path::Path, print, println, string::String, vec::Vec};
+use std::{format, fs::File, io::Read, path::Path, print, println};
 
 use crate::env::{Env, ROOT_PATH};
 use crate::shell::Shell;
@@ -20,6 +18,7 @@ enum CommandType {
 pub struct Command {
     args: Vec<String>,
     cmd_type: CommandType,
+    run_backend: bool,
 }
 
 #[allow(dead_code)]
@@ -36,6 +35,7 @@ pub enum CommandError {
     NotFile(String),
     UnclosedQuotation(usize),
     UnableGetArg,
+    EmptyCommand,
 }
 
 impl CommandError {
@@ -74,17 +74,19 @@ impl CommandError {
             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>) -> Result<Command, CommandError> {
+    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,
                 });
             }
         }
@@ -92,15 +94,17 @@ impl Command {
         return Ok(Command {
             args,
             cmd_type: CommandType::ExternalCommand(name),
+            run_backend,
         });
     }
 
-    fn parse_command_into_fragments(str: String) -> Result<Vec<String>, usize> {
+    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 != ' ' {
@@ -115,13 +119,26 @@ impl Command {
                     //字符为引号，记录下来
                     left_quote = ch;
                     left_quote_index = index;
-                } else if ch == ' ' {
+                } 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);
@@ -131,33 +148,40 @@ impl Command {
         //结束时如果栈不为空
         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(left_quote_index);
+                return Err(CommandError::UnclosedQuotation(left_quote_index));
             }
         }
-        Ok(fragments)
+        Ok(commands)
     }
 
-    fn from_string(str: String) -> Result<Command, CommandError> {
-        let iter = Self::parse_command_into_fragments(str);
-        if let Err(index) = iter {
-            return Err(CommandError::UnclosedQuotation(index));
+    fn build_command_from_fragments(
+        fragments: &Vec<String>,
+        run_backend: bool,
+    ) -> Result<Command, CommandError> {
+        if fragments.len() == 0 {
+            return Err(CommandError::EmptyCommand);
         }
-        let mut iter = iter.unwrap().into_iter();
+
+        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(value) => value,
+                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() {
+        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) => {
@@ -168,27 +192,7 @@ impl Command {
                 None => args.push(arg),
             }
         }
-        let cmd = Command::new(name, args);
-        return cmd;
-    }
-
-    pub fn from_strings(str: String) -> Vec<Command> {
-        let mut commands = Vec::new();
-        let segments: Vec<&str> = str.split(';').collect();
-        for segment in segments {
-            if segment.trim().is_empty() {
-                continue;
-            } else {
-                match Command::from_string(String::from(segment)) {
-                    Ok(s) => commands.push(s),
-                    Err(e) => {
-                        CommandError::handle(e);
-                    }
-                }
-            }
-        }
-
-        commands
+        Command::new(name.clone(), args, run_backend)
     }
 }
 
@@ -196,7 +200,7 @@ impl Command {
 pub struct BuildInCmd(pub &'static str);
 
 impl BuildInCmd {
-    pub const BUILD_IN_CMD: &[BuildInCmd] = &[
+    pub const BUILD_IN_CMD: &'static [BuildInCmd] = &[
         BuildInCmd("cd"),
         BuildInCmd("exec"),
         BuildInCmd("reboot"),
@@ -240,7 +244,11 @@ impl Shell {
         })
     }
 
-    pub fn exec_command(&mut self, command: &Command) {
+    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);
@@ -268,73 +276,51 @@ impl Shell {
         Ok(())
     }
 
-    pub fn shell_cmd_exec(&self, args: &Vec<String>) -> Result<(), CommandError> {
-        if unlikely(args.len() <= 0) {
+    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();
-        //在环境变量中搜索
-        //TODO: 放在一个函数里来实现
-        let mut real_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() {
-                    real_path = possible_path;
-                    break;
-                }
-            }
-            if real_path.is_empty() {
-                return Err(CommandError::FileNotFound(path.clone()));
-            }
-        } else {
-            match self.is_file(path) {
-                Ok(path) => real_path = path,
-                Err(e) => return Err(e),
-            }
-        }
+        let real_path = match Env::search_path_from_env(path) {
+            Some(str) => str,
+            None => return Err(CommandError::FileNotFound(path.clone())),
+        };
 
-        let mut args = args.clone();
         // 如果文件不存在，返回错误
         if !Path::new(&real_path).is_file() {
             // println!("{}: command not found", real_path);
-            return Err(CommandError::FileNotFound(real_path.clone()));
+            return Err(CommandError::NotFile(real_path.clone()));
         }
 
-        let pid: libc::pid_t = unsafe {
-            libc::syscall(libc::SYS_fork, 0, 0, 0, 0, 0, 0)
-                .try_into()
-                .unwrap()
+        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
+            } else {
+                false
+            }
+        } else {
+            false
         };
 
-        let name = &real_path[real_path.rfind('/').map(|pos| pos + 1).unwrap_or(0)..];
-        *args.get_mut(0).unwrap() = name.to_string();
-        let mut retval = 0;
-        if pid == 0 {
-            let path_cstr = std::ffi::CString::new(real_path).unwrap();
-            let args_cstr = args
-                .iter()
-                .map(|str| std::ffi::CString::new(str.as_str()).unwrap())
-                .collect::<Vec<std::ffi::CString>>();
-            let mut args_ptr = args_cstr
-                .iter()
-                .map(|c_str| c_str.as_ptr())
-                .collect::<Vec<*const i8>>();
-            args_ptr.push(std::ptr::null());
-            let argv = args_ptr.as_ptr();
-
-            unsafe {
-                libc::execv(path_cstr.as_ptr(), argv);
-            }
+        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 {
+            let _ = child.wait();
         } else {
-            if args.last().unwrap() != &"&" {
-                unsafe { libc::waitpid(pid, &mut retval as *mut i32, 0) };
-            } else {
-                println!("[1] {}", pid);
-            }
+            self.add_backend_task(child);
         }
+
+        crossterm::terminal::enable_raw_mode().expect("failed to enable raw mode");
         return Ok(());
     }
 
@@ -453,7 +439,7 @@ impl Shell {
     fn path_format(&self, path: &String) -> Result<String, CommandError> {
         let mut abs_path = path.clone();
         if !path.starts_with('/') {
-            abs_path = format!("{}/{}", Self::current_dir(), path);
+            abs_path = format!("{}/{}", Env::current_dir(), path);
         }
         let path = Path::new(&abs_path).clean();
         let mut fmt_path = path.to_str().unwrap().to_string();
@@ -463,6 +449,7 @@ impl Shell {
         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) => {
@@ -476,6 +463,7 @@ impl Shell {
         }
     }
 
+    #[allow(dead_code)]
     fn is_dir(&self, path_str: &String) -> Result<String, CommandError> {
         match self.path_format(path_str) {
             Ok(path_str) => {

src/shell/mod.rs

@@ -1,20 +1,20 @@
-use core::fmt;
 use std::{
     cell::RefCell,
+    collections::HashMap,
+    fmt,
     fs::{self, File, OpenOptions},
     io::{self, stdout, BufRead, BufReader, Read, Write},
     ops::Deref,
     path::Path,
     print,
+    process::Child,
     rc::Rc,
-    string::String,
-    vec::Vec,
 };
 
 use crate::keycode::{FunctionKeySuffix, SpecialKeycode};
 
 use colored::Colorize;
-use command::{BuildInCmd, Command};
+use command::{BuildInCmd, Command, CommandError};
 
 pub mod command;
 
@@ -55,6 +55,7 @@ pub struct Shell {
     history_commands: Vec<Rc<RefCell<Vec<u8>>>>,
     history_path: String,
     printer: Printer,
+    backend_task: HashMap<usize, Child>,
 }
 
 impl Shell {
@@ -63,19 +64,12 @@ impl 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(),
         };
         shell.read_commands();
         shell
     }
 
-    pub fn current_dir() -> String {
-        std::env::current_dir()
-            .expect("Error getting current directory")
-            .to_str()
-            .unwrap()
-            .to_string()
-    }
-
     pub fn chdir(&mut self, new_dir: &String) {
         let path = Path::new(&new_dir);
         if let Err(e) = std::env::set_current_dir(&path) {
@@ -84,14 +78,21 @@ impl Shell {
     }
 
     pub fn exec(&mut self) {
+        // 开启终端raw模式
         crossterm::terminal::enable_raw_mode().expect("failed to enable raw mode");
+
+        // 循环读取一行
         loop {
             self.printer.init_before_readline();
+            // 读取一行
             if self.readline() == 0 {
                 println!();
                 break;
             }
+
             let command_bytes = self.printer.buf.borrow().clone();
+
+            // 如果命令不以空格开头且不跟上一条命令相同，这条命令会被记录
             if !command_bytes.is_empty()
                 && !command_bytes.starts_with(&[b' '])
                 && command_bytes
@@ -106,17 +107,22 @@ impl Shell {
                     .push(Rc::new(RefCell::new(command_bytes.clone())));
                 self.write_commands(&command_bytes);
             };
+
+            // 命令不为空，执行命令
             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>) {
-        let commands = Command::from_strings(String::from_utf8(command_bytes.clone()).unwrap());
-        commands
-            .iter()
-            .for_each(|command| self.exec_command(command));
+        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),
+        }
     }
 
     pub fn read_commands(&mut self) {
@@ -149,8 +155,11 @@ impl Shell {
 
     fn read_char() -> u8 {
         let mut buf: [u8; 1] = [0];
-        std::io::stdin().read(&mut buf).expect("read char error");
-        buf[0]
+        loop {
+            if std::io::stdin().read(&mut buf).is_ok() {
+                return buf[0];
+            }
+        }
     }
 
     fn readline(&mut self) -> usize {
@@ -220,7 +229,7 @@ impl Shell {
                         buf.truncate(self.printer.cursor);
                         let str = String::from_utf8(buf.clone()).unwrap();
                         if buf.len() == 0 || buf.iter().all(|byte| *byte == b' ') {
-                            return 1;
+                            continue;
                         }
 
                         let iter = str.chars();
@@ -319,11 +328,35 @@ 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
+            }
+        })
+    }
 }
 
 struct Printer {
+    /// 提示语
     prompt: Prompt,
+    /// 缓存区，记录当前显示的内容
     buf: Rc<RefCell<Vec<u8>>>,
+    /// 光标位置（不包括提示语）
     cursor: usize,
 }
 
@@ -345,6 +378,7 @@ impl Printer {
         }
     }
 
+    /// 读取输入前初始化信息
     fn init_before_readline(&mut self) {
         self.buf = Rc::new(RefCell::new(Vec::new()));
         self.prompt.update_path();
@@ -358,7 +392,7 @@ impl Printer {
         stdout().flush().unwrap();
     }
 
-    //在光标处插入字符串
+    /// 在光标处插入字符串
     fn insert(&mut self, bytes: &[u8]) {
         let mut buf = self.buf.deref().borrow_mut();
         // self.delete_to_cursor(buf.len() - cursor);
@@ -371,7 +405,7 @@ impl Printer {
         stdout().flush().unwrap();
     }
 
-    //删除下标为[cursor,cursor + len)的字符，光标位置不变
+    /// 删除下标为[cursor,cursor + len)的字符，光标位置不变
     fn delete(&self, len: usize) {
         let cursor = self.cursor;
         let mut buf = self.buf.deref().borrow_mut();