struct Criteria {
op : String
operand : Value
}
fn parse_criteria(v : Value) -> Criteria {
let sv = scalarize(v)
match sv {
Text(s) => {
let ops = [">=", "<=", "<>", ">", "<", "="]
for op in ops {
if s.has_prefix(op) {
let rest = s.substring(start=op.length())
let operand = match parse_excel_number(rest) {
Ok(d) => Value::Num(d)
Err(_) => Value::Text(rest)
}
return { op, operand }
}
}
match parse_excel_number(s) {
Ok(d) => { op: "=", operand: Value::Num(d) }
Err(_) => { op: "=", operand: sv }
}
}
_ => { op: "=", operand: sv }
}
}
enum CritToken {
Lit(Char)
Any
Star
}
// Excel glob: * any run, ? one char, ~ escapes the next char.
// Case-insensitive.
fn wildcard_match(pattern : String, text : String) -> Bool {
let pc = Array::from_iter(@value.ascii_lower(pattern).iter())
let toks : Array[CritToken] = []
let mut i = 0
while i < pc.length() {
let c = pc[i]
if c == '~' && i + 1 < pc.length() {
toks.push(Lit(pc[i + 1]))
i += 2
} else if c == '*' {
toks.push(Star)
i += 1
} else if c == '?' {
toks.push(Any)
i += 1
} else {
toks.push(Lit(c))
i += 1
}
}
let tc = Array::from_iter(@value.ascii_lower(text).iter())
let mut ti = 0
let mut pi = 0
let mut star = -1
let mut mark = 0
while ti < tc.length() {
if pi < toks.length() {
match toks[pi] {
Lit(c) =>
if c == tc[ti] {
pi += 1
ti += 1
continue
}
Any => {
pi += 1
ti += 1
continue
}
Star => {
star = pi
mark = ti
pi += 1
continue
}
}
}
if star >= 0 {
pi = star + 1
mark += 1
ti = mark
continue
}
return false
}
while pi < toks.length() {
match toks[pi] {
Star => pi += 1
_ => return false
}
}
true
}
fn criteria_match(cell : Value, crit : Criteria) -> Bool {
let cell = scalarize(cell)
match crit.operand {
Text(t) => {
if t == "" {
// Empty criteria "" / "=" / "<>": real Excel 2024 treats a blank cell
// as matching "" (SUMIF/COUNTIF probe rows math-sumif-0116/0117,
// stat-countif-0118), while "<>" matches every non-blank cell
// (probe stat-countif-0119 and the formula-empty "<>" check).
return match crit.op {
"=" =>
match cell {
Blank => true
Text(s) => s == ""
_ => false
}
"<>" =>
match cell {
Blank => false
Err(_) => false
_ => true
}
_ => false
}
}
match cell {
Text(s) => {
let lt = @value.ascii_lower(s)
let lp = @value.ascii_lower(t)
match crit.op {
"=" => wildcard_match(t, s)
"<>" => !wildcard_match(t, s)
">" => lex_compare(lt, lp) > 0
"<" => lex_compare(lt, lp) < 0
">=" => lex_compare(lt, lp) >= 0
"<=" => lex_compare(lt, lp) <= 0
_ => false
}
}
_ => false
}
}
Num(target) => {
let cn = match cell {
Num(d) => Some(d)
Text(s) =>
match parse_excel_number(s) {
Ok(d) => Some(d)
Err(_) => None
}
_ => None
}
match cn {
None => false
Some(d) =>
match crit.op {
"=" => d == target
"<>" => d != target
">" => d > target
"<" => d < target
">=" => d >= target
"<=" => d <= target
_ => false
}
}
}
Bool(b) =>
match cell {
Bool(c) => if crit.op == "<>" { b != c } else { b == c }
_ => false
}
Err(ce) =>
// An error criterion matches error cells of the same error value and
// nothing else (probes: COUNTIF(range with #N/A, #N/A) = 1 and SUMIF
// then propagates the error from the summed cell; corpus
// gen-sumif-0002 / stat-countif-0121).
match cell {
Err(cell_err) => cell_err == ce
_ => false
}
_ => false
}
}