665bfac0b339
num_math.rs
//! Basic arithmetic typed into a number field (#3195): `960/2`, `(3+4)*2`, `100*2`, and, in a
//! field that knows the value it showed, a leading operator that applies to it: `*2` doubles,
//! `/2` halves, `+50` adds 50, as the issue's reporter describes for After Effects (not confirmed
//! in public docs). A leading `-` is a negative number (`-50`), not a subtraction. (Hot text used
//! to read `+50` as 50; it now adds 50.)
//!
//! This is a small parser for numbers and `+ - * / ( )` only: no names, no functions, nothing is
//! run as code (expressions, `crates/expr`, are a different thing). The text is bounded in
//! length and nesting, every step must stay finite, and a division by zero is no value. Text it
//! can't read is `None`, so the field keeps its value.
/// The longest text read as arithmetic (characters, after removing spaces).
const MAX_LEN: usize = 256;
/// How deeply brackets and signs (`-(-(โฆ))`, `--5`) may nest.
const MAX_DEPTH: usize = 32;
/// A typed leading operator: what it does to the value the field showed.
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum Step {
/// `+n`
Add(f64),
/// `*n`
Mul(f64),
/// `/n` (never zero)
Div(f64),
}
impl Step {
/// `current` changed by the step; `None` when that isn't a finite number.
pub fn apply(self, current: f64) -> Option<f64> {
match self {
Step::Add(n) => finite(current + n),
Step::Mul(k) => finite(current * k),
Step::Div(n) => divide(current, n),
}
}
/// The factor a `*` or `/` step multiplies by (`None` for `+`), for other layers that scale
/// their own value by it.
pub fn factor(self) -> Option<f64> {
match self {
Step::Add(_) => None,
Step::Mul(k) => finite(k),
Step::Div(n) => divide(1.0, n),
}
}
}
/// What typed text says: a value, or (with a leading `+`, `*` or `/`) a step from the value shown.
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum Typed {
Value(f64),
Step(Step),
}
/// Read typed `text`. With `steps`, a leading `+`, `*` or `/` is a [`Step`]; without (a field
/// that reads its text on every keystroke, where a step would compound) a leading `+` is a plain
/// sign and a leading `*` or `/` is no value. Spaces, including thousands groups, are ignored
/// (as egui's own parser did) and `โ` (U+2212) is a minus. `,` is a decimal point: hot text
/// always read it so, and the dialog fields, whose egui parser rejected it, now do too (so
/// `1,5` is 1.5 and `1,000` is 1, not a thousand). `None` for anything else that isn't a finite
/// number.
pub fn read(text: &str, steps: bool) -> Option<Typed> {
let s: String = text
.chars()
.filter(|c| !c.is_whitespace())
.map(|c| match c {
'โ' => '-',
',' => '.',
c => c,
})
.collect();
if s.is_empty() || s.chars().count() > MAX_LEN {
return None;
}
let first = s.chars().next()?;
if steps && matches!(first, '+' | '*' | '/') {
let operand = parse(s.get(first.len_utf8()..)?)?;
return Some(Typed::Step(match first {
'+' => Step::Add(operand),
'*' => Step::Mul(operand),
_ => Step::Div((operand != 0.0).then_some(operand)?),
}));
}
parse(&s).map(Typed::Value)
}
/// The value typed `text` stands for: [`read`], with a step applied to `current` (the value the
/// field showed; without it a leading `*` or `/` is no value and `+` only a sign).
pub fn calc(text: &str, current: Option<f64>) -> Option<f64> {
match read(text, current.is_some())? {
Typed::Value(v) => Some(v),
Typed::Step(step) => step.apply(current.filter(|c| c.is_finite())?),
}
}
/// The whole of `s` as an expression.
fn parse(s: &str) -> Option<f64> {
let mut p = Parser { chars: s.chars().peekable(), depth: 0 };
let v = p.expr()?;
if p.chars.next().is_some() {
return None;
}
finite(v)
}
/// `a / b`; `None` for a division by zero.
fn divide(a: f64, b: f64) -> Option<f64> {
if b == 0.0 {
return None;
}
finite(a / b)
}
/// A finite result, or `None`.
fn finite(v: f64) -> Option<f64> {
v.is_finite().then_some(v)
}
/// A recursive-descent reader of `expr := term (('+'|'-') term)*`,
/// `term := factor (('*'|'/') factor)*`, `factor := ('+'|'-') factor | '(' expr ')' | number`.
struct Parser<'a> {
chars: std::iter::Peekable<std::str::Chars<'a>>,
/// The brackets and signs open around the current point.
depth: usize,
}
impl Parser<'_> {
/// Reads a sum or difference of terms, left to right.
/// Returns `None` on a syntax error or a non-finite result.
fn expr(&mut self) -> Option<f64> {
let mut v = self.term()?;
while let Some(&op) = self.chars.peek() {
match op {
'+' => {
self.chars.next();
v = finite(v + self.term()?)?;
}
'-' => {
self.chars.next();
v = finite(v - self.term()?)?;
}
_ => break,
}
}
Some(v)
}
/// Reads a product or quotient of factors, left to right.
/// Returns `None` on a syntax error, a division by zero or a non-finite result.
fn term(&mut self) -> Option<f64> {
let mut v = self.factor()?;
while let Some(&op) = self.chars.peek() {
match op {
'*' => {
self.chars.next();
v = finite(v * self.factor()?)?;
}
'/' => {
self.chars.next();
v = divide(v, self.factor()?)?;
}
_ => break,
}
}
Some(v)
}
/// Reads a signed factor, a bracketed expression or a number.
/// Nesting deeper than `MAX_DEPTH` gives `None`.
fn factor(&mut self) -> Option<f64> {
let c = *self.chars.peek()?;
match c {
'+' | '-' | '(' => {
self.depth = self.depth.checked_add(1)?;
if self.depth > MAX_DEPTH {
return None;
}
self.chars.next();
let v = if c == '(' {
let v = self.expr()?;
if self.chars.next() != Some(')') {
return None;
}
v
} else {
let v = self.factor()?;
if c == '-' { -v } else { v }
};
self.depth = self.depth.saturating_sub(1);
Some(v)
}
_ => self.number(),
}
}
/// Digits with at most one decimal point and an optional exponent (`12`, `1.5`, `.5`, `2.`,
/// `2e2`, `1.5E-3`).
fn number(&mut self) -> Option<f64> {
let mut text = String::new();
let mut point = false;
while let Some(&c) = self.chars.peek() {
if c.is_ascii_digit() {
text.push(c);
} else if c == '.' && !point {
point = true;
text.push(c);
} else {
break;
}
self.chars.next();
}
if !text.chars().any(|c| c.is_ascii_digit()) {
return None;
}
if let Some(&e) = self.chars.peek()
&& matches!(e, 'e' | 'E')
{
self.chars.next();
text.push('e');
if let Some(&sign) = self.chars.peek()
&& matches!(sign, '+' | '-')
{
self.chars.next();
text.push(sign);
}
let mut digits = false;
while let Some(&c) = self.chars.peek() {
if !c.is_ascii_digit() {
break;
}
digits = true;
text.push(c);
self.chars.next();
}
if !digits {
return None;
}
}
finite(text.parse::<f64>().ok()?)
}
}
#[cfg(test)]
mod tests {
use super::calc as eval;
/// Evaluates `text` with no current value, so a leading operator has nothing to apply to.
fn abs(text: &str) -> Option<f64> {
eval(text, None)
}
#[test]
fn plain_numbers_read_as_before() {
assert_eq!(abs("100"), Some(100.0));
assert_eq!(abs("-12.5"), Some(-12.5));
assert_eq!(abs(" 12,5 "), Some(12.5), "a decimal comma");
assert_eq!(abs("1 000"), Some(1000.0), "a thousands space");
assert_eq!(abs("โ3"), Some(-3.0), "the minus sign U+2212");
assert_eq!(abs("1e3"), Some(1000.0));
assert_eq!(abs(".5"), Some(0.5));
}
#[test]
fn arithmetic() {
assert_eq!(abs("960/2"), Some(480.0));
assert_eq!(abs("100*2"), Some(200.0));
assert_eq!(abs("(3+4)*2"), Some(14.0));
assert_eq!(abs("3+4*2"), Some(11.0), "* before +");
assert_eq!(abs("10-2-3"), Some(5.0), "left to right");
assert_eq!(abs("8/4/2"), Some(1.0), "left to right");
assert_eq!(abs("-(2+3)"), Some(-5.0));
assert_eq!(abs("2*-3"), Some(-6.0));
assert_eq!(abs("1.5 * 2"), Some(3.0));
assert_eq!(abs("((((1))))"), Some(1.0));
assert_eq!(abs("100+50"), Some(150.0));
assert_eq!(abs("100-50"), Some(50.0));
assert_eq!(abs("2e2*2"), Some(400.0), "an exponent inside arithmetic");
assert_eq!(abs("1E-3*1000"), Some(1.0));
assert_eq!(abs("1e+2/4"), Some(25.0));
}
#[test]
fn steps_are_read_as_steps() {
use super::{Step, Typed, read};
assert_eq!(read("*2", true), Some(Typed::Step(Step::Mul(2.0))));
assert_eq!(read("/4", true), Some(Typed::Step(Step::Div(4.0))));
assert_eq!(read("+(1+2)", true), Some(Typed::Step(Step::Add(3.0))));
assert_eq!(read("-5", true), Some(Typed::Value(-5.0)));
assert_eq!(read("+5", false), Some(Typed::Value(5.0)));
assert_eq!(read("/0", true), None);
assert_eq!(Step::Div(4.0).factor(), Some(0.25));
assert_eq!(Step::Mul(3.0).factor(), Some(3.0));
assert_eq!(Step::Add(3.0).factor(), None);
assert_eq!(Step::Div(1e-320).factor(), None, "a factor that overflows");
assert_eq!(Step::Div(3.0).apply(3.0), Some(1.0), "a division, not a reciprocal factor");
}
#[test]
fn a_leading_operator_applies_to_the_current_value() {
assert_eq!(eval("*2", Some(100.0)), Some(200.0));
assert_eq!(eval("/2", Some(100.0)), Some(50.0));
assert_eq!(eval("+50", Some(100.0)), Some(150.0));
assert_eq!(eval("*(1+1)", Some(3.0)), Some(6.0));
assert_eq!(eval("+-50", Some(100.0)), Some(50.0));
// A leading minus is a negative number, not a subtraction.
assert_eq!(eval("-50", Some(100.0)), Some(-50.0));
assert_eq!(eval("-50*2", Some(100.0)), Some(-100.0));
// Without the current value there is nothing to apply it to; a `+` is only a sign.
assert_eq!(eval("*2", None), None);
assert_eq!(eval("/2", None), None);
assert_eq!(eval("+50", None), Some(50.0));
assert_eq!(eval("*2", Some(f64::NAN)), None);
assert_eq!(eval("+1", Some(f64::INFINITY)), None);
assert_eq!(eval("/0", Some(100.0)), None);
assert_eq!(eval("/(1-1)", Some(100.0)), None);
assert_eq!(eval("*", Some(100.0)), None);
assert_eq!(eval("*1e400", Some(1.0)), None);
// Overflow past the largest finite value.
assert_eq!(eval(&format!("*{}", "9".repeat(20)), Some(1e300)), None);
assert_eq!(eval("/0.0000000001", Some(1e300)), None);
}
#[test]
fn invalid_or_hostile_text_is_no_value() {
for text in [
"", " ", "*", "/", "1+", "+", "-", "2**3", "2//3", "1/0", "0/0", "-1/0", "1/(2-2)", "(1", "1)", "()", "(1+2", "abc", "NaN", "nan", "inf", "-inf",
"infinity", "1e999", "-1e999", "1..2", "1.2.3", ".", "1e", "2x", "x*2", "1+a", "5;rm", "1,2,3", "0x10", "1_000", "%", "50%",
] {
assert_eq!(abs(text), None, "{text:?}");
assert_eq!(eval(text, Some(10.0)), None, "{text:?} with a current value");
}
// Far too long: rejected by length before any reading.
assert_eq!(abs(&format!("{}1{}", "(".repeat(1000), ")".repeat(1000))), None);
assert_eq!(abs(&format!("{}5", "-".repeat(10_000))), None);
assert_eq!(abs(&"(".repeat(10_000)), None);
assert_eq!(abs(&"1".repeat(10_000)), None);
assert_eq!(abs(&"1+".repeat(5_000)), None);
// Short enough, but nested past the depth bound.
assert_eq!(abs(&format!("{}1{}", "(".repeat(100), ")".repeat(100))), None);
assert_eq!(abs(&format!("{}5", "-".repeat(200))), None);
assert_eq!(abs(&format!("2*{}5", "-+".repeat(100))), None);
// Nesting within the bound reads.
assert_eq!(abs(&format!("{}1{}", "(".repeat(20), ")".repeat(20))), Some(1.0));
assert_eq!(abs("--5"), Some(5.0));
// Overflow on the way is no value.
assert_eq!(abs("1e308*10"), None);
assert_eq!(abs("1e308+1e308"), None);
assert_eq!(abs("1e200*1e200/1e200"), None, "an infinite step is rejected even if the result would be finite");
// The largest numbers the length allows still multiply to a finite value.
let big = "9".repeat(120);
assert!(abs(&format!("{big}*{big}")).is_some_and(f64::is_finite));
}
/// The result is always finite (no NaN reaches a property).
#[test]
fn results_are_finite() {
for text in ["0*1e308", "1e-320/1e10", "0-0", "-0"] {
if let Some(v) = abs(text) {
assert!(v.is_finite(), "{text:?} โ {v}");
}
}
}
/// A standard numeric editor (dialogs) reads typed arithmetic too.
/// (egui's own parser read `960/2` as no value, so the field stayed 10.)
#[test]
fn a_drag_value_reads_typed_arithmetic() {
use egui::{Context, Event, Key, Modifiers, PointerButton, Pos2, RawInput, Rect, pos2, vec2};
let ctx = Context::default();
let mut value = 10.0_f64;
let mut time = 0.0;
let field = Rect::from_min_size(pos2(100.0, 100.0), vec2(80.0, 20.0));
let mut frame = |events: Vec<Event>, value: &mut f64| {
time += 0.02;
let raw = RawInput {
screen_rect: Some(Rect::from_min_size(Pos2::ZERO, vec2(400.0, 300.0))),
time: Some(time),
events,
focused: true,
..Default::default()
};
let mut out = ctx.run_ui(raw, |ui| {
ui.put(field, crate::widgets::drag_value(egui::DragValue::new(&mut *value).speed(1.0)));
});
out.textures_delta.clear();
};
let p = field.center();
frame(vec![], &mut value);
frame(
vec![Event::PointerMoved(p), Event::PointerButton { pos: p, button: PointerButton::Primary, pressed: true, modifiers: Modifiers::NONE }],
&mut value,
);
frame(vec![Event::PointerButton { pos: p, button: PointerButton::Primary, pressed: false, modifiers: Modifiers::NONE }], &mut value);
frame(vec![], &mut value);
frame(vec![Event::Text("960/2".into())], &mut value);
frame(vec![Event::Key { key: Key::Enter, physical_key: None, pressed: true, repeat: false, modifiers: Modifiers::NONE }], &mut value);
frame(vec![], &mut value);
assert_eq!(value, 480.0);
}
}
No file is open. Choose one in the tree, or press Ctrl+O (โO on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.