use crate::numeric::{Length, LengthUnit, Number, ParseError, Percentage};
use crate::var::VarReference;
use muskitty_css::parser::{BlockKind, ComponentValue, Function};
use muskitty_css::tokenizer::Token;
#[derive(Debug, Clone)]
pub enum MathExpression {
Length(Length),
Percentage(Percentage),
Number(Number),
Constant(MathConstant),
Var(VarReference),
Negate(Box<MathExpression>),
Sum(Box<MathExpression>, Box<MathExpression>),
Product(Box<MathExpression>, Box<MathExpression>),
Quotient(Box<MathExpression>, Box<MathExpression>),
Min(Vec<MathExpression>),
Max(Vec<MathExpression>),
Clamp {
min: Box<MathExpression>,
val: Box<MathExpression>,
max: Box<MathExpression>,
},
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum MathConstant {
E,
Pi,
Infinity,
NegInfinity,
NaN,
}
impl MathConstant {
pub fn to_str(self) -> &'static str {
match self {
Self::E => "e",
Self::Pi => "pi",
Self::Infinity => "infinity",
Self::NegInfinity => "-infinity",
Self::NaN => "NaN",
}
}
}
pub fn parse_calc(input: &str) -> Result<MathExpression, ParseError> {
let cvs = muskitty_css::parse_list_of_component_values(input);
parse_calc_from_cvs(&cvs)
}
pub fn parse_calc_from_cvs(cvs: &[ComponentValue]) -> Result<MathExpression, ParseError> {
let cv = crate::numeric::single_non_ws_cv(cvs)?;
match cv {
ComponentValue::Function(f) if f.name.eq_ignore_ascii_case("calc") => {
parse_math_function_body(f)
}
_ => Err(ParseError::new("expected calc() function")),
}
}
pub fn parse_math_function(input: &str) -> Result<MathExpression, ParseError> {
let cvs = muskitty_css::parse_list_of_component_values(input);
parse_math_function_from_cvs(&cvs)
}
pub fn parse_math_function_from_cvs(cvs: &[ComponentValue]) -> Result<MathExpression, ParseError> {
let cv = crate::numeric::single_non_ws_cv(cvs)?;
match cv {
ComponentValue::Function(f) => parse_math_function_body(f),
_ => Err(ParseError::new(
"expected a math function (calc/min/max/clamp)",
)),
}
}
fn parse_math_function_body(f: &Function) -> Result<MathExpression, ParseError> {
let name_lower = f.name.to_ascii_lowercase();
match name_lower.as_str() {
"calc" => {
let refs: Vec<&ComponentValue> = f.value.iter().collect();
let mut parser = CalcParser::new(&refs);
let expr = parser.parse_calc_sum()?;
parser.expect_eof()?;
Ok(expr)
}
"min" | "max" => {
let args = parse_comma_separated_calc_sums(&f.value)?;
if args.is_empty() {
return Err(ParseError::new(format!(
"{}() requires at least one argument",
f.name
)));
}
if name_lower == "min" {
Ok(MathExpression::Min(args))
} else {
Ok(MathExpression::Max(args))
}
}
"clamp" => {
let args = parse_comma_separated_calc_sums(&f.value)?;
if args.len() != 3 {
return Err(ParseError::new(format!(
"clamp() requires exactly 3 arguments, got {}",
args.len()
)));
}
let mut iter = args.into_iter();
let min = iter.next().unwrap();
let val = iter.next().unwrap();
let max = iter.next().unwrap();
Ok(MathExpression::Clamp {
min: Box::new(min),
val: Box::new(val),
max: Box::new(max),
})
}
"var" => Ok(MathExpression::Var(VarReference::from_function(f)?)),
_ => Err(ParseError::new(format!(
"unsupported math function: {}()",
f.name
))),
}
}
fn parse_comma_separated_calc_sums(
cvs: &[ComponentValue],
) -> Result<Vec<MathExpression>, ParseError> {
let mut args = Vec::new();
let mut current: Vec<&ComponentValue> = Vec::new();
for cv in cvs {
if matches!(cv, ComponentValue::PreservedToken(Token::Comma)) {
let mut parser = CalcParser::new(¤t);
let expr = parser.parse_calc_sum()?;
parser.expect_eof()?;
args.push(expr);
current.clear();
} else {
current.push(cv);
}
}
if !current.is_empty() {
let mut parser = CalcParser::new(¤t);
let expr = parser.parse_calc_sum()?;
parser.expect_eof()?;
args.push(expr);
}
Ok(args)
}
struct CalcParser<'a> {
cvs: &'a [&'a ComponentValue],
pos: usize,
}
impl<'a> CalcParser<'a> {
fn new(cvs: &'a [&'a ComponentValue]) -> Self {
Self { cvs, pos: 0 }
}
fn peek(&self) -> Option<&'a ComponentValue> {
self.cvs.get(self.pos).copied()
}
fn advance(&mut self) -> Option<&'a ComponentValue> {
let cv = self.cvs.get(self.pos).copied()?;
self.pos += 1;
Some(cv)
}
fn skip_whitespace(&mut self) {
while let Some(cv) = self.peek() {
if is_ws(cv) {
self.pos += 1;
} else {
break;
}
}
}
fn expect_eof(&self) -> Result<(), ParseError> {
for cv in self.cvs[self.pos..].iter().copied() {
if !is_ws(cv) {
return Err(ParseError::new(
"unexpected trailing content in math expression",
));
}
}
Ok(())
}
fn parse_calc_sum(&mut self) -> Result<MathExpression, ParseError> {
let mut left = self.parse_calc_product()?;
loop {
self.skip_whitespace();
match self.peek() {
Some(ComponentValue::PreservedToken(Token::Delim('+'))) => {
self.advance();
let right = self.parse_calc_product()?;
left = MathExpression::Sum(Box::new(left), Box::new(right));
}
Some(ComponentValue::PreservedToken(Token::Delim('-'))) => {
self.advance();
let right = self.parse_calc_product()?;
left = MathExpression::Sum(
Box::new(left),
Box::new(MathExpression::Negate(Box::new(right))),
);
}
_ => break,
}
}
Ok(left)
}
fn parse_calc_product(&mut self) -> Result<MathExpression, ParseError> {
let mut left = self.parse_calc_value()?;
loop {
let saved_pos = self.pos;
self.skip_whitespace();
match self.peek() {
Some(ComponentValue::PreservedToken(Token::Delim('*'))) => {
self.advance();
let right = self.parse_calc_value()?;
left = MathExpression::Product(Box::new(left), Box::new(right));
}
Some(ComponentValue::PreservedToken(Token::Delim('/'))) => {
self.advance();
let right = self.parse_calc_value()?;
left = MathExpression::Quotient(Box::new(left), Box::new(right));
}
_ => {
self.pos = saved_pos;
break;
}
}
}
Ok(left)
}
fn parse_calc_value(&mut self) -> Result<MathExpression, ParseError> {
self.skip_whitespace();
let cv = self
.peek()
.ok_or_else(|| ParseError::new("unexpected end of calc expression"))?;
match cv {
ComponentValue::PreservedToken(Token::Number(numeric)) => {
let value = numeric.value;
self.advance();
Ok(MathExpression::Number(Number { value }))
}
ComponentValue::PreservedToken(Token::Percentage(numeric)) => {
let value = numeric.value;
self.advance();
Ok(MathExpression::Percentage(Percentage { value }))
}
ComponentValue::PreservedToken(Token::Dimension(numeric, unit)) => {
let value = numeric.value;
let unit = unit.clone();
self.advance();
match LengthUnit::parse_unit(&unit) {
Some(length_unit) => Ok(MathExpression::Length(Length {
value,
unit: length_unit,
})),
None => Err(ParseError::new(format!(
"calc() currently supports only length dimensions, got unit: {unit}"
))),
}
}
ComponentValue::PreservedToken(Token::Ident(s)) => {
let s_lower = s.to_ascii_lowercase();
self.advance();
match s_lower.as_str() {
"e" => Ok(MathExpression::Constant(MathConstant::E)),
"pi" => Ok(MathExpression::Constant(MathConstant::Pi)),
"infinity" => Ok(MathExpression::Constant(MathConstant::Infinity)),
"-infinity" => Ok(MathExpression::Constant(MathConstant::NegInfinity)),
"nan" => Ok(MathExpression::Constant(MathConstant::NaN)),
_ => Err(ParseError::new(format!(
"unknown calc constant or identifier: {s}"
))),
}
}
ComponentValue::SimpleBlock(block) if matches!(block.kind, BlockKind::Paren) => {
self.advance();
let refs: Vec<&ComponentValue> = block.value.iter().collect();
let mut inner = CalcParser::new(&refs);
let expr = inner.parse_calc_sum()?;
inner.expect_eof()?;
Ok(expr)
}
ComponentValue::Function(f) => {
let f_ref = f;
self.advance();
parse_math_function_body(f_ref)
}
_ => Err(ParseError::new("unexpected token in calc expression")),
}
}
}
fn is_ws(cv: &ComponentValue) -> bool {
matches!(cv, ComponentValue::PreservedToken(Token::Whitespace))
}