use std::path::PathBuf;
use crate::{
ast::*,
error::{Error, Result},
lexer::{Token, TokenKind},
span::Span,
};
pub struct Parser {
tokens: Vec<Token>,
p: usize,
file: Option<String>,
raw_text: String,
}
impl Parser {
pub fn new(tokens: Vec<Token>, file: Option<String>, raw_text: String) -> Self {
Self { tokens, p: 0, file, raw_text }
}
pub fn parse_script_lenient(mut self) -> (Script, Vec<Error>) {
let mut commands = Vec::new();
let mut errors = Vec::new();
while !self.eof() {
match self.parse_command() {
Ok(cmd) => commands.push(cmd),
Err(e) => {
errors.push(e);
self.sync_to_next_semi();
}
}
}
(Script { commands }, errors)
}
fn sync_to_next_semi(&mut self) {
while let Some(tok) = self.peek().cloned() {
self.bump();
if matches!(tok.kind, TokenKind::Semi) {
break;
}
}
}
fn parse_command(&mut self) -> Result<Spanned<Command>> {
let start = self.peek_span_start();
let tok = self.peek().cloned().ok_or_else(|| self.err_parse("unexpected eof", None))?;
let name = match tok.kind {
TokenKind::Ident(s) => s,
_ => return Err(self.err_parse("expected command identifier", Some(tok.span))),
};
self.bump();
if let Some(digits) = name
.get(..2)
.filter(|prefix| prefix.eq_ignore_ascii_case("rs"))
.and_then(|_| name.get(2..))
.filter(|s| !s.is_empty())
{
if digits.bytes().all(|b| b.is_ascii_digit()) {
let seed = digits
.parse::<u64>()
.map_err(|_| self.err_parse("invalid u64", Some(tok.span)))?;
self.expect_semi()?;
let span = Span::new(start, self.last_end());
return Ok(Spanned::new(Command::RSeed(RSeedCmd::Set(seed)), span));
}
}
if let Some(index) = compact_numeric_suffix(&name, &["tplot", "tp"]) {
self.expect_semi()?;
let span = Span::new(start, self.last_end());
return Ok(Spanned::new(Command::TPlot(vec![TreeSelector::Index(index)]), span));
}
if let Some(index) = compact_numeric_suffix(&name, &["tchoose", "tc"]) {
self.expect_semi()?;
let span = Span::new(start, self.last_end());
return Ok(Spanned::new(Command::TChoose(vec![TreeSelector::Index(index)]), span));
}
let name_norm = normalize_cmd_name(&name);
if eq_ci(name_norm, "xread") {
if let Some(tok) = self.peek() {
if matches!(tok.kind, TokenKind::Semi) {
self.bump();
let span = Span::new(start, self.last_end());
return Ok(Spanned::new(Command::XReadQuery, span));
}
}
let raw = self.collect_raw_until_semi()?;
let span = Span::new(start, self.last_end());
return Ok(Spanned::new(Command::XReadRaw(raw), span));
}
if eq_ci(name_norm, "xx") {
match self.peek().cloned() {
None => {
let span = Span::new(start, self.last_end());
return Ok(Spanned::new(Command::XxQuery, span));
}
Some(tok) if matches!(tok.kind, TokenKind::Semi) => {
self.bump();
let span = Span::new(start, self.last_end());
return Ok(Spanned::new(Command::XxQuery, span));
}
Some(_) => {
let _raw = self.collect_raw_until_semi()?;
let span = Span::new(start, self.last_end());
return Ok(Spanned::new(Command::XxQuery, span));
}
}
}
let cmd = if eq_ci(name_norm, "log") {
if self.try_consume_discriminant(TokenKind::Star) {
self.expect_semi()?;
Command::LogToggle { enabled: true }
} else if self.try_consume_discriminant(TokenKind::Minus) {
self.expect_semi()?;
Command::LogToggle { enabled: false }
} else if self.try_consume_discriminant(TokenKind::Slash) {
self.expect_semi()?;
Command::Log(LogCmd::Stop)
} else {
let path = self.parse_path_like()?;
self.expect_semi()?;
Command::Log(LogCmd::Start { path })
}
} else if eq_ci(name_norm, "display") {
let cmd = if self.try_consume_discriminant(TokenKind::Star) {
Command::Display(DisplayCmd::ToTerminalAlso)
} else if self.try_consume_discriminant(TokenKind::Minus) {
Command::Display(DisplayCmd::Disable)
} else {
Command::Display(DisplayCmd::ToTerminalAlso)
};
self.expect_semi()?;
cmd
} else if eq_ci(name_norm, "quote") {
let s = self.collect_tokens_as_string_until_semi()?;
Command::Quote(s)
} else if eq_ci(name_norm, "assist") {
if self.try_consume_discriminant(TokenKind::Star) {
self.expect_semi()?;
Command::Assist(AssistSel::All)
} else if let Some(tok) = self.peek().cloned() {
if matches!(tok.kind, TokenKind::Semi) {
self.bump();
Command::Assist(AssistSel::Default)
} else {
let raw = self.collect_tokens_as_string_until_semi()?;
Command::Assist(AssistSel::Filter(raw.trim().to_string()))
}
} else {
return Err(self.err_parse("unexpected eof after assist", None));
}
} else if eq_ci(name_norm, "view") {
if self.try_consume_discriminant(TokenKind::Star) {
self.expect_semi()?;
Command::ViewLogToggle { enabled: true }
} else if self.try_consume_discriminant(TokenKind::Minus) {
self.expect_semi()?;
Command::ViewLogToggle { enabled: false }
} else {
let path = self.parse_path_like()?;
self.expect_semi()?;
Command::View(path)
}
} else if eq_ci(name_norm, "procedure") {
if self.try_consume_discriminant(TokenKind::Star) {
self.expect_semi()?;
Command::ProcedureToggle { enabled: true }
} else if self.try_consume_discriminant(TokenKind::Minus) {
self.expect_semi()?;
Command::ProcedureToggle { enabled: false }
} else if self.peek().map(|t| t.kind == TokenKind::Slash).unwrap_or(false)
&& self.tokens.get(self.p + 1).map(|t| t.kind == TokenKind::Semi).unwrap_or(false)
{
self.bump();
self.expect_semi()?;
Command::ProcedureClose
} else {
let path = self.parse_path_like()?;
self.expect_semi()?;
Command::ProcedureOpen(path)
}
} else if eq_ci(name_norm, "bytes") {
self.expect_semi()?;
Command::Bytes
} else if eq_ci(name_norm, "batch") {
let raw_args = self.collect_tokens_as_string_until_semi()?;
Command::Batch(raw_args)
} else if eq_ci(name_norm, "outgroup") {
if self.try_consume_discriminant(TokenKind::Eq) {
let nums = self.parse_outgroup_number_set()?;
self.expect_semi()?;
Command::Outgroup(OutgroupCmd::SetByNumbers(nums))
} else if let Some(tok) = self.peek() {
if matches!(tok.kind, TokenKind::Semi) {
self.bump();
Command::Outgroup(OutgroupCmd::Query)
} else {
let names = self.parse_outgroup_name_set()?;
self.expect_semi()?;
Command::Outgroup(OutgroupCmd::SetByNames(names))
}
} else {
return Err(self.err_parse("unexpected eof after outgroup", None));
}
} else if eq_ci(name_norm, "reroot") {
self.expect_semi()?;
Command::Reroot
} else if eq_ci(name_norm, "ccode") {
if let Some(tok) = self.peek() {
if matches!(tok.kind, TokenKind::Semi) {
self.bump();
Command::CCode(CCodeCmd::Query)
} else {
let ops = self.parse_ccode_ops()?;
Command::CCode(CCodeCmd::Apply(ops))
}
} else {
return Err(self.err_parse("unexpected eof after ccode", None));
}
} else if eq_ci(name_norm, "ckeep") {
let slot = self.parse_u8()?;
self.expect_semi()?;
Command::CKeep(slot)
} else if eq_ci(name_norm, "cget") {
let slot = self.parse_u8()?;
self.expect_semi()?;
Command::CGet(slot)
} else if eq_ci(name_norm, "hennig") {
let star = self.try_consume_discriminant(TokenKind::Star);
self.expect_semi()?;
Command::Hennig { multi: false, star }
} else if eq_ci(name_norm, "mhennig") {
let star = self.try_consume_discriminant(TokenKind::Star);
self.expect_semi()?;
Command::Hennig { multi: true, star }
} else if eq_ci(name_norm, "bb") {
let star = self.try_consume_discriminant(TokenKind::Star);
self.expect_semi()?;
Command::Bb { star }
} else if eq_ci(name_norm, "nelsen") {
self.expect_semi()?;
Command::Nelsen
} else if eq_ci(name_norm, "naked") {
if self.try_consume_discriminant(TokenKind::Eq) {
self.expect_semi()?;
Command::NakedSet { show_node_labels: false }
} else if self.try_consume_discriminant(TokenKind::Minus) {
self.expect_semi()?;
Command::NakedSet { show_node_labels: true }
} else {
self.expect_semi()?;
Command::NakedQuery
}
} else if eq_ci(name_norm, "ie") {
let cmd = if self.try_consume_discriminant(TokenKind::Star) {
Command::IeStar
} else if self.try_consume_discriminant(TokenKind::Minus) {
Command::IeDash
} else {
Command::Ie
};
self.expect_semi()?;
cmd
} else if eq_ci(name_norm, "keep") {
let slot = self.parse_u8()?;
self.expect_semi()?;
Command::Keep(slot)
} else if eq_ci(name_norm, "get") {
let slot = self.parse_u8()?;
self.expect_semi()?;
Command::Get(slot)
} else if eq_ci(name_norm, "files") {
self.expect_semi()?;
Command::Files
} else if eq_ci(name_norm, "erase") {
let slot = self.parse_u8()?;
self.expect_semi()?;
Command::Erase(slot)
} else if eq_ci(name_norm, "tchoose") {
let items = self.parse_tchoose_items()?;
self.expect_semi()?;
Command::TChoose(items)
} else if eq_ci(name_norm, "txascii") {
let enabled = if self.try_consume_discriminant(TokenKind::Minus) {
false
} else if self.try_consume_discriminant(TokenKind::Plus) {
true
} else {
true
};
self.expect_semi()?;
Command::TXAscii(enabled)
} else if eq_ci(name_norm, "tplot") {
if self.peek().map(|t| t.kind == TokenKind::Semi).unwrap_or(false) {
self.bump();
Command::TPlot(Vec::new())
} else {
let trees = self.parse_tplot_items()?;
self.expect_semi()?;
Command::TPlot(trees)
}
} else if eq_ci(name_norm, "tread") {
let title = if let Some(tok) = self.peek().cloned() {
match tok.kind {
TokenKind::StringLit(s) => {
self.bump();
Some(s)
}
_ => None,
}
} else {
None
};
let raw = self.collect_raw_until_semi()?;
let trees = split_tread_trees(&raw)
.map_err(|m| self.err_parse(m, Some(Span::new(start, self.last_end()))))?;
Command::TRead { title, trees }
} else if eq_ci(name_norm, "tlist") {
if self.peek().map(|t| t.kind == TokenKind::Semi).unwrap_or(false) {
self.bump();
Command::TList(Vec::new())
} else {
let trees = self.parse_required_tree_selector_items("tlist")?;
self.expect_semi()?;
Command::TList(trees)
}
} else if eq_ci(name_norm, "tsave") {
let path = self.parse_path_like()?;
self.expect_semi()?;
Command::TSave(path)
} else if eq_ci(name_norm, "tsvg") {
let tree = self.parse_single_tree_selector("tsvg")?;
let path = self.parse_path_like()?;
self.expect_semi()?;
Command::Tsvg { tree, path }
} else if eq_ci(name_norm, "ttags") {
if self.try_consume_discriminant(TokenKind::Eq) {
self.expect_semi()?;
Command::TTags(TTagsCmd::Enable)
} else if self.try_consume_discriminant(TokenKind::Minus) {
self.expect_semi()?;
Command::TTags(TTagsCmd::Clear)
} else if self.try_consume_discriminant(TokenKind::Amp) {
let path = self.parse_path_like()?;
self.expect_semi()?;
Command::TTags(TTagsCmd::WriteSvg(path))
} else if self.try_consume_discriminant(TokenKind::Plus) {
let node = self.parse_usize()?;
let label = self.collect_tokens_as_string_until_semi()?.trim().to_string();
if label.is_empty() {
return Err(self.err_parse("ttags +N requires label text", None));
}
Command::TTags(TTagsCmd::SetLabel { node, label })
} else {
self.expect_semi()?;
Command::TTags(TTagsCmd::Query)
}
} else if eq_ci(name_norm, "resample") {
let method = self
.peek()
.cloned()
.ok_or_else(|| self.err_parse("expected resample method", None))?;
let method_name = match method.kind {
TokenKind::Ident(s) => {
self.bump();
s
}
_ => return Err(self.err_parse("expected resample method", Some(method.span))),
};
let is_boot = method_name.eq_ignore_ascii_case("boot");
let is_jak = method_name.eq_ignore_ascii_case("jak")
|| method_name.eq_ignore_ascii_case("jack")
|| method_name.eq_ignore_ascii_case("jackknife");
let is_sym = method_name.eq_ignore_ascii_case("sym")
|| method_name.eq_ignore_ascii_case("symmetric");
if !is_boot && !is_jak && !is_sym {
return Err(self.err_parse(
format!("unsupported resample method: {method_name}"),
Some(method.span),
));
}
let replications = self.parse_usize()?;
if replications == 0 {
return Err(self.err_parse("resample requires replications > 0", None));
}
let mut tree = TreeSelector::Last;
let mut delete_percent = if is_jak {
36.8
} else if is_sym {
33.0
} else {
0.0
};
let mut search = Vec::new();
while !self.peek().map(|t| t.kind == TokenKind::Semi).unwrap_or(true) {
let tok = self
.peek()
.cloned()
.ok_or_else(|| self.err_parse("expected resample option or ';'", None))?;
match tok.kind {
TokenKind::Ident(s) if s.eq_ignore_ascii_case("from") => {
self.bump();
tree = self.parse_single_tree_selector("resample from")?;
}
TokenKind::Ident(s) if s.eq_ignore_ascii_case("delete") => {
if is_boot {
return Err(self.err_parse(
"resample boot does not accept delete; use jak or sym",
Some(tok.span),
));
}
self.bump();
delete_percent = self.parse_percent_number("resample delete")?;
}
TokenKind::LBracket => {
search = self.parse_resample_search_steps()?;
}
_ => {
return Err(self.err_parse(
"expected resample option: from, delete, [search], or ';'",
Some(tok.span),
));
}
}
}
self.expect_semi()?;
if search.is_empty() {
search = vec![
ResampleSearchStep::MHennig { star: false },
ResampleSearchStep::Bb { star: false },
];
}
if is_sym && delete_percent > 50.0 {
return Err(self.err_parse(
"resample sym delete percentage must be <= 50 because up and down use the same probability",
None,
));
}
if is_boot {
Command::Resample(ResampleCmd::Boot { replications, tree, search })
} else {
if is_jak {
Command::Resample(ResampleCmd::Jak {
replications,
tree,
delete_percent,
search,
})
} else {
Command::Resample(ResampleCmd::Sym {
replications,
tree,
delete_percent,
search,
})
}
}
} else if eq_ci(name_norm, "optcode") {
if self.try_consume_discriminant(TokenKind::Semi) {
Command::OptCode(OptCodeCmd::Query)
} else {
let mut ops = vec![self.parse_optcode_op()?];
while self.try_consume_discriminant(TokenKind::Star) {
ops.push(self.parse_optcode_op()?);
}
self.expect_semi()?;
Command::OptCode(OptCodeCmd::Apply(ops))
}
} else if eq_ci(name_norm, "apo") {
let tree = self.parse_single_tree_selector("apo")?;
let path = if self.peek().map(|t| t.kind == TokenKind::Semi).unwrap_or(false) {
None
} else {
Some(self.parse_path_like()?)
};
self.expect_semi()?;
Command::Apo { tree, path }
} else if eq_ci(name_norm, "xsteps") {
if let Some(tok) = self.peek().cloned() {
if matches!(tok.kind, TokenKind::Semi) {
self.bump();
Command::XSteps(vec![XStepsMode::L])
} else {
let tok2 = self
.peek()
.cloned()
.ok_or_else(|| self.err_parse("expected xsteps mode(s)", None))?;
let s = match tok2.kind {
TokenKind::Ident(s) => {
self.bump();
s
}
_ => {
return Err(self.err_parse(
"expected xsteps mode identifier (e.g. l, c, h, m, w, u, or lchm)",
Some(tok2.span),
));
}
};
let mut modes: Vec<XStepsMode> = Vec::new();
for ch in s.chars() {
let m = match ch.to_ascii_lowercase() {
'l' => XStepsMode::L,
'c' => XStepsMode::C,
'h' => XStepsMode::H,
'm' => XStepsMode::M,
'w' => XStepsMode::W,
'u' => XStepsMode::U,
_ => {
return Err(self.err_parse(
format!("unknown xsteps mode: {ch} (allowed: l c h m w)"),
Some(tok2.span),
));
}
};
modes.push(m);
}
self.expect_semi()?;
if modes.is_empty() {
return Err(
self.err_parse("xsteps requires at least one mode", Some(tok2.span))
);
}
Command::XSteps(modes)
}
} else {
return Err(self.err_parse("expected ';' or xsteps mode(s)", None));
}
} else if eq_ci(name_norm, "steps") {
self.expect_semi()?;
Command::Steps
} else if eq_ci(name_norm, "watch") {
let on = !self.try_consume_discriminant(TokenKind::Minus);
self.expect_semi()?;
Command::Watch(on)
} else if eq_ci(name_norm, "rseed") {
let seed = if self.try_consume_discriminant(TokenKind::Star) {
RSeedCmd::Random
} else if self.peek().map(|t| t.kind == TokenKind::Semi).unwrap_or(false) {
RSeedCmd::Query
} else {
RSeedCmd::Set(self.parse_u64()?)
};
self.expect_semi()?;
Command::RSeed(seed)
} else if eq_ci(name_norm, "yama") {
self.expect_semi()?;
Command::Yama
} else {
let raw_args = self.collect_tokens_as_string_until_semi()?;
Command::Unknown { name, raw_args }
};
let span = Span::new(start, self.last_end());
Ok(Spanned::new(cmd, span))
}
fn parse_outgroup_number_set(&mut self) -> Result<Vec<usize>> {
let mut out = Vec::new();
loop {
let a = self.parse_u32()? as usize;
if self.try_consume_discriminant(TokenKind::Dot) {
let b = self.parse_u32()? as usize;
if a > b {
return Err(self.err_parse(format!("invalid outgroup range {a}.{b}"), None));
}
for x in a..=b {
out.push(x);
}
} else {
out.push(a);
}
let Some(tok) = self.peek() else {
break;
};
if matches!(tok.kind, TokenKind::Semi) {
break;
}
if !matches!(tok.kind, TokenKind::Number(_)) {
return Err(self.err_parse("expected outgroup number or ';'", Some(tok.span)));
}
}
Ok(out)
}
fn parse_outgroup_name_set(&mut self) -> Result<Vec<String>> {
let mut names = Vec::new();
loop {
let tok = self
.peek()
.cloned()
.ok_or_else(|| self.err_parse("expected outgroup name", None))?;
match tok.kind {
TokenKind::Ident(s) => {
self.bump();
names.push(s);
}
TokenKind::StringLit(s) => {
self.bump();
names.push(s);
}
TokenKind::Semi => break,
_ => return Err(self.err_parse("expected outgroup taxon name", Some(tok.span))),
}
let Some(tok2) = self.peek() else {
break;
};
if matches!(tok2.kind, TokenKind::Semi) {
break;
}
}
if names.is_empty() {
return Err(self.err_parse("outgroup requires at least one taxon", None));
}
Ok(names)
}
fn parse_tchoose_items(&mut self) -> Result<Vec<crate::ast::TreeSelector>> {
self.parse_required_tree_selector_items("tchoose")
}
fn parse_tplot_items(&mut self) -> Result<Vec<crate::ast::TreeSelector>> {
self.parse_required_tree_selector_items("tplot")
}
fn parse_single_tree_selector(&mut self, command: &str) -> Result<crate::ast::TreeSelector> {
use crate::ast::TreeSelector;
use crate::lexer::TokenKind;
let tok = self
.peek()
.cloned()
.ok_or_else(|| self.err_parse(format!("expected {command} tree number"), None))?;
match tok.kind {
TokenKind::Slash => {
self.bump();
Ok(TreeSelector::Last)
}
TokenKind::Number(_) => Ok(TreeSelector::Index(self.parse_usize()?)),
_ => Err(self.err_parse(
format!("{command} requires exactly one tree number or '/'"),
Some(tok.span),
)),
}
}
fn parse_percent_number(&mut self, label: &str) -> Result<f64> {
let first = self
.peek()
.cloned()
.ok_or_else(|| self.err_parse(format!("expected {label} percentage"), None))?;
let TokenKind::Number(mut text) = first.kind else {
return Err(self.err_parse(format!("expected {label} percentage"), Some(first.span)));
};
self.bump();
if self.try_consume_discriminant(TokenKind::Dot) {
let frac = self.peek().cloned().ok_or_else(|| {
self.err_parse(format!("expected digits after {label} decimal"), None)
})?;
let TokenKind::Number(frac_text) = frac.kind else {
return Err(self
.err_parse(format!("expected digits after {label} decimal"), Some(frac.span)));
};
self.bump();
text.push('.');
text.push_str(&frac_text);
}
let value = text
.parse::<f64>()
.map_err(|_| self.err_parse(format!("invalid {label} percentage"), Some(first.span)))?;
if !(0.0..=100.0).contains(&value) {
return Err(self.err_parse(
format!("{label} percentage must be between 0 and 100"),
Some(first.span),
));
}
Ok(value)
}
fn parse_resample_search_steps(&mut self) -> Result<Vec<ResampleSearchStep>> {
self.expect_discriminant(TokenKind::LBracket)?;
let mut steps = Vec::new();
loop {
let tok = self
.peek()
.cloned()
.ok_or_else(|| self.err_parse("unterminated resample search list", None))?;
match tok.kind {
TokenKind::RBracket => {
self.bump();
break;
}
TokenKind::Semi => {
self.bump();
}
TokenKind::Ident(s) => {
self.bump();
let star = self.try_consume_discriminant(TokenKind::Star);
let dash = if s.eq_ignore_ascii_case("ie") {
self.try_consume_discriminant(TokenKind::Minus)
} else {
false
};
if star && dash {
return Err(self.err_parse(
"resample ie search step accepts only one of '*' or '-'",
Some(tok.span),
));
}
let step = if s.eq_ignore_ascii_case("h") || s.eq_ignore_ascii_case("hennig") {
ResampleSearchStep::Hennig { star }
} else if s.eq_ignore_ascii_case("mh") || s.eq_ignore_ascii_case("mhennig") {
ResampleSearchStep::MHennig { star }
} else if s.eq_ignore_ascii_case("bb") {
ResampleSearchStep::Bb { star }
} else if s.eq_ignore_ascii_case("ie") {
ResampleSearchStep::Ie { star, dash }
} else {
return Err(self.err_parse(
format!("unsupported resample search step: {s}"),
Some(tok.span),
));
};
steps.push(step);
}
_ => {
return Err(self
.err_parse("expected resample search step, ';', or ']'", Some(tok.span)));
}
}
}
if steps.is_empty() {
return Err(self.err_parse("resample search list cannot be empty", None));
}
Ok(steps)
}
fn parse_required_tree_selector_items(
&mut self,
command: &str,
) -> Result<Vec<crate::ast::TreeSelector>> {
let out = self.parse_tree_selector_items(command)?;
if out.is_empty() {
return Err(self.err_parse(
format!("{command} requires at least one selector (e.g. 0, 0.3, /)"),
None,
));
}
Ok(out)
}
fn parse_tree_selector_items(
&mut self,
command: &str,
) -> Result<Vec<crate::ast::TreeSelector>> {
use crate::ast::TreeSelector;
use crate::lexer::TokenKind;
let mut out: Vec<TreeSelector> = Vec::new();
loop {
let tok = self
.peek()
.cloned()
.ok_or_else(|| self.err_parse(format!("expected {command} selector"), None))?;
match tok.kind {
TokenKind::Semi => break,
TokenKind::Slash => {
self.bump();
out.push(TreeSelector::Last);
}
TokenKind::Number(_) => {
let a = self.parse_usize()?;
if self.try_consume_discriminant(TokenKind::Dot) {
let b = self.parse_usize()?;
out.push(TreeSelector::RangeInclusive(a, b));
} else {
out.push(TreeSelector::Index(a));
}
}
_ => {
return Err(self.err_parse(
format!("expected {command} selector: number, range a.b, '/', or ';'"),
Some(tok.span),
));
}
}
}
Ok(out)
}
fn parse_usize(&mut self) -> Result<usize> {
let tok = self.peek().cloned().ok_or_else(|| self.err_parse("expected number", None))?;
match tok.kind {
TokenKind::Number(s) => {
self.bump();
s.parse::<usize>().map_err(|_| self.err_parse("invalid usize", Some(tok.span)))
}
_ => Err(self.err_parse("expected number", Some(tok.span))),
}
}
fn parse_path_like(&mut self) -> Result<PathBuf> {
let tok = self.peek().cloned().ok_or_else(|| self.err_parse("expected path", None))?;
if matches!(tok.kind, TokenKind::StringLit(_)) {
self.bump();
return Ok(PathBuf::from(match tok.kind {
TokenKind::StringLit(s) => s,
_ => unreachable!(),
}));
}
let mut path = String::new();
loop {
let tok = self.peek().cloned().ok_or_else(|| self.err_parse("expected path", None))?;
match tok.kind {
TokenKind::Ident(s) | TokenKind::Number(s) => {
self.bump();
path.push_str(&s);
}
TokenKind::Dot => {
self.bump();
path.push('.');
}
TokenKind::Slash => {
self.bump();
path.push('/');
}
_ => break,
}
}
if path.is_empty() {
let tok = self.peek().cloned().ok_or_else(|| self.err_parse("expected path", None))?;
return Err(self.err_parse("expected path token", Some(tok.span)));
}
Ok(PathBuf::from(path))
}
fn parse_u32(&mut self) -> Result<u32> {
let tok = self.peek().cloned().ok_or_else(|| self.err_parse("expected number", None))?;
match tok.kind {
TokenKind::Number(s) => {
self.bump();
s.parse::<u32>().map_err(|_| self.err_parse("invalid u32", Some(tok.span)))
}
_ => Err(self.err_parse("expected number", Some(tok.span))),
}
}
fn parse_u64(&mut self) -> Result<u64> {
let tok = self.peek().cloned().ok_or_else(|| self.err_parse("expected number", None))?;
match tok.kind {
TokenKind::Number(s) => {
self.bump();
s.parse::<u64>().map_err(|_| self.err_parse("invalid u64", Some(tok.span)))
}
_ => Err(self.err_parse("expected number", Some(tok.span))),
}
}
fn parse_u8(&mut self) -> Result<u8> {
let tok = self.peek().cloned().ok_or_else(|| self.err_parse("expected number", None))?;
match tok.kind {
TokenKind::Number(s) => {
self.bump();
s.parse::<u8>().map_err(|_| self.err_parse("invalid u8", Some(tok.span)))
}
_ => Err(self.err_parse("expected number", Some(tok.span))),
}
}
fn parse_ccode_ops(&mut self) -> Result<Vec<CCodeOp>> {
let mut ops = Vec::new();
loop {
let op = self.parse_ccode_one_op()?;
ops.push(op);
if self.try_consume_discriminant(TokenKind::Star) {
continue;
}
self.expect_semi()?;
break;
}
Ok(ops)
}
fn parse_ccode_one_op(&mut self) -> Result<CCodeOp> {
if self.try_consume_discriminant(TokenKind::Plus) {
let sel = self.parse_char_sel_required()?;
return Ok(CCodeOp::Additive(sel));
}
if self.try_consume_discriminant(TokenKind::Minus) {
let sel = self.parse_char_sel_required()?;
return Ok(CCodeOp::NonAdditive(sel));
}
if self.try_consume_discriminant(TokenKind::LBracket) {
let sel = self.parse_char_sel_required()?;
return Ok(CCodeOp::Active(sel));
}
if self.try_consume_discriminant(TokenKind::RBracket) {
let sel = self.parse_char_sel_required()?;
return Ok(CCodeOp::Inactive(sel));
}
if self.try_consume_discriminant(TokenKind::Slash) {
let w =
if self.try_consume_discriminant(TokenKind::Dot) { 1 } else { self.parse_u32()? };
let sel = self.parse_char_sel_required()?;
return Ok(CCodeOp::Weight(w, sel));
}
Err(self.err_parse("ccode op must start with + - [ ] or /N", self.peek().map(|t| t.span)))
}
fn parse_char_sel_required(&mut self) -> Result<CharSel> {
if self.try_consume_discriminant(TokenKind::Dot) {
return Ok(CharSel::All);
}
let mut ranges = Vec::new();
ranges.push(self.parse_char_range()?);
loop {
let Some(tok) = self.peek() else {
break;
};
if matches!(tok.kind, TokenKind::Star) || matches!(tok.kind, TokenKind::Semi) {
break;
}
ranges.push(self.parse_char_range()?);
}
Ok(CharSel::List(ranges))
}
fn parse_optcode_char_sel(&mut self) -> Result<CharSel> {
if self.try_consume_discriminant(TokenKind::Dot)
|| self.try_consume_discriminant(TokenKind::Slash)
{
return Ok(CharSel::All);
}
let mut ranges = vec![self.parse_char_range()?];
while let Some(tok) = self.peek() {
if matches!(tok.kind, TokenKind::Star | TokenKind::Semi) {
break;
}
ranges.push(self.parse_char_range()?);
}
Ok(CharSel::List(ranges))
}
fn parse_optcode_op(&mut self) -> Result<OptCodeOp> {
let mode = self
.peek()
.cloned()
.ok_or_else(|| self.err_parse("expected optcode mode: u, f, or s", None))?;
let optimization = match mode.kind {
TokenKind::Ident(s) if s.eq_ignore_ascii_case("u") => ApoOptimization::Unambiguous,
TokenKind::Ident(s) if s.eq_ignore_ascii_case("f") => ApoOptimization::Fast,
TokenKind::Ident(s) if s.eq_ignore_ascii_case("s") => ApoOptimization::Slow,
_ => return Err(self.err_parse("optcode mode must be u, f, or s", Some(mode.span))),
};
self.bump();
Ok(OptCodeOp { optimization, chars: self.parse_optcode_char_sel()? })
}
fn parse_char_range(&mut self) -> Result<CharRange> {
let a = self.parse_u32()?;
if self.try_consume_discriminant(TokenKind::Dot) {
let b = self.parse_u32()?;
Ok(CharRange::RangeInclusive(a, b))
} else {
Ok(CharRange::Single(a))
}
}
fn collect_raw_until_semi(&mut self) -> Result<String> {
let mut s = String::new();
while let Some(tok) = self.peek().cloned() {
if matches!(tok.kind, TokenKind::Semi) {
self.bump();
break;
}
if !s.is_empty() {
s.push(' ');
}
s.push_str(&token_to_string(&tok));
self.bump();
}
Ok(s)
}
fn collect_tokens_as_string_until_semi(&mut self) -> Result<String> {
let mut s = String::new();
while let Some(tok) = self.peek().cloned() {
if matches!(tok.kind, TokenKind::Semi) {
self.bump();
break;
}
if !s.is_empty() {
s.push(' ');
}
s.push_str(&token_to_string(&tok));
self.bump();
}
Ok(s)
}
fn expect_semi(&mut self) -> Result<()> {
self.expect_discriminant(TokenKind::Semi)
}
fn expect_discriminant(&mut self, kind: TokenKind) -> Result<()> {
let tok = self.peek().cloned().ok_or_else(|| self.err_parse("unexpected eof", None))?;
if std::mem::discriminant(&tok.kind) == std::mem::discriminant(&kind) {
self.bump();
Ok(())
} else {
Err(self.err_parse(format!("expected {:?}, got {:?}", kind, tok.kind), Some(tok.span)))
}
}
fn try_consume_discriminant(&mut self, kind: TokenKind) -> bool {
let Some(tok) = self.peek() else {
return false;
};
if std::mem::discriminant(&tok.kind) == std::mem::discriminant(&kind) {
self.bump();
true
} else {
false
}
}
fn peek(&self) -> Option<&Token> {
self.tokens.get(self.p)
}
fn bump(&mut self) {
self.p += 1;
}
fn eof(&self) -> bool {
self.p >= self.tokens.len()
}
fn peek_span_start(&self) -> usize {
self.peek().map(|t| t.span.start).unwrap_or(self.raw_text.len())
}
fn last_end(&self) -> usize {
if self.p == 0 { 0 } else { self.tokens[self.p - 1].span.end }
}
fn err_parse(&self, msg: impl Into<String>, span: Option<Span>) -> Error {
Error::parse(msg, self.file.clone(), span)
}
}
fn eq_ci(a: &str, b: &str) -> bool {
a.eq_ignore_ascii_case(b)
}
fn token_to_string(tok: &Token) -> String {
match &tok.kind {
TokenKind::Ident(s) => s.clone(),
TokenKind::Number(s) => s.clone(),
TokenKind::StringLit(s) => format!("'{}'", s),
TokenKind::Semi => ";".to_string(),
TokenKind::Eq => "=".to_string(),
TokenKind::Slash => "/".to_string(),
TokenKind::Star => "*".to_string(),
TokenKind::Amp => "&".to_string(),
TokenKind::Plus => "+".to_string(),
TokenKind::Minus => "-".to_string(),
TokenKind::Dot => ".".to_string(),
TokenKind::LBracket => "[".to_string(),
TokenKind::RBracket => "]".to_string(),
TokenKind::LParen => "(".to_string(),
TokenKind::RParen => ")".to_string(),
TokenKind::Comma => ",".to_string(),
TokenKind::Question => "?".to_string(),
}
}
fn compact_numeric_suffix(name: &str, prefixes: &[&str]) -> Option<usize> {
let lower = name.to_ascii_lowercase();
let rest = prefixes.iter().find_map(|prefix| lower.strip_prefix(prefix))?;
if rest.is_empty() || !rest.chars().all(|ch| ch.is_ascii_digit()) {
return None;
}
rest.parse::<usize>().ok()
}
fn split_tread_trees(raw: &str) -> std::result::Result<Vec<String>, String> {
let mut trees = Vec::new();
let parts: Vec<&str> = raw.split('*').collect();
for part in parts {
let t = part.trim();
if t.is_empty() {
continue;
}
let t = t.trim_end_matches(';').trim();
if !t.starts_with('(') {
return Err(format!("tread tree must start with '('; got: {}", preview(t)));
}
if !t.ends_with(')') {
return Err(format!("tread tree must end with ')'; got: {}", preview(t)));
}
trees.push(t.to_string());
}
if trees.is_empty() {
return Err("tread contained no trees".to_string());
}
Ok(trees)
}
fn preview(s: &str) -> String {
const N: usize = 80;
if s.len() <= N { s.to_string() } else { format!("{}...", &s[..N]) }
}
fn normalize_cmd_name(name: &str) -> &str {
let n = name.to_ascii_lowercase();
match n.as_str() {
"z" | "zz" | "zzz" | "quit" | "exit" => return "yama",
"help" => return "assist",
_ => {}
}
const CMDS: &[(&str, usize)] = &[
("apo", 2),
("assist", 1),
("batch", 5),
("bb", 1),
("bytes", 2),
("ccode", 2),
("ckeep", 2),
("cget", 2),
("display", 1),
("erase", 1),
("files", 1),
("get", 1),
("hennig", 1),
("ie", 1),
("keep", 1),
("optcode", 3),
("log", 1),
("mhennig", 1),
("naked", 4),
("nelsen", 1),
("outgroup", 1),
("procedure", 1),
("quote", 1),
("reroot", 1),
("resample", 3),
("rseed", 2),
("steps", 1),
("tchoose", 2),
("tlist", 2),
("tplot", 2),
("tread", 2),
("tsave", 2),
("tsvg", 3),
("ttags", 2),
("txascii", 2),
("view", 1),
("watch", 1),
("xread", 2),
("xsteps", 2),
("xx", 2),
("yama", 1),
];
for &(canon, min_len) in CMDS {
if n.len() >= min_len && canon.starts_with(&n) {
return canon;
}
}
name
}