Files
pdfcraft/crates/js/src/formcalc/parser.rs
T

477 lines
17 KiB
Rust

use super::ast::{Expr, Idx, Stmt};
use super::lexer::{Tok, Token, lex};
use super::{Func, MAX_CHAIN, MAX_PARSE_DEPTH, Rc};
struct Parser {
toks: Vec<Token>,
at: usize,
depth: usize,
/// Operators and accessors chained so far in the expression being parsed.
chain: usize,
}
fn kw(t: &Tok, word: &str) -> bool {
matches!(t, Tok::Ident(s) if s.eq_ignore_ascii_case(word))
}
impl Parser {
fn peek(&self) -> &Tok {
self.toks.get(self.at).map_or(&Tok::Eof, |t| &t.tok)
}
fn line(&self) -> usize {
self.toks.get(self.at).map_or(0, |t| t.line)
}
fn next(&mut self) -> Tok {
let t = self.peek().clone();
self.at += 1;
t
}
fn is_op(&self, op: &str) -> bool {
matches!(self.peek(), Tok::Op(o) if *o == op)
}
fn eat_op(&mut self, op: &str) -> bool {
if self.is_op(op) {
self.at += 1;
true
} else {
false
}
}
fn expect_op(&mut self, op: &str) -> Result<(), String> {
if self.eat_op(op) { Ok(()) } else { Err(format!("line {}: expected {op}", self.line())) }
}
fn eat_kw(&mut self, word: &str) -> bool {
if kw(self.peek(), word) {
self.at += 1;
true
} else {
false
}
}
fn expect_kw(&mut self, word: &str) -> Result<(), String> {
if self.eat_kw(word) { Ok(()) } else { Err(format!("line {}: expected {word}", self.line())) }
}
fn skip_newlines(&mut self) {
while matches!(self.peek(), Tok::Newline) {
self.at += 1;
}
}
fn enter(&mut self) -> Result<(), String> {
self.depth += 1;
if self.depth > MAX_PARSE_DEPTH {
return Err("the script is nested too deeply".into());
}
Ok(())
}
fn leave(&mut self) {
self.depth = self.depth.saturating_sub(1);
}
/// One more link in an operator or accessor chain.
fn link(&mut self) -> Result<(), String> {
self.chain += 1;
if self.chain > MAX_CHAIN {
return Err(format!("line {}: an expression is too long", self.line()));
}
Ok(())
}
/// Statements up to one of `enders` (not consumed).
fn block(&mut self, enders: &[&str]) -> Result<Vec<Stmt>, String> {
self.enter()?;
let mut out = Vec::new();
loop {
self.skip_newlines();
match self.peek() {
Tok::Eof => break,
Tok::Ident(w) if enders.iter().any(|e| w.eq_ignore_ascii_case(e)) => break,
_ => out.push(self.statement()?),
}
}
self.leave();
Ok(out)
}
fn statement(&mut self) -> Result<Stmt, String> {
let line = self.line();
match self.peek().clone() {
Tok::Ident(w) if w.eq_ignore_ascii_case("var") => {
self.at += 1;
let Tok::Ident(name) = self.next() else { return Err(format!("line {line}: expected a name after var")) };
let init = if self.eat_op("=") { Some(self.top_expr()?) } else { None };
Ok(Stmt::Var(name, init))
}
Tok::Ident(w) if w.eq_ignore_ascii_case("if") => {
self.at += 1;
let mut arms = Vec::new();
let cond = self.top_expr()?;
self.expect_kw("then")?;
let body = self.block(&["elseif", "else", "endif"])?;
arms.push((cond, body));
let mut otherwise = None;
loop {
if self.eat_kw("elseif") {
let c = self.top_expr()?;
self.expect_kw("then")?;
let b = self.block(&["elseif", "else", "endif"])?;
arms.push((c, b));
} else if self.eat_kw("else") {
otherwise = Some(self.block(&["endif"])?);
} else {
self.expect_kw("endif")?;
break;
}
}
Ok(Stmt::If(arms, otherwise))
}
Tok::Ident(w) if w.eq_ignore_ascii_case("while") => {
self.at += 1;
let cond = self.top_expr()?;
self.expect_kw("do")?;
let body = self.block(&["endwhile"])?;
self.expect_kw("endwhile")?;
Ok(Stmt::While(cond, body))
}
Tok::Ident(w) if w.eq_ignore_ascii_case("for") => {
self.at += 1;
let Tok::Ident(var) = self.next() else { return Err(format!("line {line}: expected a variable after for")) };
self.expect_op("=")?;
let from = self.top_expr()?;
let up = if self.eat_kw("upto") {
true
} else if self.eat_kw("downto") {
false
} else {
return Err(format!("line {line}: expected upto or downto"));
};
let to = self.top_expr()?;
let step = if self.eat_kw("step") { Some(self.top_expr()?) } else { None };
self.expect_kw("do")?;
let body = self.block(&["endfor"])?;
self.expect_kw("endfor")?;
Ok(Stmt::For { var, from, to, up, step, body })
}
Tok::Ident(w) if w.eq_ignore_ascii_case("foreach") => {
self.at += 1;
let Tok::Ident(var) = self.next() else { return Err(format!("line {line}: expected a variable after foreach")) };
self.expect_kw("in")?;
self.expect_op("(")?;
let mut list = Vec::new();
if !self.is_op(")") {
loop {
list.push(self.top_expr()?);
if !self.eat_op(",") {
break;
}
}
}
self.expect_op(")")?;
self.expect_kw("do")?;
let body = self.block(&["endfor"])?;
self.expect_kw("endfor")?;
Ok(Stmt::Foreach { var, list, body })
}
Tok::Ident(w) if w.eq_ignore_ascii_case("func") => {
self.at += 1;
let Tok::Ident(name) = self.next() else { return Err(format!("line {line}: expected a name after func")) };
self.expect_op("(")?;
let mut params = Vec::new();
if !self.is_op(")") {
loop {
let Tok::Ident(p) = self.next() else { return Err(format!("line {line}: expected a parameter name")) };
params.push(p);
if !self.eat_op(",") {
break;
}
}
}
self.expect_op(")")?;
self.expect_kw("do")?;
let body = self.block(&["endfunc"])?;
self.expect_kw("endfunc")?;
Ok(Stmt::Func { name, f: Rc::new(Func { params, body }) })
}
Tok::Ident(w) if w.eq_ignore_ascii_case("return") => {
self.at += 1;
let v = if matches!(self.peek(), Tok::Newline | Tok::Eof) { None } else { Some(self.top_expr()?) };
Ok(Stmt::Return(v))
}
Tok::Ident(w) if w.eq_ignore_ascii_case("break") => {
self.at += 1;
Ok(Stmt::Break)
}
Tok::Ident(w) if w.eq_ignore_ascii_case("continue") => {
self.at += 1;
Ok(Stmt::Continue)
}
Tok::Ident(w) if w.eq_ignore_ascii_case("exit") => {
self.at += 1;
Ok(Stmt::Exit)
}
Tok::Ident(w) if w.eq_ignore_ascii_case("throw") => {
self.at += 1;
Ok(Stmt::Throw(self.top_expr()?))
}
Tok::Ident(w) if w.eq_ignore_ascii_case("do") => {
// `do … end`: a block as one statement.
self.at += 1;
let body = self.block(&["end"])?;
self.expect_kw("end")?;
Ok(Stmt::If(vec![(Expr::Num(1.0), body)], None))
}
_ => {
let e = self.top_expr()?;
if self.eat_op("=") {
let v = self.top_expr()?;
return Ok(Stmt::Assign(e, v));
}
Ok(Stmt::Expr(e))
}
}
}
/// An expression that starts a tree of its own (a condition, a bound, a statement's
/// expression): its operator chain is counted from zero, whatever came before it.
fn top_expr(&mut self) -> Result<Expr, String> {
self.chain = 0;
self.expr()
}
fn expr(&mut self) -> Result<Expr, String> {
self.enter()?;
let e = self.or_expr();
self.leave();
e
}
fn or_expr(&mut self) -> Result<Expr, String> {
let mut l = self.and_expr()?;
loop {
if self.eat_op("|") || self.eat_kw("or") {
self.link()?;
let r = self.and_expr()?;
l = Expr::Bin("|", Box::new(l), Box::new(r));
} else {
return Ok(l);
}
}
}
fn and_expr(&mut self) -> Result<Expr, String> {
let mut l = self.cmp_expr()?;
loop {
if self.eat_op("&") || self.eat_kw("and") {
self.link()?;
let r = self.cmp_expr()?;
l = Expr::Bin("&", Box::new(l), Box::new(r));
} else {
return Ok(l);
}
}
}
fn cmp_expr(&mut self) -> Result<Expr, String> {
let mut l = self.add_expr()?;
loop {
let op = match self.peek() {
Tok::Op("==") => "==",
Tok::Op("<>") => "<>",
Tok::Op("<=") => "<=",
Tok::Op(">=") => ">=",
Tok::Op("<") => "<",
Tok::Op(">") => ">",
Tok::Ident(w) if w.eq_ignore_ascii_case("eq") => "==",
Tok::Ident(w) if w.eq_ignore_ascii_case("ne") => "<>",
Tok::Ident(w) if w.eq_ignore_ascii_case("le") => "<=",
Tok::Ident(w) if w.eq_ignore_ascii_case("ge") => ">=",
Tok::Ident(w) if w.eq_ignore_ascii_case("lt") => "<",
Tok::Ident(w) if w.eq_ignore_ascii_case("gt") => ">",
_ => return Ok(l),
};
self.at += 1;
self.link()?;
let r = self.add_expr()?;
l = Expr::Bin(op, Box::new(l), Box::new(r));
}
}
fn add_expr(&mut self) -> Result<Expr, String> {
let mut l = self.mul_expr()?;
loop {
let op = match self.peek() {
Tok::Op("+") => "+",
Tok::Op("-") => "-",
_ => return Ok(l),
};
self.at += 1;
self.link()?;
let r = self.mul_expr()?;
l = Expr::Bin(op, Box::new(l), Box::new(r));
}
}
fn mul_expr(&mut self) -> Result<Expr, String> {
let mut l = self.unary()?;
loop {
let op = match self.peek() {
Tok::Op("*") => "*",
Tok::Op("/") => "/",
_ => return Ok(l),
};
self.at += 1;
self.link()?;
let r = self.unary()?;
l = Expr::Bin(op, Box::new(l), Box::new(r));
}
}
fn unary(&mut self) -> Result<Expr, String> {
self.enter()?;
let e = if self.eat_op("-") {
Ok(Expr::Neg(Box::new(self.unary()?)))
} else if self.eat_op("+") {
self.unary()
} else if self.eat_kw("not") || self.eat_kw("!") {
Ok(Expr::Not(Box::new(self.unary()?)))
} else {
self.postfix()
};
self.leave();
e
}
fn postfix(&mut self) -> Result<Expr, String> {
let mut e = self.primary()?;
loop {
if matches!(self.peek(), Tok::Op("." | ".." | "[" | "(")) {
self.link()?;
}
if self.eat_op(".") {
let Tok::Ident(name) = self.next() else { return Err(format!("line {}: expected a name after .", self.line())) };
e = Expr::Member(Box::new(e), name);
} else if self.eat_op("..") {
let Tok::Ident(name) = self.next() else { return Err(format!("line {}: expected a name after ..", self.line())) };
e = Expr::Descend(Box::new(e), name);
} else if self.eat_op("[") {
let sign = match self.peek() {
Tok::Op("-") => Some(-1),
Tok::Op("+") => Some(1),
_ => None,
};
let relative = sign.and_then(|sign| match (self.toks.get(self.at + 1).map(|t| &t.tok), self.toks.get(self.at + 2).map(|t| &t.tok)) {
(Some(Tok::Num(n)), Some(Tok::Op("]"))) if n.is_finite() && *n >= 0.0 && *n < 1e6 => Some(sign * (*n as i64)),
_ => None,
});
let idx = if let Some(k) = relative {
self.at += 2;
Idx::Rel(k)
} else if self.eat_op("*") {
Idx::All
} else {
Idx::Abs(Box::new(self.expr()?))
};
self.expect_op("]")?;
e = Expr::Index(Box::new(e), idx);
} else if self.eat_op("(") {
let mut args = Vec::new();
self.skip_newlines();
if !self.is_op(")") {
loop {
args.push(self.expr()?);
self.skip_newlines();
if !self.eat_op(",") {
break;
}
self.skip_newlines();
}
}
self.expect_op(")")?;
e = Expr::Call(Box::new(e), args);
} else {
return Ok(e);
}
}
}
fn primary(&mut self) -> Result<Expr, String> {
let line = self.line();
match self.next() {
Tok::Num(n) => Ok(Expr::Num(n)),
Tok::Str(s) => Ok(Expr::Str(s)),
Tok::Op("(") => {
self.skip_newlines();
let e = self.expr()?;
self.skip_newlines();
self.expect_op(")")?;
Ok(e)
}
Tok::Ident(w) if w.eq_ignore_ascii_case("null") => Ok(Expr::Null),
Tok::Ident(w) if w.eq_ignore_ascii_case("nan") => Ok(Expr::Num(f64::NAN)),
Tok::Ident(w) if w.eq_ignore_ascii_case("infinity") => Ok(Expr::Num(f64::INFINITY)),
Tok::Ident(w) if w.eq_ignore_ascii_case("true") => Ok(Expr::Num(1.0)),
Tok::Ident(w) if w.eq_ignore_ascii_case("false") => Ok(Expr::Num(0.0)),
Tok::Ident(w) => Ok(Expr::Ident(w)),
t => Err(format!("line {line}: unexpected {}", describe(&t))),
}
}
}
fn describe(t: &Tok) -> String {
match t {
Tok::Num(n) => format!("number {n}"),
Tok::Str(s) => format!("string {s:?}"),
Tok::Ident(s) => s.clone(),
Tok::Op(o) => format!("{o:?}"),
Tok::Newline => "end of line".into(),
Tok::Eof => "end of script".into(),
}
}
pub(super) fn parse(src: &str) -> Result<Vec<Stmt>, String> {
let toks = lex(src)?;
let mut p = Parser { toks, at: 0, depth: 0, chain: 0 };
let body = p.block(&[])?;
match p.peek() {
Tok::Eof => Ok(body),
t => Err(format!("line {}: unexpected {}", p.line(), describe(t))),
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn unary_not_does_not_swallow_following_bang() {
assert_eq!(parse("not !1"), Ok(vec![Stmt::Expr(Expr::Not(Box::new(Expr::Not(Box::new(Expr::Num(1.0))))))]));
assert_eq!(parse("not !flag"), Ok(vec![Stmt::Expr(Expr::Not(Box::new(Expr::Not(Box::new(Expr::Ident("flag".into()))))))]));
assert_eq!(parse("!!1"), Ok(vec![Stmt::Expr(Expr::Not(Box::new(Expr::Not(Box::new(Expr::Num(1.0))))))]));
}
#[test]
fn string_literals_decode_xfa_unicode_escapes_and_keep_other_backslashes() {
assert_eq!(parse(r#""\u0041\u20ac\U00000042\U0001F600""#), Ok(vec![Stmt::Expr(Expr::Str("A\u{20ac}B\u{1F600}".into()))]));
assert_eq!(parse(r#""\uD83D\uDE00""#), Ok(vec![Stmt::Expr(Expr::Str("\u{1F600}".into()))]));
assert_eq!(parse(r#""C:\temp\new\u12""#), Ok(vec![Stmt::Expr(Expr::Str(r"C:\temp\new\u12".into()))]));
}
#[test]
fn number_literals_stop_before_second_dot_for_member_access() {
assert_eq!(parse("1.5.rawValue"), Ok(vec![Stmt::Expr(Expr::Member(Box::new(Expr::Num(1.5)), "rawValue".into()))]));
assert_eq!(parse("1.rawValue"), Ok(vec![Stmt::Expr(Expr::Member(Box::new(Expr::Num(1.0)), "rawValue".into()))]));
assert_eq!(parse("1.e2foo"), Ok(vec![Stmt::Expr(Expr::Member(Box::new(Expr::Num(1.0)), "e2foo".into()))]));
assert_eq!(parse("1.e2"), Ok(vec![Stmt::Expr(Expr::Num(100.0))]));
assert!(parse("1.2.3").is_err(), "a second decimal point followed by digits is a bad number");
}
}