use crate::shell::ast::{Arg, Command, Pipeline, Redirect, ScriptNode, SeqOp};
use crate::shell::lexer::{Lexer, Symbol, Token};
#[derive(Debug)]
pub struct ShParser {
lexer: Lexer,
lookahead: Option<Token>,
pipefail: bool,
}
impl ShParser {
pub fn new(data: &str, win32_escapes: bool, pipefail: bool) -> Self {
Self {
lexer: Lexer::new(data, win32_escapes),
lookahead: None,
pipefail,
}
}
pub fn parse(&mut self) -> Result<ScriptNode, String> {
let mut node = self.parse_pipeline()?;
while let Some(op) = self.peek()? {
let seq_op = match op {
Token::Symbol(Symbol::Semicolon) => SeqOp::Semicolon,
Token::Symbol(Symbol::Ampersand) => SeqOp::Ampersand,
Token::Symbol(Symbol::OrOr) => SeqOp::Or,
Token::Symbol(Symbol::AndAnd) => SeqOp::And,
_ => break,
};
self.next()?;
if self.peek()?.is_none() {
if seq_op == SeqOp::Semicolon {
return Ok(node);
}
return Err("missing argument to operator".to_string());
}
let rhs = self.parse_pipeline()?;
node = ScriptNode::Seq(Box::new(node), seq_op, Box::new(rhs));
}
Ok(node)
}
fn parse_pipeline(&mut self) -> Result<ScriptNode, String> {
let mut commands = vec![self.parse_command()?];
while self.peek()? == Some(Token::Symbol(Symbol::Pipe)) {
self.next()?;
commands.push(self.parse_command()?);
}
Ok(ScriptNode::Pipeline(Pipeline {
commands,
negate: false,
pipe_fail: self.pipefail,
}))
}
fn parse_command(&mut self) -> Result<Command, String> {
let mut args = Vec::new();
let mut redirects = Vec::new();
let mut have_command = false;
while let Some(tok) = self.peek()? {
match tok {
Token::Word(_) => {
let word = self
.next()?
.to_word()
.ok_or_else(|| "internal parser error".to_string())?;
self.append_word_or_redirect(&mut args, &mut redirects, word)?;
have_command = true;
}
Token::Symbol(Symbol::Redirect(_)) => {
let redirect = self.next()?;
let op = redirect
.to_redirect()
.ok_or_else(|| "expected redirect".to_string())?;
self.append_redirect(&mut redirects, None, op)?;
}
Token::Symbol(Symbol::Semicolon)
| Token::Symbol(Symbol::Ampersand)
| Token::Symbol(Symbol::OrOr)
| Token::Symbol(Symbol::AndAnd)
| Token::Symbol(Symbol::Pipe) => break,
Token::Eof => break,
}
}
if !have_command {
return Err("empty command".to_string());
}
Ok(Command { args, redirects })
}
fn append_word_or_redirect(
&mut self,
args: &mut Vec<Arg>,
redirects: &mut Vec<Redirect>,
word: Arg,
) -> Result<(), String> {
if Self::word_is_redirect_prefix(word.as_str())
&& matches!(self.peek()?, Some(Token::Symbol(Symbol::Redirect(_))))
{
let source_fd = word
.parse::<usize>()
.map_err(|_| "bad redirect prefix".to_string())?;
let op = self
.next()?
.to_redirect()
.ok_or_else(|| "expected redirect after prefix".to_string())?;
self.append_redirect(redirects, Some(source_fd), op)?;
return Ok(());
}
args.push(word);
Ok(())
}
fn append_redirect(
&mut self,
redirects: &mut Vec<Redirect>,
source_fd: Option<usize>,
op: String,
) -> Result<(), String> {
let has_source = source_fd.is_some();
let op = if has_source && op == "&>" {
">&".to_string()
} else {
op
};
let target = self
.next()?
.to_word()
.ok_or_else(|| "redirection target missing".to_string())?;
let source_fd = source_fd.unwrap_or_else(|| Redirect::default_source_fd(&op));
redirects.push(Redirect {
source_fd,
op,
target,
});
Ok(())
}
fn word_is_redirect_prefix(word: &str) -> bool {
!word.is_empty() && word.chars().all(|c| c.is_ascii_digit())
}
fn next(&mut self) -> Result<Token, String> {
if let Some(tok) = self.lookahead.take() {
Ok(tok)
} else {
self.lexer.next_token()
}
}
fn peek(&mut self) -> Result<Option<Token>, String> {
if self.lookahead.is_none() {
let tok = self.lexer.next_token()?;
if tok == Token::Eof {
return Ok(None);
}
self.lookahead = Some(tok);
}
Ok(self.lookahead.clone())
}
}
impl Redirect {
fn default_source_fd(op: &str) -> usize {
match op {
"<" | "<&" | "<<" => 0,
"&>" | ">" | ">>" | ">&" => 1,
_ => 1,
}
}
}
trait TokenExt {
fn to_word(self) -> Option<Arg>;
fn to_redirect(self) -> Option<String>;
}
impl TokenExt for Token {
fn to_word(self) -> Option<Arg> {
match self {
Token::Word(w) => Some(w),
_ => None,
}
}
fn to_redirect(self) -> Option<String> {
match self {
Token::Symbol(Symbol::Redirect(op)) => Some(op),
_ => None,
}
}
}
#[cfg(test)]
mod tests {
use super::ShParser;
use crate::shell::ast::{ScriptNode, SeqOp};
#[test]
fn parse_pipeline() {
let mut p = ShParser::new("echo a | cat", false, true);
assert!(matches!(p.parse().unwrap(), ScriptNode::Pipeline(_)));
}
#[test]
fn parse_redirections_with_numeric_fd() {
let mut p = ShParser::new("echo foo 2> out 2>&1", false, true);
if let ScriptNode::Pipeline(pipeline) = p.parse().unwrap() {
assert_eq!(pipeline.commands[0].redirects.len(), 2);
assert_eq!(pipeline.commands[0].redirects[0].source_fd, 2);
assert_eq!(pipeline.commands[0].redirects[1].source_fd, 2);
} else {
panic!("expected pipeline");
}
}
#[test]
fn parse_redirect_with_leading_fd_prefix() {
let mut p = ShParser::new("2> out echo foo", false, true);
if let ScriptNode::Pipeline(pipeline) = p.parse().unwrap() {
assert_eq!(pipeline.commands[0].redirects.len(), 1);
assert_eq!(pipeline.commands[0].redirects[0].source_fd, 2);
assert_eq!(pipeline.commands[0].redirects[0].target, "out");
assert_eq!(
pipeline.commands[0].args,
vec!["echo".to_string(), "foo".to_string()]
);
} else {
panic!("expected pipeline");
}
}
#[test]
fn parse_sequence() {
let mut p = ShParser::new("echo a && echo b", false, true);
match p.parse().unwrap() {
ScriptNode::Seq(_, SeqOp::And, _) => {}
_ => panic!("expected and sequence"),
}
}
}