// Single entry point for Excel coercion rules. Locale invariant: decimal
// point is '.', thousands separators / currency / date text are #VALUE!.
/// 标量化:1×1 区域取其唯一单元格,其余值原样返回。
pub fn scalarize(v : Value) -> Value {
match v {
Range(r) => if r.rows == 1 && r.cols == 1 { r.cells[0] } else { v }
_ => v
}
}
fn is_digit(c : Char) -> Bool {
c >= '0' && c <= '9'
}
fn read_int_at(chars : Array[Char], start : Int, stop : Int) -> (Int, Int) {
let mut i = start
let mut v = 0
while i < stop && is_digit(chars[i]) {
v = v * 10 + (chars[i].to_int() - 48)
i += 1
}
(v, i)
}
fn digits_text(chars : Array[Char], start : Int, stop : Int) -> String {
let mut out = ""
for i in start.. Result[Double, XlError] {
let chars = Array::from_iter(s.iter())
let n = chars.length()
let mut i = 0
let mut clean = ""
if i < n && (chars[i] == '+' || chars[i] == '-') {
if chars[i] == '-' {
clean = "-"
}
i += 1
}
let int_start = i
while i < n && is_digit(chars[i]) {
i += 1
}
let first_len = i - int_start
if first_len == 0 {
return Err(XlError::Value)
}
if i < n && chars[i] == ',' && first_len > 3 {
return Err(XlError::Value)
}
clean = clean + digits_text(chars, int_start, i)
while i < n && chars[i] == ',' {
i += 1
let gs = i
while i < n && is_digit(chars[i]) {
i += 1
}
if i - gs != 3 {
return Err(XlError::Value)
}
clean = clean + digits_text(chars, gs, i)
}
if i < n && chars[i] == '.' {
i += 1
let fs = i
while i < n && is_digit(chars[i]) {
i += 1
}
if i == fs {
return Err(XlError::Value)
}
clean = clean + "." + digits_text(chars, fs, i)
}
if i < n && (chars[i] == 'e' || chars[i] == 'E') {
i += 1
clean = clean + "e"
if i < n && (chars[i] == '+' || chars[i] == '-') {
clean = clean + chars[i].to_string()
i += 1
}
let es = i
while i < n && is_digit(chars[i]) {
i += 1
}
if i == es {
return Err(XlError::Value)
}
clean = clean + digits_text(chars, es, i)
}
let mut percent = false
if i < n && chars[i] == '%' {
percent = true
i += 1
}
if i != n {
return Err(XlError::Value)
}
let d = @string.parse_double(clean[:]) catch { _ => return Err(XlError::Value) }
let d = @value.excel_precision(d)
Ok(if percent { d / 100.0 } else { d })
}
fn parse_ymd_text(
chars : Array[Char],
start : Int,
stop : Int
) -> Option[(Int, Int, Int)] {
let (y, i1) = read_int_at(chars, start, stop)
if i1 - start != 4 || i1 >= stop {
return None
}
let sep = chars[i1]
if sep != '-' && sep != '/' {
return None
}
let (m, i2) = read_int_at(chars, i1 + 1, stop)
if i2 == i1 + 1 || i2 - (i1 + 1) > 2 || i2 >= stop {
return None
}
if chars[i2] != sep {
return None
}
let (d, i3) = read_int_at(chars, i2 + 1, stop)
if i3 == i2 + 1 || i3 - (i2 + 1) > 2 || i3 != stop {
return None
}
if m < 1 || m > 12 || d < 0 || d > 31 {
return None
}
Some((y, m, d))
}
fn parse_hms_text(chars : Array[Char], start : Int, stop : Int) -> Option[Double] {
let (h, i1) = read_int_at(chars, start, stop)
if i1 == start || i1 - start > 2 || i1 >= stop {
return None
}
if chars[i1] != ':' {
return None
}
let (m, i2) = read_int_at(chars, i1 + 1, stop)
if i2 == i1 + 1 || i2 - (i1 + 1) > 2 {
return None
}
let mut i = i2
let mut sec = 0
if i < stop {
if chars[i] != ':' {
return None
}
let (s, i3) = read_int_at(chars, i + 1, stop)
if i3 == i + 1 || i3 - (i + 1) > 2 || i3 != stop {
return None
}
sec = s
i = i3
}
if h >= 24 || m >= 60 || sec >= 60 {
return None
}
Some((h * 3600 + m * 60 + sec).to_double() / 86400.0)
}
// Locale-invariant text date accepted by Excel/zh-CN: YYYY-MM-DD or
// YYYY/M/D, optionally followed by " HH:MM[:SS]". The date must round-trip
// through the Excel serial calendar (so 1900-02-29 is accepted, 2026-02-30
// is not; US-order dates are rejected). Returns an Excel serial.
fn parse_date_text(s : String) -> Option[Double] {
let chars = Array::from_iter(s.iter())
let n = chars.length()
let mut sp = -1
for k in 0..= 0 { sp } else { n }
let (y, m, d) = match parse_ymd_text(chars, 0, date_stop) {
Some(v) => v
None => return None
}
let mut frac = 0.0
if sp >= 0 {
match parse_hms_text(chars, sp + 1, n) {
Some(f) => frac = f
None => return None
}
}
match date_serial(y, m, d) {
Err(_) => None
Ok(serial) => {
let sd = serial.to_double()
match serial_to_ymd(sd) {
Err(_) => None
Ok((yy, mm, dd)) =>
if yy != y || mm != m || dd != d {
None
} else {
Some(sd + frac)
}
}
}
}
}
fn parse_excel_number(text : String) -> Result[Double, XlError] {
let s = text.trim().to_string()
if s.length() == 0 {
return Err(XlError::Value)
}
match parse_plain_number(s) {
Ok(d) => Ok(d)
Err(_) =>
match parse_date_text(s) {
Some(d) => Ok(d)
None => Err(XlError::Value)
}
}
}
/// Excel 数值强制转换(算术运算、数值参数):数字原样;空白→0;布尔→1/0;
/// 文本按 Excel 数字文法解析(含千分位/百分号/科学计数,locale 不变);错误传播;
/// 多格区域→`#VALUE!`。
pub fn to_number(v : Value) -> Result[Double, XlError] {
match v {
Num(d) => Ok(d)
Blank => Ok(0.0)
Bool(b) => Ok(if b { 1.0 } else { 0.0 })
Text(s) => parse_excel_number(s)
Err(e) => Err(e)
Range(r) =>
if r.cells.length() == 1 {
to_number(r.cells[0])
} else {
Err(XlError::Value)
}
}
}
/// Excel 文本强制转换(`&`、文本参数):数字按 General 格式(15 位有效数字);
/// 布尔→`"TRUE"`/`"FALSE"`;空白→`""`;错误传播;多格区域→`#VALUE!`。
pub fn to_text(v : Value) -> Result[String, XlError] {
match v {
Num(d) => if d.is_finite() { Ok(number_to_text(d)) } else { Err(XlError::Num) }
Text(s) => Ok(s)
Bool(b) => Ok(if b { "TRUE" } else { "FALSE" })
Blank => Ok("")
Err(e) => Err(e)
Range(r) =>
if r.cells.length() == 1 {
to_text(r.cells[0])
} else {
Err(XlError::Value)
}
}
}
/// Excel 布尔强制转换(逻辑参数):布尔原样;数字≠0→TRUE;空白→FALSE;
/// 文本仅接受大小写不敏感的 `"TRUE"`/`"FALSE"`,其余→`#VALUE!`;错误传播。
pub fn to_bool(v : Value) -> Result[Bool, XlError] {
match v {
Bool(b) => Ok(b)
Num(d) => Ok(d != 0.0)
Blank => Ok(false)
Text(s) =>
if s.compare_ignore_ascii_case("TRUE") == 0 {
Ok(true)
} else if s.compare_ignore_ascii_case("FALSE") == 0 {
Ok(false)
} else {
Err(XlError::Value)
}
Err(e) => Err(e)
Range(r) =>
if r.cells.length() == 1 {
to_bool(r.cells[0])
} else {
Err(XlError::Value)
}
}
}
fn blank_as(v : Value, other : Value) -> Value {
match v {
Blank =>
match other {
Num(_) => Value::Num(0.0)
Text(_) => Value::Text("")
Bool(_) => Value::Bool(false)
_ => Blank
}
_ => v
}
}
fn type_rank(v : Value) -> Int {
match v {
Num(_) | Blank => 0
Text(_) => 1
Bool(_) => 2
_ => -1
}
}
// MoonBit's String::compare is length-first; Excel text comparison is pure
// lexicographic, so compare code point by code point.
fn lex_compare(a : String, b : String) -> Int {
let ca = Array::from_iter(a.iter())
let cb = Array::from_iter(b.iter())
let n = if ca.length() < cb.length() { ca.length() } else { cb.length() }
for i in 0.. Result[Int, XlError] {
let a = scalarize(a)
let b = scalarize(b)
match a {
Err(e) => return Err(e)
Range(_) => return Err(XlError::Value)
_ => ()
}
match b {
Err(e) => return Err(e)
Range(_) => return Err(XlError::Value)
_ => ()
}
let a = blank_as(a, b)
let b = blank_as(b, a)
let ra = type_rank(a)
let rb = type_rank(b)
if ra != rb {
return Ok(if ra < rb { -1 } else { 1 })
}
match (a, b) {
(Num(x), Num(y)) => Ok(if x < y { -1 } else if x > y { 1 } else { 0 })
(Text(x), Text(y)) => Ok(lex_compare(@value.unicode_lower(x), @value.unicode_lower(y)))
(Bool(x), Bool(y)) => Ok(if x == y { 0 } else if !x { -1 } else { 1 })
(Blank, Blank) => Ok(0)
_ => Ok(0)
}
}