dan/rush
1
0
Fork 0
mirror of https://github.com/danbulant/rush synced 2026-07-05 03:00:51 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

better error handling

Browse source
This commit is contained in:
Daniel Bulant 2022-02-20 12:13:28 +01:00
parent e8b943a8d5
commit b43959fa79
6 changed files with 113 additions and 96 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

7
Cargo.lock generated
View file

@ -2,6 +2,12 @@
# It is not intended for manual editing. # It is not intended for manual editing.
version = 3 version = 3
[[package]]
name = "anyhow"
version = "1.0.54"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7a99269dff3bc004caa411f38845c20303f1e393ca2bd6581576fa3a7f59577d"
[[package]] [[package]]
name = "arrayvec" name = "arrayvec"
version = "0.5.2" version = "0.5.2"
@ -77,6 +83,7 @@ dependencies = [
name = "rush" name = "rush"
version = "0.1.0" version = "0.1.0"
dependencies = [ dependencies = [
"anyhow",
"filedescriptor", "filedescriptor",
"termion", "termion",
"utf8-chars", "utf8-chars",

3
Cargo.toml
View file

@ -9,4 +9,5 @@ edition = "2018"
[dependencies] [dependencies]
utf8-chars = "1.0.0" utf8-chars = "1.0.0"
termion = "1.5.6" termion = "1.5.6"
filedescriptor = "0.8.1" filedescriptor = "0.8.1"
anyhow = "1.0.54"

9
src/main.rs
View file

@ -10,7 +10,6 @@ use termion::raw::{IntoRawMode, RawTerminal};
use termion::input::TermRead; use termion::input::TermRead;
use termion::cursor::{DetectCursorPos}; use termion::cursor::{DetectCursorPos};
use termion::event::*; use termion::event::*;
// use termion::input::{MouseTerminal};
struct Term { struct Term {
input: String, input: String,
@ -80,10 +79,14 @@ fn main() {
shell.ctx.add_scope(true); shell.ctx.add_scope(true);
loop { loop {
print!("$: "); print!("$: ");
io::stdout().flush(); io::stdout().flush().unwrap();
shell.collect(); shell.collect();
shell.term.input += "\n"; shell.term.input += "\n";
parser::exec(&mut shell.term.input.as_bytes(), &mut shell.ctx); let res = parser::exec(&mut shell.term.input.as_bytes(), &mut shell.ctx);
match res {
Err(err) => eprintln!("rush: {}", err),
Ok(_) => {}
}
} }
} }

182
src/parser/ast.rs
View file

@ -1,4 +1,5 @@
use crate::parser::tokens::Tokens; use crate::parser::tokens::Tokens;
use anyhow::{bail, Result};
#[derive(Debug)] #[derive(Debug)]
pub struct LetExpression { pub struct LetExpression {
@ -115,7 +116,7 @@ struct Tree {
} }
impl Tree { impl Tree {
fn parse_call(&mut self, end: usize) -> Expression { fn parse_call(&mut self, end: usize) -> Result<Expression> {
let mut values: Vec<CommandValue> = Vec::new(); let mut values: Vec<CommandValue> = Vec::new();
let mut buf: Vec<Value> = Vec::new(); let mut buf: Vec<Value> = Vec::new();
let mut token = self.get_current_token(); let mut token = self.get_current_token();
@ -133,11 +134,14 @@ impl Tree {
let val = match &token { let val = match &token {
Tokens::Literal(str) => Value::Literal(str.clone()), Tokens::Literal(str) => Value::Literal(str.clone()),
Tokens::SubStart => { Tokens::SubStart => {
let val = self.get_value(end); let val = self.get_value(end)?;
token = self.get_current_token(); token = self.get_current_token();
val val
}, },
Tokens::StringVariable(str, _) => Value::Variable(str.clone()), Tokens::StringVariable(str, _) => {
if str.len() == 0 { bail!("Expected variable name"); }
Value::Variable(str.clone())
},
Tokens::ArrayVariable(str, _) => Value::ArrayVariable(str.clone()), Tokens::ArrayVariable(str, _) => Value::ArrayVariable(str.clone()),
Tokens::FileWrite => break, Tokens::FileWrite => break,
Tokens::FileRead => break, Tokens::FileRead => break,
@ -169,11 +173,11 @@ impl Tree {
if buf.len() > 0 { if buf.len() > 0 {
values.push(CommandValue::Value(Value::Values(buf))); values.push(CommandValue::Value(Value::Values(buf)));
} }
Expression::Command(values) Ok(Expression::Command(values))
} }
fn parse_let(&mut self, end: usize) -> Expression { fn parse_let(&mut self, end: usize) -> Result<Expression> {
if end < self.i + 2 { panic!("Let needs name and equal sign (=) at minimum") } if end < self.i + 2 { bail!("Let needs name and equal sign (=) at minimum") }
self.inc(); self.inc();
let mut len = 0; let mut len = 0;
for token in &self.tokens[self.i..] { for token in &self.tokens[self.i..] {
@ -182,14 +186,14 @@ impl Tree {
_ => len += 1 _ => len += 1
} }
} }
let key = Box::new(self.get_value(self.i + len)); let key = Box::new(self.get_value(self.i + len)?);
self.inc(); // ???? self.inc(); // ????
self.inc(); self.inc();
let value = Box::new(self.get_value(end)); let value = Box::new(self.get_value(end)?);
Expression::LetExpression(LetExpression { key, value }) Ok(Expression::LetExpression(LetExpression { key, value }))
} }
fn parse_read(&mut self, target: Option<Expression>, end: usize) -> Expression { fn parse_read(&mut self, target: Option<Expression>, _end: usize) -> Result<Expression> {
let target = match target { let target = match target {
Some(source) => Some(Box::new(source)), Some(source) => Some(Box::new(source)),
None => None None => None
@ -201,19 +205,19 @@ impl Tree {
val_end += 1; val_end += 1;
match token { match token {
Tokens::Space => if found_first { break }, Tokens::Space => if found_first { break },
Tokens::CommandEnd(_) => if !found_first { panic!("Unexpected command end") } else { break }, Tokens::CommandEnd(_) => if !found_first { bail!("Unexpected command end") } else { break },
Tokens::FileRead => panic!("Unexpected file read (<)"), Tokens::FileRead => bail!("Unexpected file read (<)"),
Tokens::FileWrite => panic!("Unexpected file write (>)"), Tokens::FileWrite => bail!("Unexpected file write (>)"),
_ => { found_first = true; } _ => { found_first = true; }
} }
} }
val_end -= 1; val_end -= 1;
let source = Box::new(self.get_value(val_end)); let source = Box::new(self.get_value(val_end)?);
self.inc(); self.inc();
Expression::FileSourceExpression(FileSourceExpression { source, target }) Ok(Expression::FileSourceExpression(FileSourceExpression { source, target }))
} }
fn parse_write(&mut self, source: Option<Expression>, end: usize) -> Expression { fn parse_write(&mut self, source: Option<Expression>, _end: usize) -> Result<Expression> {
let source = match source { let source = match source {
Some(source) => Some(Box::new(source)), Some(source) => Some(Box::new(source)),
None => None None => None
@ -225,52 +229,52 @@ impl Tree {
val_end += 1; val_end += 1;
match token { match token {
Tokens::Space => if found_first { break }, Tokens::Space => if found_first { break },
Tokens::CommandEnd(_) => if !found_first { panic!("Unexpected command end") } else { break }, Tokens::CommandEnd(_) => if !found_first { bail!("Unexpected command end") } else { break },
Tokens::FileRead => panic!("Unexpected file read (<)"), Tokens::FileRead => bail!("Unexpected file read (<)"),
Tokens::FileWrite => panic!("Unexpected file write (>)"), Tokens::FileWrite => bail!("Unexpected file write (>)"),
_ => { found_first = true; } _ => { found_first = true; }
} }
} }
val_end -= 1; val_end -= 1;
let target = Box::new(self.get_value(val_end)); let target = Box::new(self.get_value(val_end)?);
self.inc(); self.inc();
Expression::FileTargetExpression(FileTargetExpression { source, target }) Ok(Expression::FileTargetExpression(FileTargetExpression { source, target }))
} }
fn parse_function(&self, end: usize) -> FunctionDefinitionExpression { fn parse_function(&self, _end: usize) -> Result<FunctionDefinitionExpression> {
panic!("Functions not yet implemented") bail!("Functions not yet implemented")
} }
fn parse_array_func(&self, str: String, end: usize) -> DefinedFunction { fn parse_array_func(&self, _str: String, _end: usize) -> Result<DefinedFunction> {
panic!("Array functions not yet implemented"); bail!("Array functions not yet implemented");
} }
fn parse_string_func(&self, str: String, end: usize) -> DefinedFunction { fn parse_string_func(&self, _str: String, _end: usize) -> Result<DefinedFunction> {
panic!("Array functions not yet implemented"); bail!("Array functions not yet implemented");
} }
fn parse_for(&self, end: usize) -> ForExpression { fn parse_for(&self, _end: usize) -> Result<ForExpression> {
panic!("For loop not yet implemented"); bail!("For loop not yet implemented");
} }
fn parse_if(&self, end: usize) -> IfExpression { fn parse_if(&self, _end: usize) -> Result<IfExpression> {
panic!("If not yet implemented"); bail!("If not yet implemented");
} }
fn parse_while(&self, end: usize) -> WhileExpression { fn parse_while(&self, _end: usize) -> Result<WhileExpression> {
panic!("While not yet implemented"); bail!("While not yet implemented");
} }
fn parse_sub(&mut self, end: usize) -> Vec<Expression> { fn parse_sub(&mut self, end: usize) -> Result<Vec<Expression>> {
let mut expressions: Vec<Expression> = Vec::new(); let mut expressions: Vec<Expression> = Vec::new();
loop { loop {
if self.i >= end - 1 { break; } if self.i >= end - 1 { break; }
expressions.push(self.get_expression(end)); expressions.push(self.get_expression(end)?);
} }
expressions Ok(expressions)
} }
fn get_value(&mut self, end: usize) -> Value { fn get_value(&mut self, end: usize) -> Result<Value> {
let mut token = self.get_current_token(); let mut token = self.get_current_token();
let mut values: Vec<Value> = Vec::new(); let mut values: Vec<Value> = Vec::new();
let mut buf: Vec<Value> = Vec::new(); let mut buf: Vec<Value> = Vec::new();
@ -284,15 +288,15 @@ impl Tree {
}, },
Tokens::CommandEnd(_) => break, Tokens::CommandEnd(_) => break,
Tokens::Literal(str) => buf.push(Value::Literal(str.clone())), Tokens::Literal(str) => buf.push(Value::Literal(str.clone())),
Tokens::ExportSet => panic!("Unexpected token EXPORT_SET (=)"), Tokens::ExportSet => bail!("Unexpected token EXPORT_SET (=)"),
Tokens::FileRead => buf.push(Value::Literal(token.to_str())), Tokens::FileRead => buf.push(Value::Literal(token.to_str())),
Tokens::Function => buf.push(Value::Literal(token.to_str())), Tokens::Function => buf.push(Value::Literal(token.to_str())),
Tokens::FileWrite => buf.push(Value::Literal(token.to_str())), Tokens::FileWrite => buf.push(Value::Literal(token.to_str())),
Tokens::RedirectInto => panic!("Unexpected token REDIRECT (|)"), Tokens::RedirectInto => bail!("Unexpected token REDIRECT (|)"),
Tokens::ParenthesisEnd => panic!("Unexpected token FUNCTION CALL END ())"), Tokens::ParenthesisEnd => bail!("Unexpected token FUNCTION CALL END ())"),
Tokens::ArrayFunction(_) => panic!("Unexpected array function"), Tokens::ArrayFunction(_) => bail!("Unexpected array function"),
Tokens::StringFunction(_) => panic!("Unexpected string function"), Tokens::StringFunction(_) => bail!("Unexpected string function"),
Tokens::ParenthesisStart => panic!("Parenthesis not yet implemented"), Tokens::ParenthesisStart => bail!("Parenthesis not yet implemented"),
Tokens::SubStart => { Tokens::SubStart => {
let mut len = 0; let mut len = 0;
let mut lvl = 1; let mut lvl = 1;
@ -318,10 +322,10 @@ impl Tree {
panic!("Parenthesis do not match"); panic!("Parenthesis do not match");
} }
dbg!(&self, len); dbg!(&self, len);
let val = Value::Expressions(self.parse_sub(self.i + len)); let val = Value::Expressions(self.parse_sub(self.i + len)?);
self.inc(); self.inc();
dbg!(self); dbg!(self);
return val; return Ok(val);
}, },
Tokens::Else => buf.push(Value::Literal(token.to_str())), Tokens::Else => buf.push(Value::Literal(token.to_str())),
Tokens::End => buf.push(Value::Literal(token.to_str())), Tokens::End => buf.push(Value::Literal(token.to_str())),
@ -343,9 +347,9 @@ impl Tree {
} }
values.push(Value::ArrayVariable(str.clone())); values.push(Value::ArrayVariable(str.clone()));
}, },
Tokens::And => panic!("Unexpected AND (&&)"), Tokens::And => bail!("Unexpected AND (&&)"),
Tokens::Or => panic!("Unexpected OR (||)"), Tokens::Or => bail!("Unexpected OR (||)"),
Tokens::JobCommandEnd => panic!("Unexpected job command end (&)"), Tokens::JobCommandEnd => bail!("Unexpected job command end (&)"),
} }
if self.i >= end - 1 { break } if self.i >= end - 1 { break }
token = self.inc().get_current_token(); token = self.inc().get_current_token();
@ -353,10 +357,10 @@ impl Tree {
if buf.len() > 0 { if buf.len() > 0 {
values.push(Value::Values(buf)); values.push(Value::Values(buf));
} }
Value::Values(values) Ok(Value::Values(values))
} }
fn get_expression(&mut self, end: usize) -> Expression { fn get_expression(&mut self, end: usize) -> Result<Expression> {
let mut token = self.get_current_token(); let mut token = self.get_current_token();
let mut expr: Option<Expression> = None; let mut expr: Option<Expression> = None;
loop { loop {
@ -364,23 +368,23 @@ impl Tree {
Tokens::Space => {self.inc();}, Tokens::Space => {self.inc();},
Tokens::CommandEnd(_) => { if matches!(expr, Some(_)) { break }; self.inc();}, Tokens::CommandEnd(_) => { if matches!(expr, Some(_)) { break }; self.inc();},
Tokens::Literal(t) => if matches!(expr, Some(_)) { Tokens::Literal(t) => if matches!(expr, Some(_)) {
panic!("Unexpected literal. After file redirect, you need to use a semicolon or newline."); bail!("Unexpected literal. After file redirect, you need to use a semicolon or newline.");
} else { } else {
expr = Some(self.parse_call(end)); expr = Some(self.parse_call(end)?);
}, },
Tokens::ExportSet => panic!("Unexpected token EXPORT SET (=)"), Tokens::ExportSet => bail!("Unexpected token EXPORT SET (=)"),
Tokens::Function => return Expression::Function(self.parse_function(end)), Tokens::Function => return Ok(Expression::Function(self.parse_function(end)?)),
Tokens::FileRead => expr = Some(self.parse_read(expr, end)), Tokens::FileRead => expr = Some(self.parse_read(expr, end)?),
Tokens::FileWrite => expr = Some(self.parse_write(expr, end)), Tokens::FileWrite => expr = Some(self.parse_write(expr, end)?),
Tokens::RedirectInto => match expr { Tokens::RedirectInto => match expr {
None => panic!("Unexpected token REDIRECT (|)"), None => bail!("Unexpected token REDIRECT (|)"),
Some(_) => { Some(_) => {
self.i += 1; self.i += 1;
expr = Some(Expression::RedirectTargetExpression(RedirectTargetExpression { source: Box::new(expr.unwrap()), target: Box::new(self.get_expression(end)) })); expr = Some(Expression::RedirectTargetExpression(RedirectTargetExpression { source: Box::new(expr.unwrap()), target: Box::new(self.get_expression(end)?) }));
} }
}, },
Tokens::ParenthesisStart => if matches!(expr, Some(_)) { Tokens::ParenthesisStart => if matches!(expr, Some(_)) {
panic!("Unexpected parenthesis. After file redirect, you need to use a semicolon or newline."); bail!("Unexpected parenthesis. After file redirect, you need to use a semicolon or newline.");
} else { } else {
let mut len = 1; let mut len = 1;
let mut lvl = 1; let mut lvl = 1;
@ -399,57 +403,59 @@ impl Tree {
len += 1; len += 1;
} }
if lvl != 0 { if lvl != 0 {
panic!("Parenthesis not ended properly."); bail!("Parenthesis not ended properly.");
} }
expr = Some(self.get_expression(self.i + len)); expr = Some(self.get_expression(self.i + len)?);
self.inc(); self.inc();
}, },
Tokens::ParenthesisEnd => panic!("Unexpected token PARENTHESIS END ())"), Tokens::ParenthesisEnd => bail!("Unexpected token PARENTHESIS END ())"),
Tokens::ArrayFunction(_) => panic!("Unexpected array function"), Tokens::ArrayFunction(_) => bail!("Unexpected array function"),
Tokens::StringFunction(_) => panic!("Unexpected string function"), Tokens::StringFunction(_) => bail!("Unexpected string function"),
Tokens::SubStart => if matches!(expr, Some(_)) { Tokens::SubStart => match expr {
panic!("Unexpected literal. After file redirect, you need to use a semicolon or newline."); Some(_) => bail!("Unexpected literal. After file redirect, you need to use a semicolon or newline."),
} else { _ => expr = Some(self.parse_call(end)?)
expr = Some(self.parse_call(end));
}, },
Tokens::Else => panic!("Unexpected token ELSE"), Tokens::Else => bail!("Unexpected token ELSE"),
Tokens::End => panic!("Unexpected token END"), Tokens::End => bail!("Unexpected token END"),
Tokens::For => match expr { Tokens::For => match expr {
Some(_) => panic!("Commands must be ended properly"), Some(_) => bail!("Commands must be ended properly"),
None => expr = Some(Expression::ForExpression(self.parse_for(end))), None => expr = Some(Expression::ForExpression(self.parse_for(end)?)),
}, },
Tokens::If => match expr { Tokens::If => match expr {
Some(_) => panic!("Commands must be ended properly"), Some(_) => bail!("Commands must be ended properly"),
None => expr = Some(Expression::IfExpression(self.parse_if(end))), None => expr = Some(Expression::IfExpression(self.parse_if(end)?)),
} }
Tokens::Let => return self.parse_let(end), Tokens::Let => return Ok(self.parse_let(end)?),
Tokens::While => return Expression::WhileExpression(self.parse_while(end)), Tokens::While => return Ok(Expression::WhileExpression(self.parse_while(end)?)),
Tokens::StringVariable(_, _) => if matches!(expr, Some(_)) { Tokens::StringVariable(_, _) => if matches!(expr, Some(_)) {
panic!("Unexpected variable. After file redirect, you need to use a semicolon or newline."); bail!("Unexpected variable. After file redirect, you need to use a semicolon or newline.");
} else { } else {
expr = Some(self.parse_call(end)); expr = Some(self.parse_call(end)?);
}, },
Tokens::ArrayVariable(_, _) => panic!("Unexpected array variable"), Tokens::ArrayVariable(_, _) => bail!("Unexpected array variable"),
Tokens::And => match expr { Tokens::And => match expr {
None => panic!("Unexpected AND (&&)"), None => bail!("Unexpected AND (&&)"),
Some(_) => { Some(_) => {
self.inc(); self.inc();
expr = Some(Expression::AndExpression(AndExpression { first: Box::new(expr.unwrap()), second: Box::new(self.get_expression(end)) })); expr = Some(Expression::AndExpression(AndExpression { first: Box::new(expr.unwrap()), second: Box::new(self.get_expression(end)?) }));
} }
}, },
Tokens::Or => match expr { Tokens::Or => match expr {
None => panic!("Unexpected OR (||)"), None => bail!("Unexpected OR (||)"),
Some(_) => { Some(_) => {
self.inc(); self.inc();
expr = Some(Expression::OrExpression(OrExpression { first: Box::new(expr.unwrap()), second: Box::new(self.get_expression(end)) })); expr = Some(Expression::OrExpression(OrExpression { first: Box::new(expr.unwrap()), second: Box::new(self.get_expression(end)?) }));
} }
}, },
Tokens::JobCommandEnd => panic!("Jobs not yet implemented") Tokens::JobCommandEnd => bail!("Jobs not yet implemented")
} }
if self.i >= end - 1 { break } if self.i >= end - 1 { break }
token = self.get_current_token(); token = self.get_current_token();
} }
expr.unwrap() match expr {
Some(expr) => Ok(expr),
None => bail!("No expression found")
}
} }
fn inc(&mut self) -> &Self { fn inc(&mut self) -> &Self {
@ -464,13 +470,13 @@ impl Tree {
} }
} }
pub fn build_tree(tokens: Vec<Tokens>) -> Vec<Expression> { pub fn build_tree(tokens: Vec<Tokens>) -> Result<Vec<Expression>> {
let mut expressions: Vec<Expression> = Vec::new(); let mut expressions: Vec<Expression> = Vec::new();
let mut tree = Tree { tokens, i: 0 }; let mut tree = Tree { tokens, i: 0 };
loop { loop {
if tree.i == tree.tokens.len() - 1 { break; } if tree.i == tree.tokens.len() - 1 { break; }
let val = tree.get_expression(tree.tokens.len()); let val = tree.get_expression(tree.tokens.len());
expressions.push(val); expressions.push(val?);
} }
expressions Ok(expressions)
} }

2
src/parser/exec.rs
View file

@ -1,8 +1,6 @@
use std::error::Error;
use std::fs::File; use std::fs::File;
use std::process::{Child, Command, Stdio}; use std::process::{Child, Command, Stdio};
use std::io; use std::io;
use std::ops::Deref;
use crate::parser::ast::{AndExpression, CommandValue, Expression, FileSourceExpression, FileTargetExpression, LetExpression, OrExpression, RedirectTargetExpression, Value}; use crate::parser::ast::{AndExpression, CommandValue, Expression, FileSourceExpression, FileTargetExpression, LetExpression, OrExpression, RedirectTargetExpression, Value};
use crate::parser::vars; use crate::parser::vars;
use crate::parser::vars::{Context, Variable}; use crate::parser::vars::{Context, Variable};

6
src/parser/mod.rs
View file

@ -6,8 +6,9 @@ mod exec;
use crate::parser::ast::{build_tree}; use crate::parser::ast::{build_tree};
use crate::parser::exec::exec_tree; use crate::parser::exec::exec_tree;
use crate::parser::tokens::{tokenize}; use crate::parser::tokens::{tokenize};
use anyhow::Result;
pub fn exec(reader: &mut dyn std::io::BufRead, ctx: &mut vars::Context) { pub fn exec(reader: &mut dyn std::io::BufRead, ctx: &mut vars::Context) -> Result<()> {
let tokens = tokenize(reader).unwrap(); let tokens = tokenize(reader).unwrap();
dbg!(&tokens); dbg!(&tokens);
@ -16,7 +17,8 @@ pub fn exec(reader: &mut dyn std::io::BufRead, ctx: &mut vars::Context) {
dbg!(&expressions); dbg!(&expressions);
exec_tree(expressions, ctx); exec_tree(expressions?, ctx);
Ok(())
} }
pub fn escape(str: String) -> String { pub fn escape(str: String) -> String {