Marqdo-math: limited, documented LaTeX-subset kernel (blueprint section 5). - Exact BigRational arithmetic, structured Float only for irrational results; Int result when exact; bounds on exponents, source size, AST nodes and result bits so hostile input cannot hang or exhaust memory. - Supports numbers, Unicode identifiers, \pi/\e, + - * / ^, \frac, \sqrt, \cdot/\times, braces, parentheses, one '=' equation, and linear solving for a target variable (F=ma solved for F/m/a). - Unsupported constructs are structured errors; the kernel never claims any mathematical proof. Marqdo-foreign: explicit kernels (blueprint section 6). - run/call/detect only; reading a document never spawns a process. - Direct exec of python3/python/node with a temp program file, clear env, private cwd, JSON request envelope on stdin, captured bounded stdout/stderr, wall-clock timeout with kill, typed wire decoding for call, structured ForeignError for spawn/protocol/timeout/oversized output. - Process isolation only: crate docs state this is not a strict OS sandbox.
838 lines
28 KiB
Rust
838 lines
28 KiB
Rust
//! Lexer and recursive-descent parser for the documented math subset.
|
|
//!
|
|
//! The parser is intentionally strict: anything outside the subset becomes a
|
|
//! structured [`MathError`] instead of being skipped, guessed or silently
|
|
//! simplified. It never panics on untrusted input: recursion depth, source size
|
|
//! and numeric literal size are all bounded before the corresponding work
|
|
//! happens.
|
|
|
|
use std::iter::Peekable;
|
|
use std::str::CharIndices;
|
|
|
|
use num_bigint::BigInt;
|
|
use num_rational::Ratio;
|
|
|
|
use crate::ast::{Constant, Expr, Formula, FormulaKind, Rational};
|
|
use crate::error::MathError;
|
|
|
|
/// Maximum accepted source length in bytes. Longer inputs are rejected before
|
|
/// tokenization so that a hostile formula cannot consume unbounded memory.
|
|
pub const MAX_SOURCE_BYTES: usize = 1_000_000;
|
|
|
|
/// Maximum parser recursion depth (parentheses, groups, unary chains, fractions
|
|
/// and roots all consume one level). Deeper input is a parse error instead of a
|
|
/// stack overflow.
|
|
pub const MAX_PARSE_DEPTH: usize = 256;
|
|
|
|
/// Maximum number of AST nodes in one formula. This bounds evaluation,
|
|
/// substitution and rendering recursion depth: a long left-associative chain
|
|
/// such as `1 + 1 + ...` would otherwise build a very deep tree even though the
|
|
/// parser loop itself is iterative. Deeper formulas are rejected with a parse
|
|
/// error instead of risking a stack overflow later.
|
|
pub const MAX_AST_NODES: usize = 512;
|
|
|
|
/// Maximum number of digits in one numeric literal.
|
|
const MAX_LITERAL_DIGITS: usize = 100_000;
|
|
|
|
/// Plain identifiers that name elementary functions in ordinary LaTeX. They are
|
|
/// reported as unsupported instead of being silently reinterpreted as variables
|
|
/// or implicit multiplication.
|
|
const FUNCTION_NAMES: &[&str] = &[
|
|
"sin", "cos", "tan", "cot", "sec", "csc", "arcsin", "arccos", "arctan", "sinh", "cosh", "tanh",
|
|
"log", "ln", "lg", "exp", "abs", "min", "max", "floor", "ceil", "round", "det", "dim", "gcd",
|
|
"lcm", "lim", "sup", "inf", "arg", "Re", "Im",
|
|
];
|
|
|
|
#[derive(Debug, Clone, PartialEq)]
|
|
enum TokenKind {
|
|
Number(Rational),
|
|
Ident(String),
|
|
Constant(Constant),
|
|
Plus,
|
|
Minus,
|
|
Star,
|
|
Slash,
|
|
Caret,
|
|
LParen,
|
|
RParen,
|
|
LBrace,
|
|
RBrace,
|
|
Equals,
|
|
Frac,
|
|
Sqrt,
|
|
Eof,
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
struct Token {
|
|
kind: TokenKind,
|
|
/// Byte offset of the first byte of the token.
|
|
start: usize,
|
|
}
|
|
|
|
impl Token {
|
|
fn describe(&self) -> String {
|
|
match &self.kind {
|
|
TokenKind::Number(_) => "a number".to_string(),
|
|
TokenKind::Ident(name) => format!("identifier `{name}`"),
|
|
TokenKind::Constant(constant) => match constant {
|
|
Constant::Pi => "`\\pi`".to_string(),
|
|
Constant::E => "`\\e`".to_string(),
|
|
},
|
|
TokenKind::Plus => "`+`".to_string(),
|
|
TokenKind::Minus => "`-`".to_string(),
|
|
TokenKind::Star => "`*`".to_string(),
|
|
TokenKind::Slash => "`/`".to_string(),
|
|
TokenKind::Caret => "`^`".to_string(),
|
|
TokenKind::LParen => "`(`".to_string(),
|
|
TokenKind::RParen => "`)`".to_string(),
|
|
TokenKind::LBrace => "`{`".to_string(),
|
|
TokenKind::RBrace => "`}`".to_string(),
|
|
TokenKind::Equals => "`=`".to_string(),
|
|
TokenKind::Frac => "`\\frac`".to_string(),
|
|
TokenKind::Sqrt => "`\\sqrt`".to_string(),
|
|
TokenKind::Eof => "the end of the formula".to_string(),
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Parse `latex` into a [`Formula`].
|
|
///
|
|
/// The supported grammar is documented on the crate root. The returned formula
|
|
/// keeps the original source in [`Formula::source`] and exposes the parsed
|
|
/// [`FormulaKind`] for inspection.
|
|
pub fn parse(latex: &str) -> Result<Formula, MathError> {
|
|
if latex.len() > MAX_SOURCE_BYTES {
|
|
return Err(MathError::parse(
|
|
format!(
|
|
"formula source is {} bytes; the supported limit is {MAX_SOURCE_BYTES} bytes",
|
|
latex.len()
|
|
),
|
|
Some(0),
|
|
));
|
|
}
|
|
let tokens = lex(latex)?;
|
|
Parser {
|
|
tokens,
|
|
position: 0,
|
|
depth: 0,
|
|
nodes: 0,
|
|
}
|
|
.parse_formula(latex)
|
|
}
|
|
|
|
fn lex(source: &str) -> Result<Vec<Token>, MathError> {
|
|
Lexer {
|
|
source,
|
|
chars: source.char_indices().peekable(),
|
|
tokens: Vec::new(),
|
|
}
|
|
.run()
|
|
}
|
|
|
|
struct Lexer<'a> {
|
|
source: &'a str,
|
|
chars: Peekable<CharIndices<'a>>,
|
|
tokens: Vec<Token>,
|
|
}
|
|
|
|
impl<'a> Lexer<'a> {
|
|
fn run(mut self) -> Result<Vec<Token>, MathError> {
|
|
while let Some(&(start, ch)) = self.chars.peek() {
|
|
if ch.is_whitespace() {
|
|
self.chars.next();
|
|
continue;
|
|
}
|
|
let kind = match ch {
|
|
'+' => {
|
|
self.chars.next();
|
|
TokenKind::Plus
|
|
}
|
|
'-' => {
|
|
self.chars.next();
|
|
TokenKind::Minus
|
|
}
|
|
'*' => {
|
|
self.chars.next();
|
|
TokenKind::Star
|
|
}
|
|
'/' => {
|
|
self.chars.next();
|
|
TokenKind::Slash
|
|
}
|
|
'^' => {
|
|
self.chars.next();
|
|
TokenKind::Caret
|
|
}
|
|
'(' => {
|
|
self.chars.next();
|
|
TokenKind::LParen
|
|
}
|
|
')' => {
|
|
self.chars.next();
|
|
TokenKind::RParen
|
|
}
|
|
'{' => {
|
|
self.chars.next();
|
|
TokenKind::LBrace
|
|
}
|
|
'}' => {
|
|
self.chars.next();
|
|
TokenKind::RBrace
|
|
}
|
|
'=' => {
|
|
self.chars.next();
|
|
TokenKind::Equals
|
|
}
|
|
'\\' => self.lex_command()?,
|
|
ch if ch.is_ascii_digit() || ch == '.' => self.lex_number()?,
|
|
ch if is_ident_start(ch) => self.lex_identifier()?,
|
|
other => {
|
|
return Err(MathError::unsupported(
|
|
format!("unsupported character `{other}` in a formula"),
|
|
Some(start),
|
|
));
|
|
}
|
|
};
|
|
self.tokens.push(Token { kind, start });
|
|
}
|
|
self.tokens.push(Token {
|
|
kind: TokenKind::Eof,
|
|
start: self.source.len(),
|
|
});
|
|
Ok(self.tokens)
|
|
}
|
|
|
|
fn lex_identifier(&mut self) -> Result<TokenKind, MathError> {
|
|
let start = self.current_offset();
|
|
let mut text = String::new();
|
|
while let Some(&(_, ch)) = self.chars.peek() {
|
|
if is_ident_continue(ch) {
|
|
text.push(ch);
|
|
self.chars.next();
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
match text.as_str() {
|
|
"pi" => Ok(TokenKind::Constant(Constant::Pi)),
|
|
"e" => Ok(TokenKind::Constant(Constant::E)),
|
|
_ if FUNCTION_NAMES.contains(&text.as_str()) => Err(MathError::unsupported(
|
|
format!(
|
|
"function `{text}` is not supported; the native math subset has no function calls"
|
|
),
|
|
Some(start),
|
|
)),
|
|
_ => Ok(TokenKind::Ident(text)),
|
|
}
|
|
}
|
|
|
|
/// Byte offset of the next unconsumed character (or the source end).
|
|
fn current_offset(&mut self) -> usize {
|
|
match self.chars.peek() {
|
|
Some(&(offset, _)) => offset,
|
|
None => self.source.len(),
|
|
}
|
|
}
|
|
|
|
fn lex_number(&mut self) -> Result<TokenKind, MathError> {
|
|
let start = self.current_offset();
|
|
let mut integer_digits = String::new();
|
|
while let Some(&(_, ch)) = self.chars.peek() {
|
|
if ch.is_ascii_digit() {
|
|
integer_digits.push(ch);
|
|
self.chars.next();
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
|
|
let mut fraction_digits = String::new();
|
|
if matches!(self.chars.peek(), Some(&(_, '.'))) {
|
|
self.chars.next();
|
|
while let Some(&(_, ch)) = self.chars.peek() {
|
|
if ch.is_ascii_digit() {
|
|
fraction_digits.push(ch);
|
|
self.chars.next();
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
if fraction_digits.is_empty() {
|
|
return Err(MathError::parse(
|
|
"malformed decimal literal: expected digits after `.`",
|
|
Some(start),
|
|
));
|
|
}
|
|
}
|
|
|
|
if integer_digits.is_empty() && fraction_digits.is_empty() {
|
|
return Err(MathError::parse("malformed numeric literal", Some(start)));
|
|
}
|
|
if integer_digits.len() + fraction_digits.len() > MAX_LITERAL_DIGITS {
|
|
return Err(MathError::parse(
|
|
format!(
|
|
"numeric literal has more than {MAX_LITERAL_DIGITS} digits, which is outside the supported resource bound"
|
|
),
|
|
Some(start),
|
|
));
|
|
}
|
|
|
|
// Reject scientific notation (`1e3`) explicitly: it is outside the
|
|
// subset and would otherwise parse as `1 * e3`.
|
|
if matches!(self.chars.peek(), Some(&(_, 'e' | 'E')))
|
|
&& self.number_is_followed_by_exponent()
|
|
{
|
|
return Err(MathError::parse(
|
|
"scientific notation is not supported; write an explicit product such as `2 * 10 ^ 3`",
|
|
Some(start),
|
|
));
|
|
}
|
|
|
|
let integer_text = if integer_digits.is_empty() {
|
|
"0"
|
|
} else {
|
|
&integer_digits
|
|
};
|
|
let numerator = parse_bigint(integer_text, start)?;
|
|
if fraction_digits.is_empty() {
|
|
return Ok(TokenKind::Number(Ratio::from_integer(numerator)));
|
|
}
|
|
let mut all_digits = String::with_capacity(integer_digits.len() + fraction_digits.len());
|
|
all_digits.push_str(if integer_digits.is_empty() {
|
|
"0"
|
|
} else {
|
|
&integer_digits
|
|
});
|
|
all_digits.push_str(&fraction_digits);
|
|
let numerator = parse_bigint(&all_digits, start)?;
|
|
let denominator = BigInt::from(10_u32).pow(fraction_digits.len() as u32);
|
|
Ok(TokenKind::Number(Ratio::new(numerator, denominator)))
|
|
}
|
|
|
|
/// Look past the current `e`/`E` to decide whether it introduces an
|
|
/// exponent (`1e3`, `1e-3`) rather than the Euler constant (`2e`).
|
|
fn number_is_followed_by_exponent(&self) -> bool {
|
|
let mut chars = self.chars.clone();
|
|
let _ = chars.next(); // the 'e' / 'E'
|
|
match chars.next().map(|(_, ch)| ch) {
|
|
Some(ch) if ch.is_ascii_digit() => true,
|
|
Some('+' | '-') => {
|
|
matches!(chars.next().map(|(_, ch)| ch), Some(ch) if ch.is_ascii_digit())
|
|
}
|
|
_ => false,
|
|
}
|
|
}
|
|
|
|
fn lex_command(&mut self) -> Result<TokenKind, MathError> {
|
|
let start = self.current_offset();
|
|
self.chars.next(); // consume the backslash
|
|
let mut name = String::new();
|
|
while let Some(&(_, ch)) = self.chars.peek() {
|
|
if ch.is_ascii_alphabetic() {
|
|
name.push(ch);
|
|
self.chars.next();
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
match name.as_str() {
|
|
"pi" => Ok(TokenKind::Constant(Constant::Pi)),
|
|
"e" => Ok(TokenKind::Constant(Constant::E)),
|
|
"cdot" | "times" => Ok(TokenKind::Star),
|
|
"frac" => Ok(TokenKind::Frac),
|
|
"sqrt" => Ok(TokenKind::Sqrt),
|
|
"left" => self.lex_left_right(start, '('),
|
|
"right" => self.lex_left_right(start, ')'),
|
|
"" => Err(MathError::unsupported(
|
|
"unsupported LaTeX control symbol; only alphabetic commands such as `\\pi` are supported",
|
|
Some(start),
|
|
)),
|
|
other => Err(MathError::unsupported(
|
|
format!(
|
|
"unsupported LaTeX command `\\{other}`; the native math subset only supports `\\frac`, `\\sqrt`, `\\cdot`, `\\times`, `\\left(`, `\\right)`, `\\pi` and `\\e`"
|
|
),
|
|
Some(start),
|
|
)),
|
|
}
|
|
}
|
|
|
|
fn lex_left_right(&mut self, start: usize, expected: char) -> Result<TokenKind, MathError> {
|
|
while let Some(&(_, ch)) = self.chars.peek() {
|
|
if ch.is_whitespace() {
|
|
self.chars.next();
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
match self.chars.next() {
|
|
Some((_, ch)) if ch == expected => Ok(if expected == '(' {
|
|
TokenKind::LParen
|
|
} else {
|
|
TokenKind::RParen
|
|
}),
|
|
_ => Err(MathError::unsupported(
|
|
format!(
|
|
"only the parenthesis forms `\\left(` and `\\right)` are supported, not `\\{}` followed by another delimiter",
|
|
if expected == '(' { "left" } else { "right" }
|
|
),
|
|
Some(start),
|
|
)),
|
|
}
|
|
}
|
|
}
|
|
|
|
fn parse_bigint(digits: &str, position: usize) -> Result<BigInt, MathError> {
|
|
digits
|
|
.parse::<BigInt>()
|
|
.map_err(|_| MathError::parse("numeric literal is too large to represent", Some(position)))
|
|
}
|
|
|
|
fn is_ident_start(ch: char) -> bool {
|
|
ch.is_alphabetic() || ch == '_'
|
|
}
|
|
|
|
fn is_ident_continue(ch: char) -> bool {
|
|
ch.is_alphanumeric() || ch == '_'
|
|
}
|
|
|
|
struct Parser {
|
|
tokens: Vec<Token>,
|
|
position: usize,
|
|
depth: usize,
|
|
nodes: usize,
|
|
}
|
|
|
|
impl Parser {
|
|
fn peek(&self) -> &Token {
|
|
// The lexer always appends an Eof token, so indexing is in bounds.
|
|
&self.tokens[self.position.min(self.tokens.len() - 1)]
|
|
}
|
|
|
|
fn advance(&mut self) -> Token {
|
|
let token = self.peek().clone();
|
|
if self.position < self.tokens.len() - 1 {
|
|
self.position += 1;
|
|
}
|
|
token
|
|
}
|
|
|
|
/// Record one constructed AST node, enforcing [`MAX_AST_NODES`].
|
|
fn node(&mut self, expr: Expr) -> Result<Expr, MathError> {
|
|
self.nodes += 1;
|
|
if self.nodes > MAX_AST_NODES {
|
|
return Err(MathError::parse(
|
|
format!(
|
|
"formula contains more than the supported limit of {MAX_AST_NODES} syntax nodes"
|
|
),
|
|
Some(self.peek().start),
|
|
));
|
|
}
|
|
Ok(expr)
|
|
}
|
|
|
|
fn enter_depth(&mut self) -> Result<(), MathError> {
|
|
self.depth += 1;
|
|
if self.depth > MAX_PARSE_DEPTH {
|
|
return Err(MathError::parse(
|
|
format!("formula nesting exceeds the supported limit of {MAX_PARSE_DEPTH} levels"),
|
|
Some(self.peek().start),
|
|
));
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
fn parse_formula(mut self, source: &str) -> Result<Formula, MathError> {
|
|
if matches!(self.peek().kind, TokenKind::Eof) {
|
|
return Err(MathError::parse("empty formula", Some(0)));
|
|
}
|
|
let left = self.parse_expr()?;
|
|
let kind = if matches!(self.peek().kind, TokenKind::Equals) {
|
|
let equals = self.advance();
|
|
if matches!(self.peek().kind, TokenKind::Eof) {
|
|
return Err(MathError::parse(
|
|
"expected a right-hand side after `=`",
|
|
Some(equals.start + 1),
|
|
));
|
|
}
|
|
let right = self.parse_expr()?;
|
|
if matches!(self.peek().kind, TokenKind::Equals) {
|
|
return Err(MathError::parse(
|
|
"more than one `=` in a formula; at most one equation is supported and `=` is never assignment",
|
|
Some(self.peek().start),
|
|
));
|
|
}
|
|
FormulaKind::Equation { left, right }
|
|
} else {
|
|
FormulaKind::Expression(left)
|
|
};
|
|
if !matches!(self.peek().kind, TokenKind::Eof) {
|
|
return Err(MathError::parse(
|
|
format!("unexpected {} after the formula", self.peek().describe()),
|
|
Some(self.peek().start),
|
|
));
|
|
}
|
|
Ok(Formula {
|
|
source: source.to_string(),
|
|
kind,
|
|
})
|
|
}
|
|
|
|
fn parse_expr(&mut self) -> Result<Expr, MathError> {
|
|
let mut left = self.parse_term()?;
|
|
loop {
|
|
match self.peek().kind {
|
|
TokenKind::Plus => {
|
|
self.advance();
|
|
let right = self.parse_term()?;
|
|
left = self.node(Expr::Add(Box::new(left), Box::new(right)))?;
|
|
}
|
|
TokenKind::Minus => {
|
|
self.advance();
|
|
let right = self.parse_term()?;
|
|
left = self.node(Expr::Sub(Box::new(left), Box::new(right)))?;
|
|
}
|
|
_ => return Ok(left),
|
|
}
|
|
}
|
|
}
|
|
|
|
fn parse_term(&mut self) -> Result<Expr, MathError> {
|
|
let mut left = self.parse_unary()?;
|
|
loop {
|
|
if matches!(self.peek().kind, TokenKind::Star) {
|
|
self.advance();
|
|
let right = self.parse_unary()?;
|
|
left = self.node(Expr::Mul(Box::new(left), Box::new(right)))?;
|
|
} else if matches!(self.peek().kind, TokenKind::Slash) {
|
|
self.advance();
|
|
let right = self.parse_unary()?;
|
|
left = self.node(Expr::Div(Box::new(left), Box::new(right)))?;
|
|
} else if can_start_primary(&self.peek().kind) {
|
|
if matches!(left, Expr::Number(_))
|
|
&& matches!(self.peek().kind, TokenKind::Number(_))
|
|
{
|
|
return Err(MathError::parse(
|
|
"two adjacent number literals are ambiguous; insert an operator",
|
|
Some(self.peek().start),
|
|
));
|
|
}
|
|
// Implicit multiplication: `2x`, `\pi r^2`, `m a`.
|
|
let right = self.parse_unary()?;
|
|
left = self.node(Expr::Mul(Box::new(left), Box::new(right)))?;
|
|
} else {
|
|
return Ok(left);
|
|
}
|
|
}
|
|
}
|
|
|
|
fn parse_unary(&mut self) -> Result<Expr, MathError> {
|
|
self.enter_depth()?;
|
|
let result = self.parse_unary_inner();
|
|
self.depth -= 1;
|
|
result
|
|
}
|
|
|
|
fn parse_unary_inner(&mut self) -> Result<Expr, MathError> {
|
|
match self.peek().kind {
|
|
TokenKind::Minus => {
|
|
self.advance();
|
|
let inner = self.parse_unary()?;
|
|
self.node(Expr::Neg(Box::new(inner)))
|
|
}
|
|
TokenKind::Plus => {
|
|
self.advance();
|
|
self.parse_unary()
|
|
}
|
|
_ => self.parse_power(),
|
|
}
|
|
}
|
|
|
|
fn parse_power(&mut self) -> Result<Expr, MathError> {
|
|
let base = self.parse_primary()?;
|
|
if matches!(self.peek().kind, TokenKind::Caret) {
|
|
self.advance();
|
|
let exponent = self.parse_unary()?;
|
|
return self.node(Expr::Pow(Box::new(base), Box::new(exponent)));
|
|
}
|
|
Ok(base)
|
|
}
|
|
|
|
fn parse_primary(&mut self) -> Result<Expr, MathError> {
|
|
self.enter_depth()?;
|
|
let result = self.parse_primary_inner();
|
|
self.depth -= 1;
|
|
result
|
|
}
|
|
|
|
fn parse_primary_inner(&mut self) -> Result<Expr, MathError> {
|
|
let token = self.peek().clone();
|
|
match token.kind {
|
|
TokenKind::Number(value) => {
|
|
self.advance();
|
|
self.node(Expr::Number(value))
|
|
}
|
|
TokenKind::Ident(name) => {
|
|
self.advance();
|
|
self.node(Expr::Variable(name))
|
|
}
|
|
TokenKind::Constant(constant) => {
|
|
self.advance();
|
|
self.node(Expr::Constant(constant))
|
|
}
|
|
TokenKind::LParen => {
|
|
self.advance();
|
|
let inner = self.parse_expr()?;
|
|
self.expect_closing(TokenKind::RParen, "`)`", token.start)?;
|
|
Ok(inner)
|
|
}
|
|
TokenKind::LBrace => {
|
|
self.advance();
|
|
let inner = self.parse_expr()?;
|
|
self.expect_closing(TokenKind::RBrace, "`}`", token.start)?;
|
|
Ok(inner)
|
|
}
|
|
TokenKind::Frac => {
|
|
self.advance();
|
|
let numerator = self.parse_braced_argument("\\frac")?;
|
|
let denominator = self.parse_braced_argument("\\frac")?;
|
|
self.node(Expr::Div(Box::new(numerator), Box::new(denominator)))
|
|
}
|
|
TokenKind::Sqrt => {
|
|
self.advance();
|
|
let inner = self.parse_braced_argument("\\sqrt")?;
|
|
self.node(Expr::Sqrt(Box::new(inner)))
|
|
}
|
|
TokenKind::Eof => Err(MathError::parse(
|
|
"expected an expression, found the end of the formula",
|
|
Some(token.start),
|
|
)),
|
|
other => Err(MathError::parse(
|
|
format!(
|
|
"expected an expression, found {}",
|
|
Token {
|
|
kind: other,
|
|
start: token.start
|
|
}
|
|
.describe()
|
|
),
|
|
Some(token.start),
|
|
)),
|
|
}
|
|
}
|
|
|
|
fn parse_braced_argument(&mut self, command: &str) -> Result<Expr, MathError> {
|
|
if !matches!(self.peek().kind, TokenKind::LBrace) {
|
|
return Err(MathError::parse(
|
|
format!("`{command}` requires a braced argument such as `{command}{{x}}`"),
|
|
Some(self.peek().start),
|
|
));
|
|
}
|
|
let open = self.advance();
|
|
let inner = self.parse_expr()?;
|
|
self.expect_closing(TokenKind::RBrace, "`}`", open.start)?;
|
|
Ok(inner)
|
|
}
|
|
|
|
fn expect_closing(
|
|
&mut self,
|
|
expected: TokenKind,
|
|
description: &str,
|
|
open_position: usize,
|
|
) -> Result<(), MathError> {
|
|
if std::mem::discriminant(&self.peek().kind) == std::mem::discriminant(&expected) {
|
|
self.advance();
|
|
Ok(())
|
|
} else {
|
|
Err(MathError::parse(
|
|
format!(
|
|
"expected {description} to close the group opened at byte {open_position}, found {}",
|
|
self.peek().describe()
|
|
),
|
|
Some(self.peek().start),
|
|
))
|
|
}
|
|
}
|
|
}
|
|
|
|
fn can_start_primary(kind: &TokenKind) -> bool {
|
|
matches!(
|
|
kind,
|
|
TokenKind::Number(_)
|
|
| TokenKind::Ident(_)
|
|
| TokenKind::Constant(_)
|
|
| TokenKind::LParen
|
|
| TokenKind::LBrace
|
|
| TokenKind::Frac
|
|
| TokenKind::Sqrt
|
|
)
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
fn parse_ok(source: &str) -> Formula {
|
|
parse(source).unwrap_or_else(|err| panic!("expected {source:?} to parse: {err}"))
|
|
}
|
|
|
|
fn parse_err(source: &str) -> MathError {
|
|
parse(source).unwrap_err()
|
|
}
|
|
|
|
#[test]
|
|
fn precedence_matches_standard_arithmetic() {
|
|
let formula = parse_ok("1 + 2 * 3");
|
|
assert_eq!(
|
|
formula.kind,
|
|
FormulaKind::Expression(Expr::Add(
|
|
Box::new(Expr::Number(Ratio::from_integer(BigInt::from(1)))),
|
|
Box::new(Expr::Mul(
|
|
Box::new(Expr::Number(Ratio::from_integer(BigInt::from(2)))),
|
|
Box::new(Expr::Number(Ratio::from_integer(BigInt::from(3)))),
|
|
)),
|
|
))
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn unary_minus_binds_looser_than_power() {
|
|
// -2^2 is -(2^2), not (-2)^2.
|
|
let formula = parse_ok("-2^2");
|
|
assert!(matches!(
|
|
formula.kind,
|
|
FormulaKind::Expression(Expr::Neg(_))
|
|
));
|
|
}
|
|
|
|
#[test]
|
|
fn power_is_right_associative() {
|
|
let formula = parse_ok("2^3^2");
|
|
let FormulaKind::Expression(Expr::Pow(_, exponent)) = formula.kind else {
|
|
panic!("expected a power");
|
|
};
|
|
assert!(matches!(*exponent, Expr::Pow(_, _)));
|
|
}
|
|
|
|
#[test]
|
|
fn implicit_multiplication_joins_adjacent_factors() {
|
|
let formula = parse_ok("\\pi r^2");
|
|
let FormulaKind::Expression(Expr::Mul(left, right)) = formula.kind else {
|
|
panic!("expected multiplication");
|
|
};
|
|
assert!(matches!(*left, Expr::Constant(Constant::Pi)));
|
|
assert!(matches!(*right, Expr::Pow(_, _)));
|
|
|
|
// `F = m a` is an equation whose right side is a product.
|
|
let formula = parse_ok("F = m a");
|
|
let FormulaKind::Equation { right, .. } = formula.kind else {
|
|
panic!("expected an equation");
|
|
};
|
|
assert!(matches!(right, Expr::Mul(_, _)));
|
|
}
|
|
|
|
#[test]
|
|
fn left_and_right_parentheses_are_accepted() {
|
|
assert_eq!(
|
|
parse_ok("\\left(1 + 2\\right) * 3").kind,
|
|
parse_ok("(1 + 2) * 3").kind
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn frac_and_sqrt_become_dedicated_nodes() {
|
|
let formula = parse_ok("\\frac{1}{2} + \\sqrt{4}");
|
|
let FormulaKind::Expression(Expr::Add(left, right)) = formula.kind else {
|
|
panic!("expected addition");
|
|
};
|
|
assert!(matches!(*left, Expr::Div(_, _)));
|
|
assert!(matches!(*right, Expr::Sqrt(_)));
|
|
}
|
|
|
|
#[test]
|
|
fn single_equals_is_an_equation() {
|
|
let formula = parse_ok("A = \\pi r^2");
|
|
assert!(formula.is_equation());
|
|
assert_eq!(formula.variables().len(), 2);
|
|
}
|
|
|
|
#[test]
|
|
fn more_than_one_equals_is_a_parse_error() {
|
|
let err = parse_err("a = b = c");
|
|
assert_eq!(err.kind, crate::error::MathErrorKind::Parse);
|
|
assert!(err.message.contains("more than one"));
|
|
}
|
|
|
|
#[test]
|
|
fn empty_and_malformed_input_is_a_parse_error() {
|
|
assert_eq!(parse_err("").kind, crate::error::MathErrorKind::Parse);
|
|
for source in ["1 +", "(1 + 2", "\\frac{1}{2", "{1 + 2", "1 + 2)", "= 3"] {
|
|
let err = parse_err(source);
|
|
assert_eq!(
|
|
err.kind,
|
|
crate::error::MathErrorKind::Parse,
|
|
"source {source:?}"
|
|
);
|
|
assert!(err.position.is_some(), "source {source:?}");
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn unsupported_commands_are_structured() {
|
|
for source in [
|
|
"\\begin{matrix}1&2\\end{matrix}",
|
|
"\\int_0^1 x dx",
|
|
"\\sin(x)",
|
|
"\\sum_{i=1}^n i",
|
|
"sin(1)",
|
|
] {
|
|
let err = parse_err(source);
|
|
assert_eq!(
|
|
err.kind,
|
|
crate::error::MathErrorKind::Unsupported,
|
|
"source {source:?}"
|
|
);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn unknown_characters_are_structured() {
|
|
let err = parse_err("1, 2");
|
|
assert_eq!(err.kind, crate::error::MathErrorKind::Unsupported);
|
|
assert!(err.message.contains("unsupported character"));
|
|
}
|
|
|
|
#[test]
|
|
fn deep_nesting_is_rejected_without_stack_overflow() {
|
|
let source = format!("{}1{}", "(".repeat(10_000), ")".repeat(10_000));
|
|
let err = parse_err(&source);
|
|
assert_eq!(err.kind, crate::error::MathErrorKind::Parse);
|
|
assert!(err.message.contains("nesting"));
|
|
}
|
|
|
|
#[test]
|
|
fn excessive_node_count_is_rejected() {
|
|
// A long left-associative chain is cheap to parse iteratively but would
|
|
// build a very deep tree; the node budget rejects it first.
|
|
let source = format!("{}1", "1 + ".repeat(MAX_AST_NODES));
|
|
let err = parse_err(&source);
|
|
assert_eq!(err.kind, crate::error::MathErrorKind::Parse);
|
|
assert!(err.message.contains("syntax nodes"), "{}", err.message);
|
|
}
|
|
|
|
#[test]
|
|
fn very_long_chain_is_rejected_without_stack_overflow() {
|
|
let source = format!("{}1", "1 + ".repeat(200_000));
|
|
let err = parse_err(&source);
|
|
assert_eq!(err.kind, crate::error::MathErrorKind::Parse);
|
|
}
|
|
|
|
#[test]
|
|
fn numeric_literal_bounds_are_enforced() {
|
|
let source = "9".repeat(MAX_LITERAL_DIGITS + 1);
|
|
let err = parse_err(&source);
|
|
assert_eq!(err.kind, crate::error::MathErrorKind::Parse);
|
|
assert!(err.message.contains("digits"));
|
|
}
|
|
}
|