use crate::ast::{col_name, is_omitted_arg, Expr};
use crate::error::ExcelError;
use alloc::string::{String, ToString};
use alloc::vec;
use core::fmt;
fn node_bp(e: &Expr) -> usize {
match e {
Expr::Binary { op, .. } => op.binding_power().0,
Expr::Unary { op, .. } => op.binding_power(),
_ => usize::MAX,
}
}
fn write_number(out: &mut String, n: f64) {
if n.is_nan() {
out.push_str(ExcelError::Num.literal());
} else if n.is_infinite() {
out.push_str(if n > 0.0 { "1E+999" } else { "-1E+999" });
} else {
let _ = fmt::Write::write_fmt(out, format_args!("{n}"));
}
}
enum Job<'a> {
Str(&'static str),
Expr {
e: &'a Expr,
min_bp: usize,
wrap_eq: bool,
},
Args(&'a [Expr]),
}
impl fmt::Display for Expr {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let mut out = String::new();
let mut stack = vec![Job::Expr {
e: self,
min_bp: 0,
wrap_eq: false,
}];
while let Some(job) = stack.pop() {
match job {
Job::Str(s) => out.push_str(s),
Job::Args(args) => {
for (i, a) in args.iter().enumerate().rev() {
if !is_omitted_arg(a) {
stack.push(Job::Expr {
e: a,
min_bp: 0,
wrap_eq: false,
});
}
if i > 0 {
stack.push(Job::Str(","));
}
}
}
Job::Expr { e, min_bp, wrap_eq } => {
let bp = node_bp(e);
let wrap = bp < min_bp || (wrap_eq && bp == min_bp);
if wrap {
out.push('(');
stack.push(Job::Str(")"));
}
match *e {
Expr::Number(n) => write_number(&mut out, n),
Expr::Text(ref s) => {
out.push('"');
out.push_str(&s.replace('"', "\"\""));
out.push('"');
}
Expr::Boolean(b) => out.push_str(if b { "TRUE" } else { "FALSE" }),
Expr::Error(err) => out.push_str(err.literal()),
Expr::CellRef {
col,
row,
col_abs,
row_abs,
} => {
if col_abs {
out.push('$');
}
out.push_str(&col_name(col));
if row_abs {
out.push('$');
}
let _ = fmt::Write::write_fmt(&mut out, format_args!("{row}"));
}
Expr::Range { ref start, ref end } => {
out.push_str(&start.to_string());
out.push(':');
out.push_str(&end.to_string());
}
Expr::Unary { op, ref expr } => {
if op.is_prefix() {
out.push_str(op.symbol());
stack.push(Job::Expr {
e: expr,
min_bp: op.binding_power(),
wrap_eq: false,
});
} else {
stack.push(Job::Str(op.symbol()));
stack.push(Job::Expr {
e: expr,
min_bp: op.binding_power(),
wrap_eq: false,
});
}
}
Expr::Binary {
op,
ref left,
ref right,
} => {
let (lbp, rbp) = op.binding_power();
let right_assoc = lbp == rbp;
stack.push(Job::Expr {
e: right,
min_bp: rbp,
wrap_eq: !right_assoc,
});
stack.push(Job::Str(op.symbol()));
stack.push(Job::Expr {
e: left,
min_bp: lbp,
wrap_eq: right_assoc,
});
}
Expr::Function { ref name, ref args } => {
out.push_str(&name.to_ascii_uppercase());
out.push('(');
stack.push(Job::Str(")"));
stack.push(Job::Args(args));
}
}
}
}
}
f.write_str(&out)
}
}
#[must_use]
pub fn to_formula(expr: &Expr) -> String {
expr.to_string()
}