use std::collections::HashMap;
use std::hash::BuildHasher;
use std::io::Error;
use crate::error::printable;
use crate::preprocess::{MAX_NESTING_DEPTH, nesting_error};
#[derive(Debug, Clone, PartialEq)]
pub enum EvalValue {
Number(f32),
Str(String),
}
#[derive(Debug, Clone, PartialEq)]
enum Tok {
Num(f32),
Str(String),
Ident(String),
Op(char),
}
fn unsupported(expr: &str) -> Error {
error!(
"__EVAL expression not supported by dayzmake: {}",
printable(expr)
)
}
fn tokenize(expr: &str) -> Result<Vec<Tok>, Error> {
let chars: Vec<char> = expr.chars().collect();
let mut toks = Vec::new();
let mut i = 0;
while let Some(&c) = chars.get(i) {
if c.is_whitespace() {
i += 1;
} else if c.is_ascii_digit()
|| (c == '.' && chars.get(i + 1).is_some_and(char::is_ascii_digit))
{
let start = i;
while matches!(chars.get(i), Some(c) if c.is_ascii_digit() || *c == '.') {
i += 1;
}
let text: String = chars.get(start..i).unwrap_or(&[]).iter().collect();
toks.push(Tok::Num(text.parse().map_err(|_| unsupported(expr))?));
} else if c == '"' {
i += 1;
let mut s = String::new();
loop {
match chars.get(i) {
None => return Err(unsupported(expr)),
Some('"') if chars.get(i + 1) == Some(&'"') => {
s.push('"');
i += 2;
}
Some('"') => {
i += 1;
break;
}
Some(&ch) => {
s.push(ch);
i += 1;
}
}
}
toks.push(Tok::Str(s));
} else if c.is_ascii_alphabetic() || c == '_' {
let start = i;
while matches!(chars.get(i), Some(c) if c.is_ascii_alphanumeric() || *c == '_') {
i += 1;
}
toks.push(Tok::Ident(
chars.get(start..i).unwrap_or(&[]).iter().collect(),
));
} else if "+-*/%^()".contains(c) {
toks.push(Tok::Op(c));
i += 1;
} else {
return Err(unsupported(expr));
}
}
Ok(toks)
}
struct Parser<'a, S: BuildHasher> {
toks: Vec<Tok>,
pos: usize,
expr: &'a str,
vars: &'a HashMap<String, EvalValue, S>,
depth: usize,
}
impl<S: BuildHasher> Parser<'_, S> {
fn peek_op(&self) -> Option<char> {
match self.toks.get(self.pos) {
Some(Tok::Op(c)) => Some(*c),
_ => None,
}
}
fn prec(op: char) -> Option<u8> {
match op {
'+' | '-' => Some(1),
'*' | '/' | '%' => Some(2),
'^' => Some(3),
_ => None,
}
}
fn nested<T>(&mut self, f: impl FnOnce(&mut Self) -> Result<T, Error>) -> Result<T, Error> {
if self.depth >= MAX_NESTING_DEPTH {
return Err(nesting_error());
}
self.depth += 1;
let result = f(self);
self.depth -= 1;
result
}
fn expr(&mut self, min_prec: u8) -> Result<EvalValue, Error> {
let mut lhs = self.atom()?;
while let Some(op) = self.peek_op() {
let prec = match Self::prec(op) {
Some(p) if p >= min_prec => p,
_ => break,
};
self.pos += 1;
let rhs = self.nested(|p| p.expr(if op == '^' { prec } else { prec + 1 }))?;
lhs = self.apply(op, lhs, rhs)?;
}
Ok(lhs)
}
fn atom(&mut self) -> Result<EvalValue, Error> {
self.nested(Self::atom_inner)
}
fn atom_inner(&mut self) -> Result<EvalValue, Error> {
let tok = self
.toks
.get(self.pos)
.cloned()
.ok_or_else(|| unsupported(self.expr))?;
self.pos += 1;
match tok {
Tok::Num(n) => Ok(EvalValue::Number(n)),
Tok::Str(s) => Ok(EvalValue::Str(s)),
Tok::Ident(name) => self
.vars
.get(&name)
.cloned()
.ok_or_else(|| unsupported(self.expr)),
Tok::Op('-') => match self.atom()? {
EvalValue::Number(n) => Ok(EvalValue::Number(-n)),
EvalValue::Str(_) => Err(unsupported(self.expr)),
},
Tok::Op('(') => {
let v = self.expr(1)?;
if self.peek_op() != Some(')') {
return Err(unsupported(self.expr));
}
self.pos += 1;
Ok(v)
}
Tok::Op(_) => Err(unsupported(self.expr)),
}
}
fn apply(&self, op: char, a: EvalValue, b: EvalValue) -> Result<EvalValue, Error> {
match (a, b) {
(EvalValue::Number(x), EvalValue::Number(y)) => Ok(EvalValue::Number(match op {
'+' => x + y,
'-' => x - y,
'*' => x * y,
'/' => {
if matches!(y.classify(), std::num::FpCategory::Zero) {
return Err(error!(
"__EVAL: division by zero in: {}",
printable(self.expr)
));
}
x / y
}
'%' => {
if matches!(y.classify(), std::num::FpCategory::Zero) {
return Err(error!(
"__EVAL: division by zero in: {}",
printable(self.expr)
));
}
x % y
}
'^' => x.powf(y),
_ => return Err(unsupported(self.expr)),
})),
(EvalValue::Str(x), EvalValue::Str(y)) if op == '+' => Ok(EvalValue::Str(x + &y)),
_ => Err(unsupported(self.expr)),
}
}
}
pub fn eval<S: BuildHasher>(
expr: &str,
vars: &mut HashMap<String, EvalValue, S>,
) -> Result<EvalValue, Error> {
let toks = tokenize(expr)?;
let mut parser = Parser {
toks,
pos: 0,
expr,
vars,
depth: 0,
};
let value = parser.expr(1)?;
if parser.pos != parser.toks.len() {
return Err(unsupported(expr));
}
Ok(value)
}
pub fn exec<S: BuildHasher>(
stmts: &str,
vars: &mut HashMap<String, EvalValue, S>,
) -> Result<(), Error> {
let mut in_string = false;
let mut current = String::new();
let mut parts = Vec::new();
for c in stmts.chars() {
if c == '"' {
in_string = !in_string;
}
if c == ';' && !in_string {
parts.push(std::mem::take(&mut current));
} else {
current.push(c);
}
}
parts.push(current);
for stmt in parts.iter().map(|s| s.trim()).filter(|s| !s.is_empty()) {
let eq = stmt.find('=').ok_or_else(|| {
error!(
"__EXEC statement not supported by dayzmake: {}",
printable(stmt)
)
})?;
let name = stmt[..eq].trim();
if name.is_empty() || !name.chars().all(|c| c.is_ascii_alphanumeric() || c == '_') {
return Err(error!(
"__EXEC statement not supported by dayzmake: {}",
printable(stmt)
));
}
let value = eval(stmt[eq + 1..].trim(), vars)?;
vars.insert(name.to_string(), value);
}
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
fn ev(s: &str) -> Result<EvalValue, Error> {
eval(s, &mut HashMap::new())
}
#[test]
fn arithmetic_precedence() {
assert_eq!(ev("1+2*3").unwrap(), EvalValue::Number(7.0));
assert_eq!(ev("2^3^2").unwrap(), EvalValue::Number(512.0));
assert_eq!(ev("2*3^2").unwrap(), EvalValue::Number(18.0));
assert_eq!(ev("(1+2)*3/2").unwrap(), EvalValue::Number(4.5));
}
#[test]
fn unsupported_is_error() {
assert!(
ev("floor 2.7")
.unwrap_err()
.to_string()
.contains("not supported")
);
assert!(
ev("1 > 0")
.unwrap_err()
.to_string()
.contains("not supported")
);
}
}