Improve user experience

CHANGELOG.md

@@ -1,6 +1,7 @@
 # Changelog
 
 ## Unreleased
+- Improve user experience (#274)
 - Add process table and exit syscall (#268)
 - Improve UTF-8 support (#267)
 - Bump acpi from 4.0.0 to 4.1.0 (#265)

Cargo.toml

@@ -7,6 +7,7 @@ edition = "2018"
 license = "MIT"
 repository = "https://github.com/vinc/moros"
 readme = "README.md"
+default-run = "moros"
 
 [features]
 default = ["video", "rtl8139"]

Makefile

@@ -40,7 +40,7 @@ $(img):
 image: $(img)
 	touch src/lib.rs
 	env | grep MOROS
-	cargo bootimage --no-default-features --features $(output),$(nic) --release --bin moros
+	cargo bootimage --no-default-features --features $(output),$(nic) --release
 	dd conv=notrunc if=$(bin) of=$(img)
 
 opts = -m 32 -cpu max -nic model=$(nic) -hda $(img) -soundhw pcspk

src/main.rs

@@ -13,21 +13,32 @@ fn main(boot_info: &'static BootInfo) -> ! {
     moros::init(boot_info);
     print!("\x1b[?25h"); // Enable cursor
     loop {
-        let bootrc = "/ini/boot.sh";
-        if sys::fs::File::open(bootrc).is_some() {
-            usr::shell::main(&["shell", bootrc]);
+        if let Some(cmd) = option_env!("MOROS_CMD") {
+            let prompt = usr::shell::prompt_string(true);
+            println!("{}{}", prompt, cmd);
+            usr::shell::exec(cmd);
+            sys::acpi::shutdown();
         } else {
-            if sys::fs::is_mounted() {
-                println!("Could not find '{}'", bootrc);
-            } else {
-                println!("MFS is not mounted to '/'");
-            }
-            println!("Running console in diskless mode");
-            usr::shell::main(&["shell"]);
+            user_boot();
         }
     }
 }
 
+fn user_boot() {
+    let script = "/ini/boot.sh";
+    if sys::fs::File::open(script).is_some() {
+        usr::shell::main(&["shell", script]);
+    } else {
+        if sys::fs::is_mounted() {
+            println!("Could not find '{}'", script);
+        } else {
+            println!("MFS is not mounted to '/'");
+        }
+        println!("Running console in diskless mode");
+        usr::shell::main(&["shell"]);
+    }
+}
+
 #[panic_handler]
 fn panic(info: &PanicInfo) -> ! {
     println!("{}", info);

src/sys/fs/block.rs

@@ -11,9 +11,6 @@ pub struct Block {
     buf: [u8; super::BLOCK_SIZE],
 }
 
-// TODO: Add LinkedBlock that contains the next block address used by a data
-// block and give Block the full block size for the data of a bitmap block.
-
 // Block structure:
 // 0..4 => next block address
 // 4..512 => block data

src/sys/fs/dir.rs

@@ -39,13 +39,13 @@ impl Dir {
     }
 
     pub fn open(pathname: &str) -> Option<Self> {
-        let pathname = realpath(pathname);
-        let mut dir = Dir::root();
-
         if !super::is_mounted() {
             return None;
         }
 
+        let mut dir = Dir::root();
+        let pathname = realpath(pathname);
+
         if pathname == "/" {
             return Some(dir);
         }

src/sys/fs/super_block.rs

@@ -37,6 +37,7 @@ impl SuperBlock {
         }
     }
 
+    // NOTE: FS must be mounted
     pub fn read() -> Self {
         let block = Block::read(SUPERBLOCK_ADDR);
         let data = block.data();

src/usr/calc.rs

@@ -9,7 +9,7 @@ use alloc::vec::Vec;
 
 use nom::branch::alt;
 use nom::character::complete::{char, space0};
-use nom::number::complete::float;
+use nom::number::complete::double;
 use nom::combinator::map;
 use nom::multi::many0;
 use nom::sequence::{delimited, tuple};
@@ -21,7 +21,7 @@ use nom::IResult;
 
 #[derive(Debug, PartialEq)]
 pub enum Exp {
-    Num(f32),
+    Num(f64),
     Add(Box<Exp>, Box<Exp>),
     Sub(Box<Exp>, Box<Exp>),
     Mul(Box<Exp>, Box<Exp>),
@@ -54,7 +54,7 @@ fn parse_parens(input: &str) -> IResult<&str, Exp> {
 }
 
 fn parse_num(input: &str) -> IResult<&str, Exp> {
-    map(delimited(space0, float, space0), Exp::Num)(input)
+    map(delimited(space0, double, space0), Exp::Num)(input)
 }
 
 fn parse_exp(exp: Exp, rem: Vec<(char, Exp)>) -> Exp {
@@ -75,20 +75,20 @@ fn parse_op(tup: (char, Exp), exp1: Exp) -> Exp {
 
 // Evaluation
 
-fn eval(exp: Exp) -> f32 {
+fn eval(exp: Exp) -> f64 {
     match exp {
         Exp::Num(num) => num,
         Exp::Add(exp1, exp2) => eval(*exp1) + eval(*exp2),
         Exp::Sub(exp1, exp2) => eval(*exp1) - eval(*exp2),
         Exp::Mul(exp1, exp2) => eval(*exp1) * eval(*exp2),
         Exp::Div(exp1, exp2) => eval(*exp1) / eval(*exp2),
-        Exp::Exp(exp1, exp2) => libm::powf(eval(*exp1), eval(*exp2)),
+        Exp::Exp(exp1, exp2) => libm::pow(eval(*exp1), eval(*exp2)),
     }
 }
 
 // REPL
 
-fn parse_eval(line: &str) -> Result<f32, String> {
+fn parse_eval(line: &str) -> Result<f64, String> {
     match parse(&line) {
         Ok((line, parsed)) => {
             if line.is_empty() {
@@ -118,6 +118,10 @@ fn repl() -> usr::shell::ExitCode {
         if line == "exit" || line == "quit" {
             break;
         }
+        if line.is_empty() {
+            println!();
+            continue;
+        }
 
         match parse_eval(&line) {
             Ok(res) => {
@@ -129,10 +133,8 @@ fn repl() -> usr::shell::ExitCode {
             }
         }
 
-        if !line.is_empty() {
-            prompt.history.add(&line);
-            prompt.history.save(history_file);
-        }
+        prompt.history.add(&line);
+        prompt.history.save(history_file);
     }
     usr::shell::ExitCode::CommandSuccessful
 }

src/usr/lisp.rs

@@ -135,13 +135,13 @@ macro_rules! ensure_tonicity {
             let floats = parse_list_of_floats(args)?;
             let first = floats.first().ok_or(Err::Reason("Expected at least one number".to_string()))?;
             let rest = &floats[1..];
-            fn f (prev: &f64, xs: &[f64]) -> bool {
+            fn func(prev: &f64, xs: &[f64]) -> bool {
                 match xs.first() {
-                    Some(x) => $check_fn(*prev, *x) && f(x, &xs[1..]),
+                    Some(x) => $check_fn(*prev, *x) && func(x, &xs[1..]),
                     None => true,
                 }
             }
-            Ok(Exp::Bool(f(first, rest)))
+            Ok(Exp::Bool(func(first, rest)))
         }
     };
 }
@@ -150,32 +150,26 @@ fn default_env<'a>() -> Env<'a> {
     let mut data: BTreeMap<String, Exp> = BTreeMap::new();
     data.insert(
         "*".to_string(),
-        Exp::Func(
-            |args: &[Exp]| -> Result<Exp, Err> {
-                let res = parse_list_of_floats(args)?.iter().fold(1.0, |res, a| res * a);
-                Ok(Exp::Number(res))
-            }
-        )
+        Exp::Func(|args: &[Exp]| -> Result<Exp, Err> {
+            let res = parse_list_of_floats(args)?.iter().fold(1.0, |res, a| res * a);
+            Ok(Exp::Number(res))
+        })
     );
     data.insert(
         "+".to_string(), 
-        Exp::Func(
-            |args: &[Exp]| -> Result<Exp, Err> {
-                let res = parse_list_of_floats(args)?.iter().fold(0.0, |res, a| res + a);
-                Ok(Exp::Number(res))
-            }
-        )
+        Exp::Func(|args: &[Exp]| -> Result<Exp, Err> {
+            let res = parse_list_of_floats(args)?.iter().fold(0.0, |res, a| res + a);
+            Ok(Exp::Number(res))
+        })
     );
     data.insert(
         "-".to_string(), 
-        Exp::Func(
-            |args: &[Exp]| -> Result<Exp, Err> {
-                let floats = parse_list_of_floats(args)?;
-                let first = *floats.first().ok_or(Err::Reason("Expected at least one number".to_string()))?;
-                let sum_of_rest = floats[1..].iter().fold(0.0, |sum, a| sum + a);
-                Ok(Exp::Number(first - sum_of_rest))
-            }
-        )
+        Exp::Func(|args: &[Exp]| -> Result<Exp, Err> {
+            let floats = parse_list_of_floats(args)?;
+            let first = *floats.first().ok_or(Err::Reason("Expected at least one number".to_string()))?;
+            let sum_of_rest = floats[1..].iter().fold(0.0, |sum, a| sum + a);
+            Ok(Exp::Number(first - sum_of_rest))
+        })
     );
     data.insert(
         "=".to_string(), 
@@ -198,7 +192,7 @@ fn default_env<'a>() -> Env<'a> {
         Exp::Func(ensure_tonicity!(|a, b| approx_eq!(f64, a, b) || a < b))
     );
 
-    Env {data, outer: None}
+    Env { data, outer: None }
 }
 
 fn parse_list_of_floats(args: &[Exp]) -> Result<Vec<f64>, Err> {
@@ -236,18 +230,14 @@ fn eval_eq_args(arg_forms: &[Exp], env: &mut Env) -> Result<Exp, Err> {
     match first_eval {
         Exp::Symbol(a) => {
             match second_eval {
-                Exp::Symbol(b) => {
-                    Ok(Exp::Bool(a == b))
-                },
-                _ => Ok(Exp::Bool(false))
+                Exp::Symbol(b) => Ok(Exp::Bool(a == b)),
+                _              => Ok(Exp::Bool(false)),
             }
         },
         Exp::List(a) => {
             match second_eval {
-                Exp::List(b) => {
-                    Ok(Exp::Bool(a.is_empty() && b.is_empty()))
-                },
-                _ => Ok(Exp::Bool(false))
+                Exp::List(b) => Ok(Exp::Bool(a.is_empty() && b.is_empty())),
+                _            => Ok(Exp::Bool(false))
             }
         },
         _ => Ok(Exp::Bool(false))
@@ -457,8 +447,8 @@ fn eval(exp: &Exp, env: &mut Env) -> Result<Exp, Err> {
                 None => {
                     let first_eval = eval(first_form, env)?;
                     match first_eval {
-                        Exp::Func(f) => {
-                            f(&eval_forms(arg_forms, env)?)
+                        Exp::Func(func) => {
+                            func(&eval_forms(arg_forms, env)?)
                         },
                         Exp::Lambda(lambda) => {
                             let new_env = &mut env_for_lambda(lambda.params_exp, arg_forms, env)?;
@@ -519,22 +509,24 @@ fn repl(env: &mut Env) -> usr::shell::ExitCode {
     prompt.history.load(history_file);
     prompt.completion.set(&lisp_completer);
 
-    while let Some(exp) = prompt.input(&prompt_string) {
-        if exp == "(exit)" || exp == "(quit)" {
+    while let Some(line) = prompt.input(&prompt_string) {
+        if line == "(exit)" || line == "(quit)" {
             break;
         }
-        match parse_eval(&exp, env) {
+        if line.is_empty() {
+            println!();
+            continue;
+        }
+        match parse_eval(&line, env) {
             Ok(res) => {
                 println!("{}\n", res);
             }
             Err(e) => match e {
                 Err::Reason(msg) => println!("{}Error:{} {}\n", csi_error, csi_reset, msg),
             },
         }
-        if !exp.is_empty() {
-            prompt.history.add(&exp);
-            prompt.history.save(history_file);
-        }
+        prompt.history.add(&line);
+        prompt.history.save(history_file);
     }
     usr::shell::ExitCode::CommandSuccessful
 }