use crate::ast::{Arg, Command};
use crate::err::SpecError;
use crate::lexer::{lex, Tok};
const MAX_BLOCK_DEPTH: usize = 256;
pub fn parse(src: &str) -> Result<Vec<Command>, SpecError> {
let desugared = crate::rust_ffi::desugar(src);
parse_at(&desugared, 0, 0)
}
fn parse_at(src: &str, base: usize, depth: usize) -> Result<Vec<Command>, SpecError> {
if depth > MAX_BLOCK_DEPTH {
return Err(SpecError {
msg: "spec: blocks too deeply nested".into(),
span: Some((base, base + 1)),
});
}
let toks = lex(src)?;
let mut cmds = Vec::new();
let mut cur: Vec<Arg> = Vec::new();
let mut cur_pos: Option<usize> = None;
for (t, off) in &toks {
match t {
Tok::Sep => {
if !cur.is_empty() {
cmds.push(finish(
std::mem::take(&mut cur),
cur_pos.take().unwrap_or(base),
)?);
}
}
Tok::Word(w) => {
cur_pos.get_or_insert(base + off);
cur.push(Arg::Word(w.clone()));
}
Tok::Str(s) => {
cur_pos.get_or_insert(base + off);
cur.push(Arg::Str(s.clone()));
}
Tok::Block(raw) => {
cur_pos.get_or_insert(base + off);
cur.push(Arg::Block(parse_at(raw, base + off + 1, depth + 1)?));
}
}
}
if !cur.is_empty() {
cmds.push(finish(cur, cur_pos.unwrap_or(base))?);
}
Ok(cmds)
}
fn finish(mut args: Vec<Arg>, pos: usize) -> Result<Command, SpecError> {
let name = match args.first() {
Some(Arg::Word(s)) | Some(Arg::Str(s)) => s.clone(),
Some(Arg::Block(_)) => {
return Err(SpecError {
msg: "command cannot start with a block".into(),
span: Some((pos, pos + 1)),
})
}
None => {
return Err(SpecError {
msg: "empty command".into(),
span: Some((pos, pos + 1)),
})
}
};
args.remove(0);
Ok(Command { name, args, pos })
}