Files
solidcraft/crates/doc/src/expr.rs
T
ivisafandClaude Opus 5.5 3bcf77ee32 Expressions: a number and its unit are one value (10 mm / 2 mm is 5) (#6331)
* Expressions: a number and its unit are one value (10 mm / 2 mm is 5)

A unit written after a number was multiplied in at the precedence of `*` and
`/`, so `10 mm / 2 mm` was (10 mm / 2) mm = 5 mm² and `90 deg / 1 rad` a value
in angle², reported as a unit error. The number now takes the unit after it
before `*` and `/` apply; a fraction of numbers before a unit stays one value
(`1/2 in` is half an inch), and an exponent stays a plain number (`2^3 mm`).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* Expressions: after a division, a fraction before a unit only when closed up

`width / 10 / 2 mm` read the `10 / 2 mm` as the fraction 5 mm and gave
width / (5 mm) = 8 instead of (width / 10) / 2 mm = 2. After a `/` the
fraction rule now needs the fraction written without spaces (`1 in / 1/2 in`
is still 2); elsewhere `1/2 in` and `10 / 2 mm` are unchanged.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-26 12:24:34 +00:00

1514 lines
62 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//! Parameter expressions: `2 * width + 5 mm`, `angle / 2`, `sqrt(a^2 + b^2)`, `atan2(h; w)`.
//!
//! Values carry a simple dimension (powers of length and angle). Lengths are millimetres and
//! angles radians internally. A unit-less number added to a dimensioned value takes that value's
//! unit: the parameter's own unit when it has one (`width + 5` adds 5 in for an inch
//! parameter), else millimetres and degrees. A unit-less final result takes the expected unit
//! (`2` for an inch parameter is 2 in). Trigonometric functions take an angle; a unit-less
//! argument is read as degrees.
use std::collections::BTreeMap;
use crate::DocError;
const MAX_LEN: usize = 4096;
const MAX_DEPTH: usize = 64;
const MAX_ARGS: usize = 64;
/// An expression a feature holds, as the user wrote it (`2 * width + 5 mm`): kept as text and
/// evaluated with the design's parameters. It is saved as a plain string, and reads as one
/// (`&expr` is a `&str`); it changes only as a whole (`*expr = new.into()`).
#[derive(Clone, Debug, Default, PartialEq, Eq, Hash, PartialOrd, Ord, serde::Serialize, serde::Deserialize)]
#[serde(transparent)]
pub struct Expr(String);
impl Expr {
pub fn new(s: impl Into<String>) -> Self {
Expr(s.into())
}
pub fn as_str(&self) -> &str {
&self.0
}
pub fn into_string(self) -> String {
self.0
}
}
impl std::ops::Deref for Expr {
type Target = str;
fn deref(&self) -> &str {
&self.0
}
}
impl AsRef<str> for Expr {
fn as_ref(&self) -> &str {
&self.0
}
}
impl From<String> for Expr {
fn from(s: String) -> Self {
Expr(s)
}
}
impl From<&str> for Expr {
fn from(s: &str) -> Self {
Expr(s.to_string())
}
}
impl From<&String> for Expr {
fn from(s: &String) -> Self {
Expr(s.clone())
}
}
impl From<Expr> for String {
fn from(e: Expr) -> Self {
e.0
}
}
impl std::fmt::Display for Expr {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(&self.0)
}
}
impl PartialEq<str> for Expr {
fn eq(&self, other: &str) -> bool {
self.0 == other
}
}
impl PartialEq<&str> for Expr {
fn eq(&self, other: &&str) -> bool {
self.0 == *other
}
}
impl PartialEq<Expr> for String {
fn eq(&self, other: &Expr) -> bool {
*self == other.0
}
}
impl PartialEq<String> for Expr {
fn eq(&self, other: &String) -> bool {
&self.0 == other
}
}
/// What an expression must evaluate to.
#[derive(Clone, Copy, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum Kind {
Length,
Angle,
Unitless,
}
impl Kind {
pub fn from_unit(u: &str) -> Kind {
unit_info(u).map(|(k, _)| k).unwrap_or(Kind::Length)
}
/// The unit a new parameter of this kind gets (`mm`, `deg` or none).
pub fn default_unit(self) -> &'static str {
match self {
Kind::Length => "mm",
Kind::Angle => "deg",
Kind::Unitless => "",
}
}
}
/// Units a parameter or an expression may use: name, kind and size (mm or radians).
pub const UNITS: [(&str, Kind, f64); 14] = [
("mm", Kind::Length, 1.0),
("cm", Kind::Length, 10.0),
("m", Kind::Length, 1000.0),
("um", Kind::Length, 0.001),
("µm", Kind::Length, 0.001),
("in", Kind::Length, 25.4),
("inch", Kind::Length, 25.4),
("ft", Kind::Length, 304.8),
("yd", Kind::Length, 914.4),
("km", Kind::Length, 1_000_000.0),
("mil", Kind::Length, 0.0254),
("nm", Kind::Length, 1e-6),
("deg", Kind::Angle, std::f64::consts::PI / 180.0),
("rad", Kind::Angle, 1.0),
];
/// Functions an expression may call (name, signature) — for autocomplete and help.
pub const FUNCTIONS: [(&str, &str); 23] = [
("sin", "sin(angle)"),
("cos", "cos(angle)"),
("tan", "tan(angle)"),
("asin", "asin(x) → angle"),
("acos", "acos(x) → angle"),
("atan", "atan(x) → angle"),
("atan2", "atan2(y, x) → angle"),
("sqrt", "sqrt(x)"),
("abs", "abs(x)"),
("min", "min(a, b, …)"),
("max", "max(a, b, …)"),
("floor", "floor(x)"),
("ceil", "ceil(x)"),
("round", "round(x)"),
("exp", "exp(x)"),
("ln", "ln(x)"),
("log", "log(x) (base 10)"),
("log10", "log10(x)"),
("sign", "sign(x)"),
("hypot", "hypot(a, b)"),
("pow", "pow(x, n)"),
("trunc", "trunc(x)"),
("mod", "mod(a, b)"),
];
/// Constants an expression may use.
pub const CONSTANTS: [&str; 2] = ["pi", "PI"];
/// Kind and size (mm or radians per unit) of a parameter's unit; empty means unit-less.
pub fn unit_info(u: &str) -> Option<(Kind, f64)> {
match u.trim() {
"" | "none" | "unitless" => Some((Kind::Unitless, 1.0)),
"°" | "degree" | "degrees" => Some((Kind::Angle, std::f64::consts::PI / 180.0)),
t => UNITS.iter().find(|(n, _, _)| *n == t).map(|(_, k, s)| (*k, *s)),
}
}
/// How unit-less numbers are read: millimetres / degrees by default.
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct Defaults {
/// Millimetres per unit-less length number.
pub len: f64,
/// Radians per unit-less angle number.
pub ang: f64,
}
impl Default for Defaults {
fn default() -> Self {
Defaults { len: 1.0, ang: std::f64::consts::PI / 180.0 }
}
}
impl Defaults {
/// Defaults for a parameter with this unit (`in` reads bare numbers as inches); the
/// document's length unit covers the other kind.
pub fn for_unit(unit: &str, doc_len: f64) -> Defaults {
let mut d = Defaults { len: doc_len, ..Defaults::default() };
match unit_info(unit) {
Some((Kind::Length, s)) => d.len = s,
Some((Kind::Angle, s)) => d.ang = s,
_ => {}
}
d
}
}
/// A dimensioned value.
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct Value {
pub v: f64,
pub len: i8,
pub ang: i8,
}
impl Value {
pub fn num(v: f64) -> Value {
Value { v, len: 0, ang: 0 }
}
pub fn length(mm: f64) -> Value {
Value { v: mm, len: 1, ang: 0 }
}
pub fn angle(rad: f64) -> Value {
Value { v: rad, len: 0, ang: 1 }
}
pub fn unitless(&self) -> bool {
self.len == 0 && self.ang == 0
}
/// The value's kind, if it is a plain length, angle or number.
pub fn kind(&self) -> Option<Kind> {
match (self.len, self.ang) {
(0, 0) => Some(Kind::Unitless),
(1, 0) => Some(Kind::Length),
(0, 1) => Some(Kind::Angle),
_ => None,
}
}
/// Convert to the expected kind (mm or radians); unit-less numbers are mm / degrees.
pub fn to_kind(self, k: Kind) -> Result<f64, DocError> {
self.to_kind_in(k, Defaults::default())
}
/// Convert to the expected kind, reading a unit-less result in the given defaults.
pub fn to_kind_in(self, k: Kind, d: Defaults) -> Result<f64, DocError> {
let out = match k {
Kind::Length if self.len == 1 && self.ang == 0 => self.v,
Kind::Length if self.unitless() => self.v * d.len,
Kind::Angle if self.ang == 1 && self.len == 0 => self.v,
Kind::Angle if self.unitless() => self.v * d.ang,
Kind::Unitless if self.unitless() => self.v,
_ => {
let hint = if k == Kind::Unitless && self.len == 1 && self.ang == 0 {
" (a count needs a unit-less value: divide by a length, e.g. `floor(L / (210 mm))`)"
} else {
""
};
return Err(DocError::Expr(format!("expected {}, got {}{hint}", kind_word(k), self.describe())));
}
};
if out.is_finite() { Ok(out) } else { Err(DocError::Expr("result is not a finite number".into())) }
}
/// "a length", "an angle", "length²"…
pub fn describe(&self) -> String {
match self.kind() {
Some(k) => kind_word(k).to_string(),
None => {
let pow = |name: &str, n: i8| match n {
0 => String::new(),
1 => name.to_string(),
_ => format!("{name}^{n}"),
};
let parts: Vec<String> = [pow("length", self.len), pow("angle", self.ang)].into_iter().filter(|s| !s.is_empty()).collect();
format!("a value in {}", parts.join("·"))
}
}
}
}
fn kind_word(k: Kind) -> &'static str {
match k {
Kind::Length => "a length",
Kind::Angle => "an angle",
Kind::Unitless => "a unit-less number",
}
}
/// A number in the given unit (e.g. 50.8 mm in `in` is 2); unknown units leave it as is.
pub fn value_in_unit(v: Value, unit: &str) -> f64 {
match (unit_info(unit), v.kind()) {
(Some((Kind::Length, s)), Some(Kind::Length)) | (Some((Kind::Angle, s)), Some(Kind::Angle)) if s != 0.0 => v.v / s,
_ => v.v,
}
}
fn unit(name: &str) -> Option<Value> {
UNITS.iter().find(|(n, _, _)| *n == name).map(|(_, k, s)| match k {
Kind::Angle => Value::angle(*s),
_ => Value::length(*s),
})
}
fn is_constant(id: &str) -> bool {
CONSTANTS.contains(&id)
}
/// What kind of word the expression language reserves `name` as: `unit`, `constant` or
/// `function` (None: free for a parameter).
pub fn reserved_kind(name: &str) -> Option<&'static str> {
if unit(name).is_some() {
Some("unit")
} else if is_constant(name) {
Some("constant")
} else if FUNCTIONS.iter().any(|(f, _)| *f == name) {
Some("function")
} else {
None
}
}
/// Is this a name the expression language reserves (unit, constant or function)?
pub fn is_reserved(name: &str) -> bool {
reserved_kind(name).is_some()
}
#[derive(Clone, Debug, PartialEq)]
enum Tok {
Num(f64),
Id(String),
Op(char),
}
/// Tokens with their byte ranges in the source.
fn lex_spans(s: &str) -> Result<Vec<(Tok, usize, usize)>, DocError> {
if s.len() > MAX_LEN {
return Err(DocError::Expr("expression too long".into()));
}
let cs: Vec<(usize, char)> = s.char_indices().collect();
let at = |i: usize| cs.get(i).map(|x| x.0).unwrap_or(s.len());
let mut i = 0;
let mut out = Vec::new();
// Parentheses open at this point: a comma outside them can only be a decimal comma.
let mut depth = 0usize;
// A single leading `=` marks the text as a formula (`=d3`, #4681) and is not part of it.
if let Some(k) = cs.iter().position(|(_, c)| !c.is_whitespace())
&& cs.get(k).is_some_and(|(_, c)| *c == '=')
{
i = k + 1;
}
while let Some(&(_, c)) = cs.get(i) {
if c.is_whitespace() {
i += 1;
} else if c.is_ascii_digit() || c == '.' || leading_decimal_comma(&cs, i, depth, out.last()) {
let st = i;
// A leading decimal comma (`,5` for 0,5, #2966) starts the number as `.5` would.
let leading_comma = c == ',';
if leading_comma {
i += 1;
}
while cs.get(i).is_some_and(|(_, c)| c.is_ascii_digit() || *c == '.') {
i += 1;
}
// A decimal comma (`2,5 mm`, as typed with a numeric keypad in many locales, #1347):
// a comma between digits, in a number with no point, outside any parentheses (inside
// them a comma separates a function's arguments: `max(1,2)`).
let digit = |k: usize| cs.get(k).is_some_and(|(_, c)| c.is_ascii_digit());
let has_point = cs.get(st..i).is_some_and(|ds| ds.iter().any(|(_, c)| *c == '.'));
if depth == 0 && !leading_comma && !has_point && digit(i.wrapping_sub(1)) && cs.get(i).is_some_and(|(_, c)| *c == ',') && digit(i + 1) {
i += 1;
while digit(i) {
i += 1;
}
}
// Exponent: 1e-3 (but not `2em`).
if cs.get(i).is_some_and(|(_, c)| *c == 'e' || *c == 'E') {
let sign = cs.get(i + 1).is_some_and(|(_, c)| *c == '-' || *c == '+');
let digit_at = if sign { i + 2 } else { i + 1 };
if cs.get(digit_at).is_some_and(|(_, c)| c.is_ascii_digit()) {
i = digit_at;
while cs.get(i).is_some_and(|(_, c)| c.is_ascii_digit()) {
i += 1;
}
}
}
let t = s.get(at(st)..at(i)).unwrap_or_default();
let v: f64 = t.replace(',', ".").parse().map_err(|_| DocError::Expr(format!("bad number `{t}`")))?;
// A mixed number, as imperial sizes are written (`2 1/8"` is 2.125 in, #1802): a whole
// number, then a proper fraction of whole numbers, is one value, not `2 × 1/8`.
if t.chars().all(|c| c.is_ascii_digit())
&& let Some((fraction, end)) = mixed_fraction(&cs, i, depth)
{
out.push((Tok::Num(v + fraction), at(st), at(end)));
i = end;
continue;
}
out.push((Tok::Num(v), at(st), at(i)));
} else if c.is_alphabetic() || c == '_' || c == 'µ' {
let st = i;
while cs.get(i).is_some_and(|(_, c)| c.is_alphanumeric() || *c == '_') {
i += 1;
}
out.push((Tok::Id(s.get(at(st)..at(i)).unwrap_or_default().to_string()), at(st), at(i)));
} else if c == '°' {
out.push((Tok::Id("deg".into()), at(i), at(i + 1)));
i += 1;
} else if c == '"' || c == '″' {
// Inch and foot marks (`1"`, `2'`, #1502), straight or as primes.
out.push((Tok::Id("in".into()), at(i), at(i + 1)));
i += 1;
} else if c == '\'' || c == '′' {
out.push((Tok::Id("ft".into()), at(i), at(i + 1)));
i += 1;
} else if c == '×' || c == '·' {
out.push((Tok::Op('*'), at(i), at(i + 1)));
i += 1;
} else if c == '÷' {
out.push((Tok::Op('/'), at(i), at(i + 1)));
i += 1;
} else if c == '−' {
out.push((Tok::Op('-'), at(i), at(i + 1)));
i += 1;
} else if c == ';' {
// Some CAD tools separate function arguments with `;` in some locales.
out.push((Tok::Op(','), at(i), at(i + 1)));
i += 1;
} else if "+-*/^(),%".contains(c) {
match c {
'(' => depth += 1,
')' => depth = depth.saturating_sub(1),
_ => {}
}
out.push((Tok::Op(c), at(i), at(i + 1)));
i += 1;
} else {
return Err(DocError::Expr(format!("unexpected `{c}`")));
}
}
Ok(out)
}
/// Whether the comma at `i` starts a number, as a leading decimal comma (`,5` for 0,5, #2966).
/// It must be outside parentheses (inside them a comma separates arguments, as for any decimal
/// comma), be followed by a digit, and stand where an operand is expected: at the start or right
/// after `+ - * / ^`. A comma after a number, name, `)` or `%` keeps its meaning (`2 ,5` and
/// `1,5,3` stay errors).
fn leading_decimal_comma(cs: &[(usize, char)], i: usize, depth: usize, prev: Option<&(Tok, usize, usize)>) -> bool {
depth == 0
&& cs.get(i).is_some_and(|(_, c)| *c == ',')
&& cs.get(i + 1).is_some_and(|(_, c)| c.is_ascii_digit())
&& match prev {
None => true,
Some((Tok::Op(op), _, _)) => "+-*/^".contains(*op),
Some(_) => false,
}
}
/// The proper fraction of a mixed number whose whole part ends at `i`: spaces, digits, `/`,
/// digits, with nothing after them that would continue the number (`2 1/8.5`, `2 1/8e3`, a
/// decimal comma outside parentheses: `2 1/8,5`). Its value and where it ends. `depth`: the
/// parentheses open there (inside them a comma separates arguments: `max(2 1/8,1)`).
fn mixed_fraction(cs: &[(usize, char)], mut i: usize, depth: usize) -> Option<(f64, usize)> {
let digits = |from: usize| cs.get(from..).map_or(0, |rest| rest.iter().take_while(|(_, c)| c.is_ascii_digit()).count());
let space = i;
while cs.get(i).is_some_and(|(_, c)| *c == ' ' || *c == '\t') {
i += 1;
}
let numerator = digits(i);
if i == space || numerator == 0 || !cs.get(i + numerator).is_some_and(|(_, c)| *c == '/') {
return None;
}
let denominator = digits(i + numerator + 1);
let end = i + numerator + 1 + denominator;
let next = |k: usize| cs.get(end + k).map(|(_, c)| *c);
let continues = matches!(next(0), Some('.'))
|| (depth == 0 && matches!(next(0), Some(',')) && next(1).is_some_and(|c| c.is_ascii_digit()))
|| (matches!(next(0), Some('e' | 'E')) && next(1).is_some_and(|c| c.is_ascii_digit() || c == '-' || c == '+'));
if denominator == 0 || continues {
return None;
}
// Compared as digits, not as floats: long ones round to the same float (#1802 review).
let digits_of = |from: usize, len: usize| -> Option<String> {
let s: String = cs.get(from..from + len)?.iter().map(|(_, c)| *c).collect();
Some(s.trim_start_matches('0').to_string())
};
let (n, d) = (digits_of(i, numerator)?, digits_of(i + numerator + 1, denominator)?);
let proper = !d.is_empty() && (n.len(), n.as_str()) < (d.len(), d.as_str());
let value = |t: &str| if t.is_empty() { Some(0.0) } else { t.parse::<f64>().ok() };
if !proper {
return None;
}
Some((value(&n)? / value(&d)?, end))
}
fn lex(s: &str) -> Result<Vec<Tok>, DocError> {
Ok(lex_spans(s)?.into_iter().map(|(t, _, _)| t).collect())
}
/// Is the identifier token at `i` a reference to a parameter (not a call, unit or constant)?
fn is_reference(toks: &[Tok], i: usize, id: &str) -> bool {
let is_call = matches!(toks.get(i + 1), Some(Tok::Op('(')));
!is_call && unit(id).is_none() && !is_constant(id)
}
/// Identifiers an expression refers to (excluding units, constants and functions).
pub fn references(s: &str) -> Vec<String> {
// Every evaluation fingerprints every feature by the parameters its expressions name, so the
// same short expressions are asked about on every command: the answers are kept (per thread,
// bounded) instead of being lexed again.
thread_local! {
static SEEN: std::cell::RefCell<std::collections::HashMap<String, Vec<String>>> = std::cell::RefCell::new(std::collections::HashMap::new());
}
if let Some(hit) = SEEN.with(|seen| seen.borrow().get(s).cloned()) {
return hit;
}
let out = scan_references(s);
SEEN.with(|seen| {
let mut seen = seen.borrow_mut();
if seen.len() >= 1 << 16 {
seen.clear();
}
seen.insert(s.to_string(), out.clone());
});
out
}
/// [`references`], worked out.
fn scan_references(s: &str) -> Vec<String> {
let Ok(toks) = lex(s) else { return Vec::new() };
let mut out: Vec<String> = Vec::new();
for (i, t) in toks.iter().enumerate() {
if let Tok::Id(id) = t
&& is_reference(&toks, i, id)
&& !out.contains(id)
{
out.push(id.clone());
}
}
out
}
/// The expression with every reference to `old` renamed to `new` (text otherwise kept).
pub fn rename_reference(s: &str, old: &str, new: &str) -> String {
let Ok(spans) = lex_spans(s) else { return s.to_string() };
let toks: Vec<Tok> = spans.iter().map(|(t, _, _)| t.clone()).collect();
let mut out = String::with_capacity(s.len());
let mut last = 0;
for (i, (t, a, b)) in spans.iter().enumerate() {
if let Tok::Id(id) = t
&& id == old
&& is_reference(&toks, i, id)
{
out.push_str(s.get(last..*a).unwrap_or_default());
out.push_str(new);
last = *b;
}
}
out.push_str(s.get(last..).unwrap_or_default());
out
}
/// Is the expression just a number (with an optional unit), like `20`, `20 mm` or `-1.5 in`?
pub fn is_literal(s: &str) -> bool {
let Ok(toks) = lex(s) else { return false };
let toks: &[Tok] = match toks.first() {
Some(Tok::Op('-' | '+')) => toks.get(1..).unwrap_or_default(),
_ => &toks,
};
match toks {
[Tok::Num(_)] => true,
[Tok::Num(_), Tok::Id(u)] => unit(u).is_some(),
_ => false,
}
}
/// Is the expression a bare number without a unit, like `20` or `-1.5`?
pub fn is_bare_number(s: &str) -> bool {
is_literal(s) && s.trim().trim_start_matches(['-', '+']).trim().parse::<f64>().is_ok()
}
/// Is `s` shaped like a parameter name: a letter or `_`, then letters, digits and `_`? The shape
/// only; whether the name is free or reserved is `Document::param_name_problem`'s business.
fn is_name_shaped(s: &str) -> bool {
let mut cs = s.chars();
matches!(cs.next(), Some(c) if c.is_alphabetic() || c == '_') && cs.all(|c| c.is_alphanumeric() || c == '_')
}
/// A value typed as a definition, `name = expression` (or `#name = expression`, #2371): the name
/// without the `#` and the text after the first `=`, both trimmed (the text may be empty). `None` for anything else, including text whose
/// left side is not shaped like a name (`2 = 3`), which stays an ordinary expression and fails
/// to parse as before. The dimension input defines a user parameter this way (#2916); other
/// value inputs can take the same form later.
pub fn definition(s: &str) -> Option<(&str, &str)> {
let (name, rhs) = s.split_once('=')?;
let name = name.trim();
let rhs = rhs.trim();
let name = name.strip_prefix('#').unwrap_or(name);
// `w == 3` is not a definition: a second `=` would read as a formula marker (#4681).
(is_name_shaped(name) && !rhs.starts_with('=')).then_some((name, rhs))
}
/// The length unit of a design with these units: `mm` unless they name another length unit.
pub fn length_unit_or_mm(units: &str) -> &str {
let u = units.trim();
if unit_info(u).is_some_and(|(k, _)| k == Kind::Length) { u } else { "mm" }
}
struct Parser<'a> {
toks: Vec<Tok>,
/// Each token's byte range in the source: whether a fraction is written closed up.
spans: Vec<(usize, usize)>,
pos: usize,
lookup: &'a dyn Fn(&str) -> Result<Value, DocError>,
depth: usize,
defaults: Defaults,
}
impl Parser<'_> {
fn peek(&self) -> Option<&Tok> {
self.toks.get(self.pos)
}
fn next(&mut self) -> Option<Tok> {
let t = self.toks.get(self.pos).cloned();
self.pos += 1;
t
}
fn enter(&mut self) -> Result<(), DocError> {
self.depth += 1;
if self.depth > MAX_DEPTH { Err(DocError::Expr("expression nested too deeply".into())) } else { Ok(()) }
}
fn expr(&mut self) -> Result<Value, DocError> {
self.enter()?;
let mut a = self.term()?;
while let Some(Tok::Op(c @ ('+' | '-'))) = self.peek().cloned() {
self.pos += 1;
let b = self.term()?;
a = add(a, b, c == '-', self.defaults)?;
}
self.depth -= 1;
Ok(a)
}
fn term(&mut self) -> Result<Value, DocError> {
let mut a = self.unary()?;
loop {
match self.peek().cloned() {
Some(Tok::Op('*')) => {
self.pos += 1;
let b = self.unary()?;
a = mul(a, b, false)?;
}
Some(Tok::Op('/')) => {
self.pos += 1;
let b = self.unary()?;
a = mul(a, b, true)?;
}
Some(Tok::Op('%')) => {
self.pos += 1;
let b = self.unary()?;
a = modulo(a, b, self.defaults)?;
}
// Juxtaposition: `10 mm`, `2 width`.
Some(Tok::Id(_) | Tok::Num(_)) | Some(Tok::Op('(')) => {
let b = self.unary()?;
a = mul(a, b, false)?;
}
_ => return Ok(a),
}
}
}
fn unary(&mut self) -> Result<Value, DocError> {
self.signed(true)
}
/// A signed operand. `glue`: a number takes the unit written after it (not in an exponent).
fn signed(&mut self, glue: bool) -> Result<Value, DocError> {
match self.peek() {
Some(Tok::Op('-')) => {
self.pos += 1;
self.enter()?;
let v = self.signed(glue)?;
self.depth -= 1;
Ok(Value { v: -v.v, ..v })
}
Some(Tok::Op('+')) => {
self.pos += 1;
self.enter()?;
let v = self.signed(glue)?;
self.depth -= 1;
Ok(v)
}
_ => self.power(glue),
}
}
fn power(&mut self, glue: bool) -> Result<Value, DocError> {
let number = matches!(self.peek(), Some(Tok::Num(_)));
let at = self.pos;
let mut base = self.atom()?;
// A number and the unit after it are one quantity, bound tighter than `*` and `/`:
// `10 mm / 2 mm` is 5, not (10 mm / 2) mm = 5 mm². The unit keeps its own power
// (`3 mm^2`). A name that is not a unit (`2 width`) stays an ordinary product.
if glue && number {
// A fraction of two numbers before a unit is one value, as sizes are written:
// `1/2"` and `1/2 in` are half an inch (as the mixed number `2 1/8"` is one value).
// After a division only written closed up: `1 in / 1/2 in` is 2, but
// `width / 10 / 2 mm` is (width / 10) / 2 mm.
if let (Some(Tok::Op('/')), Some(Tok::Num(d))) = (self.peek(), self.toks.get(self.pos + 1))
&& self.unit_at(self.pos + 2)
&& (!self.after_division(at) || self.closed_up(at, self.pos + 1))
{
let d = Value::num(*d);
self.pos += 2;
base = mul(base, d, true)?;
}
if self.unit_at(self.pos) {
let u = self.power(false)?;
return mul(base, u, false);
}
}
if let Some(Tok::Op('^')) = self.peek() {
self.pos += 1;
self.enter()?;
// The exponent is a plain number: `2^3 mm` stays 8 mm.
let e = self.signed(false)?;
self.depth -= 1;
return pow(base, e);
}
Ok(base)
}
/// Whether the operand starting at token `i` is divided by: a `/` before it, past any signs.
fn after_division(&self, i: usize) -> bool {
let mut k = i;
while k > 0 && matches!(self.toks.get(k - 1), Some(Tok::Op('+' | '-'))) {
k -= 1;
}
k > 0 && matches!(self.toks.get(k - 1), Some(Tok::Op('/')))
}
/// Whether tokens `a` to `b` are written without spaces between them.
fn closed_up(&self, a: usize, b: usize) -> bool {
(a..b).all(|i| matches!((self.spans.get(i), self.spans.get(i + 1)), (Some(x), Some(y)) if x.1 == y.0))
}
/// Whether the token at `i` is a unit name, not called as a function.
fn unit_at(&self, i: usize) -> bool {
matches!(self.toks.get(i), Some(Tok::Id(id)) if unit(id).is_some()) && !matches!(self.toks.get(i + 1), Some(Tok::Op('(')))
}
fn atom(&mut self) -> Result<Value, DocError> {
match self.next() {
Some(Tok::Num(v)) => Ok(Value::num(v)),
Some(Tok::Op('(')) => {
let v = self.expr()?;
match self.next() {
Some(Tok::Op(')')) => Ok(v),
_ => Err(DocError::Expr("missing `)`".into())),
}
}
Some(Tok::Id(id)) => {
if let Some(Tok::Op('(')) = self.peek() {
self.pos += 1;
let mut args = Vec::new();
if !matches!(self.peek(), Some(Tok::Op(')'))) {
loop {
if args.len() >= MAX_ARGS {
return Err(DocError::Expr(format!("too many arguments to `{id}`")));
}
args.push(self.expr()?);
match self.next() {
Some(Tok::Op(',')) => continue,
Some(Tok::Op(')')) => break,
_ => return Err(DocError::Expr(format!("missing `)` after the arguments of `{id}`"))),
}
}
} else {
self.pos += 1;
}
return call(&id, &args, self.defaults);
}
match id.as_str() {
"pi" | "PI" => return Ok(Value::num(std::f64::consts::PI)),
_ => {}
}
if let Some(u) = unit(&id) {
return Ok(u);
}
(self.lookup)(&id)
}
Some(Tok::Op(c)) => Err(DocError::Expr(format!("unexpected `{c}`"))),
None => Err(DocError::Expr("unexpected end of expression".into())),
}
}
}
/// A unit-less number next to a dimensioned value, in that value's default unit.
fn scale_bare(x: Value, len: i8, ang: i8, d: Defaults) -> f64 {
if !x.unitless() {
x.v
} else if len == 1 && ang == 0 {
x.v * d.len
} else if ang == 1 && len == 0 {
x.v * d.ang
} else {
x.v
}
}
fn add(a: Value, b: Value, sub: bool, d: Defaults) -> Result<Value, DocError> {
let (len, ang) = if a.unitless() {
(b.len, b.ang)
} else if b.unitless() || (a.len == b.len && a.ang == b.ang) {
(a.len, a.ang)
} else {
return Err(DocError::Expr(format!("cannot {} {} and {}", if sub { "subtract" } else { "add" }, a.describe(), b.describe())));
};
let (x, y) = (scale_bare(a, len, ang, d), scale_bare(b, len, ang, d));
Ok(Value { v: if sub { x - y } else { x + y }, len, ang })
}
fn dims(a: i8, b: i8, sub: bool) -> Result<i8, DocError> {
let r = if sub { a.checked_sub(b) } else { a.checked_add(b) };
r.filter(|x| x.abs() <= 16).ok_or_else(|| DocError::Expr("unit powers too large".into()))
}
fn mul(a: Value, b: Value, div: bool) -> Result<Value, DocError> {
if div {
if b.v == 0.0 {
return Err(DocError::Expr("division by zero".into()));
}
Ok(Value { v: a.v / b.v, len: dims(a.len, b.len, true)?, ang: dims(a.ang, b.ang, true)? })
} else {
Ok(Value { v: a.v * b.v, len: dims(a.len, b.len, false)?, ang: dims(a.ang, b.ang, false)? })
}
}
fn modulo(a: Value, b: Value, d: Defaults) -> Result<Value, DocError> {
let (len, ang) = if a.unitless() { (b.len, b.ang) } else { (a.len, a.ang) };
if !(a.unitless() || b.unitless() || (a.len == b.len && a.ang == b.ang)) {
return Err(DocError::Expr(format!("cannot take {} modulo {}", a.describe(), b.describe())));
}
let (x, y) = (scale_bare(a, len, ang, d), scale_bare(b, len, ang, d));
if y == 0.0 {
return Err(DocError::Expr("modulo by zero".into()));
}
Ok(Value { v: x.rem_euclid(y), len, ang })
}
fn pow(base: Value, e: Value) -> Result<Value, DocError> {
if !e.unitless() {
return Err(DocError::Expr(format!("an exponent must be a unit-less number, not {}", e.describe())));
}
let n = e.v;
let k = if (n - n.round()).abs() < 1e-12 && n.abs() < 16.0 { n.round() as i8 } else { 0 };
if !base.unitless() && k == 0 {
return Err(DocError::Expr("a value with units needs a small whole-number exponent".into()));
}
Ok(Value { v: base.v.powf(n), len: dims(0, base.len.saturating_mul(k), false)?, ang: dims(0, base.ang.saturating_mul(k), false)? })
}
fn call(f: &str, args: &[Value], d: Defaults) -> Result<Value, DocError> {
let one = || match args {
[a] => Ok(*a),
_ => Err(DocError::Expr(format!("`{f}` takes one argument"))),
};
let two = || match args {
[a, b] => Ok((*a, *b)),
_ => Err(DocError::Expr(format!("`{f}` takes two arguments"))),
};
let rad = |a: Value| {
if a.ang == 1 && a.len == 0 {
Ok(a.v)
} else if a.unitless() {
Ok(a.v * d.ang)
} else {
Err(DocError::Expr(format!("`{f}` needs an angle, not {}", a.describe())))
}
};
let num = |a: Value| if a.unitless() { Ok(a.v) } else { Err(DocError::Expr(format!("`{f}` needs a unit-less number, not {}", a.describe()))) };
let same = |a: Value, b: Value| -> Result<(Value, Value), DocError> {
// Bring a bare number to the other operand's unit (as in `a + b`).
let z = add(a, Value { v: 0.0, ..b }, false, d)?;
let w = add(b, Value { v: 0.0, ..a }, false, d)?;
Ok((z, w))
};
let unit_fn = |x: f64, a: Value| Value { v: x, ..a };
Ok(match f {
"sin" => Value::num(rad(one()?)?.sin()),
"cos" => Value::num(rad(one()?)?.cos()),
"tan" => Value::num(rad(one()?)?.tan()),
"asin" | "acos" => {
let x = num(one()?)?;
if !(-1.0..=1.0).contains(&x) {
return Err(DocError::Expr(format!("`{f}` needs a number between -1 and 1")));
}
Value::angle(if f == "asin" { x.asin() } else { x.acos() })
}
"atan" => Value::angle(num(one()?)?.atan()),
"atan2" => {
let (y, x) = two()?;
let (y, x) = same(y, x)?;
if y.len != x.len || y.ang != x.ang {
return Err(DocError::Expr("`atan2` needs two values with the same units".into()));
}
Value::angle(y.v.atan2(x.v))
}
"sqrt" => {
let a = one()?;
if a.len % 2 != 0 || a.ang % 2 != 0 {
return Err(DocError::Expr("sqrt of an odd power of a unit".into()));
}
if a.v < 0.0 {
return Err(DocError::Expr("sqrt of a negative number".into()));
}
Value { v: a.v.sqrt(), len: a.len / 2, ang: a.ang / 2 }
}
"abs" => {
let a = one()?;
unit_fn(a.v.abs(), a)
}
"sign" => Value::num(one()?.v.signum()),
"floor" | "ceil" | "round" | "trunc" => {
let a = one()?;
// Round in the value's own default unit (round(2.4 in) = 2 in for an inch parameter).
let scale = scale_bare(Value::num(1.0), a.len, a.ang, d);
let x = if scale != 0.0 { a.v / scale } else { a.v };
let r = match f {
"floor" => x.floor(),
"ceil" => x.ceil(),
"trunc" => x.trunc(),
_ => x.round(),
};
unit_fn(r * if scale != 0.0 { scale } else { 1.0 }, a)
}
"exp" => Value::num(num(one()?)?.exp()),
"ln" | "log" | "log10" => {
let x = num(one()?)?;
if x <= 0.0 {
return Err(DocError::Expr(format!("`{f}` needs a positive number")));
}
Value::num(if f == "ln" { x.ln() } else { x.log10() })
}
"hypot" => {
let (a, b) = two()?;
let (a, b) = same(a, b)?;
if a.len != b.len || a.ang != b.ang {
return Err(DocError::Expr("`hypot` needs two values with the same units".into()));
}
unit_fn(a.v.hypot(b.v), a)
}
"pow" => {
let (a, b) = two()?;
pow(a, b)?
}
"mod" => {
let (a, b) = two()?;
modulo(a, b, d)?
}
"min" | "max" => {
let Some(first) = args.first().copied() else { return Err(DocError::Expr(format!("`{f}` needs arguments"))) };
let mut acc = first;
for a in args.iter().skip(1) {
let (x, y) = same(*a, acc)?;
if x.len != y.len || x.ang != y.ang {
return Err(DocError::Expr(format!("`{f}` needs values with the same units")));
}
acc = if (f == "min" && x.v < y.v) || (f == "max" && x.v > y.v) { x } else { y };
}
acc
}
_ => return Err(DocError::Expr(format!("unknown function `{f}`"))),
})
}
/// Evaluate an expression; `lookup` resolves parameter names. Bare numbers are mm / degrees.
pub fn eval_with(s: &str, lookup: &dyn Fn(&str) -> Result<Value, DocError>) -> Result<Value, DocError> {
eval_with_defaults(s, lookup, Defaults::default())
}
/// Evaluate an expression reading bare numbers next to lengths / angles in `defaults`.
pub fn eval_with_defaults(s: &str, lookup: &dyn Fn(&str) -> Result<Value, DocError>, defaults: Defaults) -> Result<Value, DocError> {
let (toks, spans): (Vec<Tok>, Vec<(usize, usize)>) = lex_spans(s)?.into_iter().map(|(t, a, b)| (t, (a, b))).unzip();
if toks.is_empty() {
return Err(DocError::Expr("empty expression".into()));
}
let mut p = Parser { toks, spans, pos: 0, lookup, depth: 0, defaults };
let v = p.expr()?;
if p.pos < p.toks.len() {
return Err(DocError::Expr(format!("unexpected input in `{s}`")));
}
if !v.v.is_finite() {
return Err(DocError::Expr(format!("`{s}` is not a finite number")));
}
Ok(v)
}
/// One parameter to evaluate: name, expression and unit (`mm`, `in`, `deg`, empty…).
#[derive(Clone, Debug, PartialEq)]
pub struct ParamDef {
pub name: String,
pub expr: String,
pub unit: String,
}
/// Evaluate all parameters in dependency order: values (mm / rad / unit-less) and errors by
/// name. Circular references are reported with their path (`a → b → a`). `doc_len` is the
/// document's length unit in mm (bare numbers of unit-less-unit parameters next to lengths).
pub fn eval_params(params: &[ParamDef], doc_len: f64) -> (BTreeMap<String, Value>, BTreeMap<String, String>) {
// Each command evaluates the design's parameters (every named feature input is one) several
// times over, mostly unchanged: the last few results are kept (per thread) for the same
// definitions, compared in full.
type Evaluated = (BTreeMap<String, Value>, BTreeMap<String, String>);
thread_local! {
static LAST: std::cell::RefCell<Vec<(Vec<ParamDef>, u64, Evaluated)>> = const { std::cell::RefCell::new(Vec::new()) };
}
let key = doc_len.to_bits();
let hit = LAST.with(|last| {
let mut last = last.borrow_mut();
let at = last.iter().position(|(defs, len, _)| *len == key && defs.as_slice() == params)?;
let entry = last.remove(at);
let out = entry.2.clone();
last.push(entry);
Some(out)
});
if let Some(out) = hit {
return out;
}
let out = eval_params_uncached(params, doc_len);
LAST.with(|last| {
let mut last = last.borrow_mut();
if last.len() >= 4 {
last.remove(0);
}
last.push((params.to_vec(), key, out.clone()));
});
out
}
/// [`eval_params`], worked out.
fn eval_params_uncached(params: &[ParamDef], doc_len: f64) -> (BTreeMap<String, Value>, BTreeMap<String, String>) {
let mut done: BTreeMap<String, Value> = BTreeMap::new();
let mut errors: BTreeMap<String, String> = BTreeMap::new();
let index: BTreeMap<&str, &ParamDef> = params.iter().map(|p| (p.name.as_str(), p)).collect();
struct Ctx<'a> {
index: BTreeMap<&'a str, &'a ParamDef>,
done: BTreeMap<String, Value>,
errors: BTreeMap<String, String>,
stack: Vec<String>,
doc_len: f64,
}
fn visit(name: &str, cx: &mut Ctx) -> Result<Value, DocError> {
if let Some(v) = cx.done.get(name) {
return Ok(*v);
}
if let Some(e) = cx.errors.get(name) {
return Err(DocError::Expr(format!("`{name}` has an error: {e}")));
}
let Some(p) = cx.index.get(name).copied() else {
return Err(DocError::Expr(format!("unknown parameter `{name}`")));
};
if let Some(at) = cx.stack.iter().position(|s| s == name) {
let mut path: Vec<&str> = cx.stack.iter().skip(at).map(String::as_str).collect();
path.push(name);
return Err(DocError::Expr(format!("circular reference: {}", path.join(" → "))));
}
if cx.stack.len() > 512 {
return Err(DocError::Expr("parameters nested too deeply".into()));
}
cx.stack.push(name.to_string());
let mut vals: BTreeMap<String, Value> = BTreeMap::new();
let mut err = None;
for d in references(&p.expr) {
match visit(&d, cx) {
Ok(v) => {
vals.insert(d, v);
}
Err(e) => {
err = Some(e);
break;
}
}
}
cx.stack.pop();
let r = match err {
Some(e) => Err(e),
// Most parameters are named feature inputs with a literal value ("10 mm"): those are
// worked out once (per thread) rather than parsed again on every evaluation.
None if vals.is_empty() => eval_constant(p, cx.doc_len),
None => eval_def(p, &|n| vals.get(n).copied().ok_or_else(|| DocError::Expr(format!("unknown parameter `{n}`"))), cx.doc_len),
};
match &r {
Ok(v) => {
cx.done.insert(name.to_string(), *v);
}
Err(e) => {
let msg = e.to_string();
cx.errors.insert(name.to_string(), msg.strip_prefix("expression: ").unwrap_or(&msg).to_string());
}
}
r
}
let mut cx = Ctx { index, done: std::mem::take(&mut done), errors: std::mem::take(&mut errors), stack: Vec::new(), doc_len };
for p in params {
cx.stack.clear();
let _ = visit(&p.name, &mut cx);
}
(cx.done, cx.errors)
}
/// One parameter's value: its expression in its unit, with the values of the parameters it
/// refers to from `lookup`.
pub fn eval_def(p: &ParamDef, lookup: &dyn Fn(&str) -> Result<Value, DocError>, doc_len: f64) -> Result<Value, DocError> {
let (kind, _) = unit_info(&p.unit).unwrap_or((Kind::Length, 1.0));
let defaults = Defaults::for_unit(&p.unit, doc_len);
let x = eval_with_defaults(&p.expr, lookup, defaults)?.to_kind_in(kind, defaults)?;
Ok(match kind {
Kind::Length => Value::length(x),
Kind::Angle => Value::angle(x),
Kind::Unitless => Value::num(x),
})
}
/// [`eval_def`] of a parameter whose expression names no other parameter, remembered by its
/// expression, unit and the design's length unit.
fn eval_constant(p: &ParamDef, doc_len: f64) -> Result<Value, DocError> {
type Key = (String, String, u64);
thread_local! {
static SEEN: std::cell::RefCell<std::collections::HashMap<Key, Result<Value, DocError>>> = std::cell::RefCell::new(std::collections::HashMap::new());
}
let key = (p.expr.clone(), p.unit.clone(), doc_len.to_bits());
if let Some(hit) = SEEN.with(|seen| seen.borrow().get(&key).cloned()) {
return hit;
}
let out = eval_def(p, &|n| Err(DocError::Expr(format!("unknown parameter `{n}`"))), doc_len);
SEEN.with(|seen| {
let mut seen = seen.borrow_mut();
if seen.len() >= 1 << 16 {
seen.clear();
}
seen.insert(key, out.clone());
});
out
}
/// Dependency edges between parameters: (parameter, parameter it references).
pub fn param_edges(params: &[ParamDef]) -> Vec<(String, String)> {
let mut out = Vec::new();
for p in params {
for r in references(&p.expr) {
out.push((p.name.clone(), r));
}
}
out
}
#[cfg(test)]
mod tests {
use super::*;
fn ev(s: &str, k: Kind) -> Result<f64, DocError> {
let look = |n: &str| match n {
"width" => Ok(Value::length(40.0)),
"ang" => Ok(Value::angle(std::f64::consts::FRAC_PI_2)),
"count" => Ok(Value::num(3.0)),
_ => Err(DocError::Expr(format!("unknown {n}"))),
};
eval_with(s, &look)?.to_kind(k)
}
fn def(n: &str, e: &str, u: &str) -> ParamDef {
ParamDef { name: n.into(), expr: e.into(), unit: u.into() }
}
#[test]
fn a_decimal_comma_outside_parentheses() {
// #1347: a comma between digits is a decimal comma where it cannot separate arguments.
assert_eq!(ev("2,5", Kind::Unitless).unwrap(), 2.5);
assert_eq!(ev("2,5 mm", Kind::Length).unwrap(), 2.5);
assert_eq!(ev("12,75mm + 0,25", Kind::Length).unwrap(), 13.0);
assert_eq!(ev("width / 2,5", Kind::Length).unwrap(), 16.0);
assert!((ev("1,5e3 mm", Kind::Length).unwrap() - 1500.0).abs() < 1e-9);
assert!((ev("22,5 deg", Kind::Angle).unwrap() - 22.5f64.to_radians()).abs() < 1e-12);
// Inside parentheses a comma still separates a function's arguments.
assert_eq!(ev("max(1,2)", Kind::Unitless).unwrap(), 2.0);
assert_eq!(ev("max(1 mm, 3, 2)", Kind::Length).unwrap(), 3.0);
assert_eq!(ev("(2,5)", Kind::Unitless).ok(), None, "a comma inside parentheses is not a decimal comma");
// Not between two digits, or a second comma: still an error.
for bad in ["2,", "2 ,5", "2, 5", "1,5,3", "1.5,3", ",5,3", ",5.3", "width ,5", "(1) ,5"] {
assert!(ev(bad, Kind::Unitless).is_err(), "{bad}");
}
}
#[test]
fn a_leading_decimal_comma_is_a_number() {
// #2966: `,5` is 0,5 where `.5` would be a number: at the start or after an operator.
assert_eq!(ev(",5", Kind::Unitless).unwrap(), 0.5);
assert_eq!(ev(",5 mm", Kind::Length).unwrap(), 0.5);
assert_eq!(ev("-,5", Kind::Unitless).unwrap(), -0.5);
assert_eq!(ev("2*,5", Kind::Unitless).unwrap(), 1.0);
assert_eq!(ev("width - ,25", Kind::Length).unwrap(), 39.75);
// Function arguments are still separated by commas.
assert_eq!(ev("max(1,5)", Kind::Unitless).unwrap(), 5.0);
assert_eq!(ev("max(,5; 2)", Kind::Unitless).ok(), None, "inside parentheses a comma is a separator");
}
#[test]
fn inch_and_foot_marks() {
// #1502: `1"` in a millimetre design is an inch, `2'` two feet, straight or as primes.
assert_eq!(ev("1\"", Kind::Length).unwrap(), 25.4);
assert_eq!(ev("1″", Kind::Length).unwrap(), 25.4);
assert_eq!(ev("2'", Kind::Length).unwrap(), 609.6);
assert_eq!(ev("2′", Kind::Length).unwrap(), 609.6);
assert_eq!(ev("1/2\"", Kind::Length).unwrap(), 12.7);
assert_eq!(ev("width + 1\"", Kind::Length).unwrap(), 65.4);
assert_eq!(ev("2' + 3\"", Kind::Length).unwrap(), 685.8);
// A mark alone is its unit alone, as `in` is.
assert_eq!(ev("\"", Kind::Length).ok(), ev("in", Kind::Length).ok());
}
#[test]
fn mixed_numbers() {
// #1802: `2 1/8"` is 2.125 in, as imperial sizes are written, not 2 × 1/8 in.
assert_eq!(ev("2 1/8\"", Kind::Length).unwrap(), 2.125 * 25.4);
assert_eq!(ev("2 1/8 in", Kind::Length).unwrap(), 2.125 * 25.4);
assert_eq!(ev("3 7/16\"", Kind::Length).unwrap(), 3.4375 * 25.4);
assert_eq!(ev("10 1/2mm", Kind::Length).unwrap(), 10.5);
assert_eq!(ev("width + 1 1/2", Kind::Length).unwrap(), 41.5);
assert_eq!(ev("max(2 1/8, 3)", Kind::Unitless).unwrap(), 3.0);
// Inside parentheses a comma after the fraction separates arguments; outside, a comma
// between digits is a decimal comma, which continues the number (as before).
assert_eq!(ev("max(2 1/8,1)", Kind::Unitless).unwrap(), 2.125);
assert_eq!(ev("2 1/8,5", Kind::Unitless).unwrap(), 2.0 / 8.5);
// Long numerators and denominators are compared as digits, not as rounded floats.
assert!((ev("2 9007199254740992/9007199254740993", Kind::Unitless).unwrap() - 3.0).abs() < 1e-12);
assert_eq!(ev("2 007/8", Kind::Unitless).unwrap(), 2.875);
assert_eq!(ev("-2 1/4", Kind::Unitless).unwrap(), -2.25);
// Not a proper fraction of whole numbers after a whole number: as before.
for (s, v) in [("2 3/2", 3.0), ("2.5 1/2", 1.25), ("2 1/8.5", 2.0 / 8.5), ("2 1 / 8", 0.25), ("2 1/0", f64::INFINITY), ("1/8", 0.125)] {
assert_eq!(ev(s, Kind::Unitless).ok(), Some(v).filter(|v| v.is_finite()), "{s}");
}
}
#[test]
fn a_number_and_its_unit_are_one_quantity() {
// `10 mm / 2 mm` divides by 2 mm; it is not `(10 mm / 2) mm`, a value in mm².
assert_eq!(ev("10 mm / 2 mm", Kind::Unitless).unwrap(), 5.0);
assert_eq!(ev("10mm/2mm", Kind::Unitless).unwrap(), 5.0);
assert_eq!(ev("width / 4 mm", Kind::Unitless).unwrap(), 10.0);
assert_eq!(ev("6 mm / 2 mm * 3", Kind::Unitless).unwrap(), 9.0);
assert!((ev("90 deg / 1 rad", Kind::Unitless).unwrap() - std::f64::consts::FRAC_PI_2).abs() < 1e-12);
assert!((ev("(ang - 30 deg) / 1 rad * width", Kind::Length).unwrap() - 40.0 * 60f64.to_radians()).abs() < 1e-12);
assert_eq!(ev("1 in / 1 mm", Kind::Unitless).unwrap(), 25.4);
assert_eq!(ev("2 1/2 in / 1 in", Kind::Unitless).unwrap(), 2.5);
assert_eq!(ev("1\" / 1 mm", Kind::Unitless).unwrap(), 25.4);
assert_eq!(ev("-10 mm / 2 mm", Kind::Unitless).unwrap(), -5.0);
// A fraction of numbers right before a unit stays one value: half an inch.
assert_eq!(ev("1/2 in", Kind::Length).unwrap(), 12.7);
assert_eq!(ev("width + 3/4\"", Kind::Length).unwrap(), 40.0 + 0.75 * 25.4);
assert_eq!(ev("1 in / 1/2 in", Kind::Unitless).unwrap(), 2.0);
assert_eq!(ev("10 / 2 mm", Kind::Length).unwrap(), 5.0);
// After a division, a spaced-out `/` divides again: (width / 10) / 2 mm.
assert_eq!(ev("width / 10 / 2 mm", Kind::Unitless).unwrap(), 2.0);
assert_eq!(ev("width / -10 / 2 mm", Kind::Unitless).unwrap(), -2.0);
assert_eq!(ev("width / 10/2 mm", Kind::Unitless).unwrap(), 8.0);
// The unit keeps its own power, and an exponent stays a plain number.
assert_eq!(ev("sqrt(9 mm^2)", Kind::Length).unwrap(), 3.0);
assert_eq!(ev("8 mm^3 / 2 mm^2", Kind::Length).unwrap(), 4.0);
assert_eq!(ev("2^3 mm", Kind::Length).unwrap(), 8.0);
// A number next to a name that is not a unit is a product, as before.
assert_eq!(ev("2 width", Kind::Length).unwrap(), 80.0);
// Unchanged: a unit alone, and a unit after a parenthesis.
assert_eq!(ev("width / mm", Kind::Unitless).unwrap(), 40.0);
assert_eq!(ev("(10 / 2) mm", Kind::Length).unwrap(), 5.0);
}
#[test]
fn arithmetic_and_units() {
assert_eq!(ev("10", Kind::Length).unwrap(), 10.0);
assert!((ev("90 deg", Kind::Angle).unwrap() - std::f64::consts::FRAC_PI_2).abs() < 1e-12);
assert_eq!(ev("10 mm", Kind::Length).unwrap(), 10.0);
assert_eq!(ev("1 in", Kind::Length).unwrap(), 25.4);
assert_eq!(ev("2 cm + 5", Kind::Length).unwrap(), 25.0);
assert_eq!(ev("width / 2 + 1", Kind::Length).unwrap(), 21.0);
assert_eq!(ev("width * count", Kind::Length).unwrap(), 120.0);
assert_eq!(ev("-(2+3)*2^2", Kind::Unitless).unwrap(), -20.0);
assert!((ev("45", Kind::Angle).unwrap() - std::f64::consts::FRAC_PI_4).abs() < 1e-12);
assert!((ev("ang / 2", Kind::Angle).unwrap() - std::f64::consts::FRAC_PI_4).abs() < 1e-12);
assert!((ev("ang + 90", Kind::Angle).unwrap() - std::f64::consts::PI).abs() < 1e-12);
assert!((ev("sqrt((3 mm) ^ 2 + (4 mm) ^ 2)", Kind::Length).unwrap() - 5.0).abs() < 1e-12);
assert!((ev("sin(30)", Kind::Unitless).unwrap() - 0.5).abs() < 1e-12);
assert!((ev("2*pi", Kind::Unitless).unwrap() - std::f64::consts::TAU).abs() < 1e-12);
assert_eq!(ev("max(1 mm, 3, 2)", Kind::Length).unwrap(), 3.0);
assert_eq!(ev("min(1 in, 30 mm)", Kind::Length).unwrap(), 25.4);
assert_eq!(ev("1e-3 m", Kind::Length).unwrap(), 1.0);
assert_eq!(ev("1 ft - 1 in", Kind::Length).unwrap(), 304.8 - 25.4);
assert!((ev("atan2(1 mm, 1 mm)", Kind::Angle).unwrap() - std::f64::consts::FRAC_PI_4).abs() < 1e-12);
assert!((ev("atan2(1; 1)", Kind::Angle).unwrap() - std::f64::consts::FRAC_PI_4).abs() < 1e-12);
assert!((ev("exp(ln(5))", Kind::Unitless).unwrap() - 5.0).abs() < 1e-12);
assert!((ev("log(1000)", Kind::Unitless).unwrap() - 3.0).abs() < 1e-12);
assert_eq!(ev("floor(2.7) + ceil(0.2) + round(1.5) + abs(-1)", Kind::Unitless).unwrap(), 6.0);
assert!((ev("1 rad", Kind::Angle).unwrap() - 1.0).abs() < 1e-12);
assert!((ev("acos(0)", Kind::Angle).unwrap() - std::f64::consts::FRAC_PI_2).abs() < 1e-12);
assert_eq!(ev("2 × 3 ÷ 4 − 1", Kind::Unitless).unwrap(), 0.5);
assert_eq!(ev("hypot(3 mm, 4 mm)", Kind::Length).unwrap(), 5.0);
assert_eq!(ev("7 % 4", Kind::Unitless).unwrap(), 3.0);
assert_eq!(ev("width^2 / width", Kind::Length).unwrap(), 40.0);
}
/// A count from a length (`(L - 20) / 210`, the 210 read as unit-less) names the fix (#5901).
#[test]
fn a_length_where_a_count_is_expected_says_to_divide_by_a_length() {
let e = ev("width / 2", Kind::Unitless).unwrap_err().to_string();
assert!(e.contains("expected a unit-less number, got a length") && e.contains("divide by a length"), "{e}");
assert_eq!(ev("floor(width / (6 mm))", Kind::Unitless).unwrap(), 6.0);
let e = ev("45 deg", Kind::Unitless).unwrap_err().to_string();
assert!(!e.contains("divide"), "{e}");
}
#[test]
fn errors() {
assert!(ev("width + ang", Kind::Length).is_err());
let e = ev("10 mm + 5 deg", Kind::Length).unwrap_err().to_string();
assert!(e.contains("cannot add a length and an angle"), "{e}");
assert!(ev("width * width", Kind::Length).unwrap_err().to_string().contains("expected a length"));
assert!(ev("nope", Kind::Length).is_err());
assert!(ev("(1", Kind::Length).is_err());
assert!(ev("1 / 0", Kind::Length).is_err());
assert!(ev("", Kind::Length).is_err());
assert!(ev("1 $ 2", Kind::Length).is_err());
assert!(ev("sqrt(-1)", Kind::Unitless).is_err());
assert!(ev("asin(2)", Kind::Angle).is_err());
assert!(ev("ln(0)", Kind::Unitless).is_err());
assert!(ev("sin(1 mm)", Kind::Unitless).is_err());
assert!(ev("atan2(1 mm, 1 deg)", Kind::Angle).is_err());
assert!(ev("10 ^ 400", Kind::Unitless).is_err());
assert!(ev("width ^ 1.5", Kind::Unitless).is_err());
assert!(ev("max()", Kind::Unitless).is_err());
assert!(ev("frob(1)", Kind::Unitless).is_err());
let deep = "(".repeat(500) + "1" + &")".repeat(500);
assert!(ev(&deep, Kind::Length).is_err());
assert!(ev(&"-".repeat(500), Kind::Length).is_err());
assert!(ev(&"+".repeat(500), Kind::Length).is_err());
assert!(ev(&"width*".repeat(100), Kind::Length).is_err());
assert!(ev(&("2^".repeat(200) + "2"), Kind::Unitless).is_err());
}
/// Hostile input never panics: random strings over the expression alphabet.
#[test]
fn fuzz_never_panics() {
let alphabet: Vec<char> = "0123456789.eE+-*/^(),;% abcdmnpitrsgxw_°×÷−µ\u{0}\u{7f}é\"'".chars().collect();
let words = ["width", "sin(", "atan2(", "mm", "deg", "pi", "1e308", "1e-400", "(", ")", "^", "max(", "in", "count", ","];
let mut seed: u64 = 0x9e37_79b9_7f4a_7c15;
let mut rnd = move || {
seed ^= seed << 13;
seed ^= seed >> 7;
seed ^= seed << 17;
seed
};
for _ in 0..20_000 {
let n = (rnd() % 40) as usize;
let mut s = String::new();
for _ in 0..n {
if rnd() % 4 == 0 {
s.push_str(words[(rnd() % words.len() as u64) as usize]);
} else {
s.push(alphabet[(rnd() % alphabet.len() as u64) as usize]);
}
}
for k in [Kind::Length, Kind::Angle, Kind::Unitless] {
let _ = ev(&s, k);
}
let _ = references(&s);
let _ = rename_reference(&s, "width", "w2");
let _ = is_literal(&s);
}
}
#[test]
fn params_in_order_with_cycles() {
let p = vec![def("b", "a * 2", "mm"), def("a", "10 mm", "mm"), def("x", "y", "mm"), def("y", "z + 1", "mm"), def("z", "x", "mm")];
let (v, e) = eval_params(&p, 1.0);
assert_eq!(v.get("b").unwrap().v, 20.0);
assert!(e.contains_key("x") && e.contains_key("y") && e.contains_key("z"));
assert!(e["x"].contains("circular reference: x → y → z → x"), "{}", e["x"]);
assert_eq!(references("2*width + sin(ang) + 3 mm + pi"), vec!["width".to_string(), "ang".to_string()]);
let (_, e) = eval_params(&[def("s", "s", "mm")], 1.0);
assert!(e["s"].contains("s → s"));
}
#[test]
fn parameter_units() {
let p = vec![
def("a", "2", "in"),
def("b", "a + 1", "in"),
def("c", "b", "mm"),
def("t", "0.5", "rad"),
def("u", "t + 1", "rad"),
def("k", "3", ""),
def("bad", "a + t", "mm"),
def("mixed", "1 in + 2", "mm"),
];
let (v, e) = eval_params(&p, 1.0);
assert!((v["a"].v - 50.8).abs() < 1e-9);
assert!((v["b"].v - 76.2).abs() < 1e-9);
assert!((v["c"].v - 76.2).abs() < 1e-9);
assert!((v["u"].v - 1.5).abs() < 1e-12);
assert_eq!(v["k"], Value::num(3.0));
assert!(e["bad"].contains("cannot add"));
assert!((v["mixed"].v - 27.4).abs() < 1e-9);
assert!((value_in_unit(v["b"], "in") - 3.0).abs() < 1e-12);
assert!((value_in_unit(Value::angle(std::f64::consts::PI), "deg") - 180.0).abs() < 1e-9);
}
#[test]
fn rename_and_literals() {
assert_eq!(rename_reference("width*2 + widths + width(1) + sin(width)", "width", "w"), "w*2 + widths + width(1) + sin(w)");
assert_eq!(rename_reference("10 mm", "mm", "x"), "10 mm");
assert!(is_literal("20") && is_literal("-1.5 in") && is_literal("3 deg"));
assert!(!is_literal("d1") && !is_literal("2 * 3") && !is_literal("2 width"));
assert!(is_bare_number(" -1.5 ") && is_bare_number("+2") && !is_bare_number("20 mm") && !is_bare_number("(2)"));
assert_eq!((length_unit_or_mm(" in "), length_unit_or_mm("deg"), length_unit_or_mm("")), ("in", "mm", "mm"));
}
/// `name = expression` splits at the first `=` when the left side is shaped like a name; the
/// right side is any text, checked by whoever evaluates it.
#[test]
fn definitions_split_on_a_name_and_an_equals_sign() {
let splits = [
("w = 20", "w", "20"),
("w=20", "w", "20"),
(" w = 20 mm ", "w", "20 mm"),
("w = (a + b) / 2", "w", "(a + b) / 2"),
("w = 2 * (3 + sin(45 deg))", "w", "2 * (3 + sin(45 deg))"),
("w = 1 in - 5.4 mm", "w", "1 in - 5.4 mm"),
("_w1 = 1", "_w1", "1"),
("szerokość = 20", "szerokość", "20"),
// A `#` before the name marks it as a new parameter's (#2371).
("#w = 20", "w", "20"),
(" #w=20 mm", "w", "20 mm"),
// Reserved names split too: the parameter check names the reason.
("mm = 5", "mm", "5"),
("w = a = 3", "w", "a = 3"),
// An empty expression is the caller's error to report.
("w =", "w", ""),
("w = ", "w", ""),
];
for (text, name, rhs) in splits {
assert_eq!(definition(text), Some((name, rhs)), "{text:?}");
}
for text in [
"20",
"20 mm",
"width / 2",
"= 20",
"=",
"",
"2w = 3",
"a b = 3",
"a-b = 3",
"w.x = 3",
"(w) = 3",
"-w = 3",
"# = 3",
"#= 3",
"##w = 3",
"# w = 3",
"#2w = 3",
"#w",
"w == 3",
] {
assert_eq!(definition(text), None, "{text:?}");
}
}
/// A reserved name is refused by saying what kind of word it is.
#[test]
fn a_reserved_name_is_refused_by_its_kind() {
assert_eq!(
(reserved_kind("mm"), reserved_kind("deg"), reserved_kind("pi"), reserved_kind("sin"), reserved_kind("width")),
(Some("unit"), Some("unit"), Some("constant"), Some("function"), None)
);
let problem = |n: &str| crate::Document::param_name_problem(n).unwrap_or_default();
assert_eq!(problem("mm"), "`mm` is a unit name, so it cannot be a parameter name");
assert_eq!(problem("sin"), "`sin` is a function name, so it cannot be a parameter name");
assert_eq!(problem("pi"), "`pi` is a constant, so it cannot be a parameter name");
assert_eq!(crate::Document::param_name_problem("width"), None);
assert!(problem("2w").contains("not a valid parameter name"));
}
/// The kept answers of `references` and `eval_params` never stand for different input: an
/// edited expression, unit or design length unit gives its own values.
#[test]
fn kept_parameter_values_follow_every_change() {
assert_eq!(references("width * 2 + 3 mm"), vec!["width".to_string()]);
assert_eq!(references("width * 2 + 3 mm"), vec!["width".to_string()]);
assert!(references("10 mm").is_empty());
let mm = |v: &BTreeMap<String, Value>, n: &str| v.get(n).map(|x| x.v);
let mut defs = vec![def("a", "10 mm", "mm"), def("b", "a * 2", "mm"), def("c", "5", "mm")];
let (first, _) = eval_params(&defs, 1.0);
assert_eq!((mm(&first, "a"), mm(&first, "b"), mm(&first, "c")), (Some(10.0), Some(20.0), Some(5.0)));
defs[0].expr = "12 mm".into();
let (edited, _) = eval_params(&defs, 1.0);
assert_eq!((mm(&edited, "a"), mm(&edited, "b")), (Some(12.0), Some(24.0)));
defs[0].expr = "10 mm".into();
assert_eq!(eval_params(&defs, 1.0).0, first, "back as it was");
// Whatever changes, the kept answer is the one worked out afresh.
for (unit, expr, len) in [("mm", "5", 25.4), ("", "5", 25.4), ("in", "5", 1.0), ("deg", "5", 1.0), ("", "5", 1.0)] {
defs[2].unit = unit.into();
defs[2].expr = expr.into();
assert_eq!(eval_params(&defs, len), eval_params_uncached(&defs, len), "{unit} {expr} {len}");
}
defs[2].expr = "bad +".into();
assert!(eval_params(&defs, 1.0).1.contains_key("c"));
}
}