use super::{Arg, first_error};
use crate::error::CellError;
use crate::formula::eval::{Engine, Origin};
use crate::formula::parser::Expr;
use crate::formula::value::Value;
use crate::style::format;
pub fn concatenate(args: &[Arg]) -> Value {
let mut out = String::new();
for arg in args {
let mut flat = Vec::new();
arg.value.flatten(&mut flat);
for v in flat {
match v.text() {
Ok(t) => out.push_str(&t),
Err(e) => return Value::Error(e),
}
}
}
Value::Text(out)
}
pub fn len(args: &[Arg]) -> Value {
one_text(args, |t| count_value(t.chars().count()))
}
pub fn upper(args: &[Arg]) -> Value {
one_text(args, |t| Value::Text(t.to_uppercase()))
}
pub fn lower(args: &[Arg]) -> Value {
one_text(args, |t| Value::Text(t.to_lowercase()))
}
pub fn trim(args: &[Arg]) -> Value {
one_text(args, |t| {
Value::Text(t.split_whitespace().collect::<Vec<_>>().join(" "))
})
}
pub fn left(args: &[Arg]) -> Value {
cut(args, |chars, n| chars.iter().take(n).collect())
}
pub fn right(args: &[Arg]) -> Value {
cut(args, |chars, n| {
chars.iter().skip(chars.len().saturating_sub(n)).collect()
})
}
fn cut(args: &[Arg], take: fn(&[char], usize) -> String) -> Value {
let (text, count) = match args {
[t] => (t.text(), Ok(1.0)),
[t, n] => (t.text(), n.number()),
_ => return Value::Error(CellError::Value),
};
match (text, count) {
(Ok(t), Ok(n)) if n >= 0.0 => {
let chars: Vec<char> = t.chars().collect();
#[expect(
clippy::cast_possible_truncation,
clippy::cast_sign_loss,
reason = "checked non-negative, and a longer count just takes everything"
)]
let n = (n as usize).min(chars.len());
Value::Text(take(&chars, n))
}
(Ok(_), Ok(_)) => Value::Error(CellError::Value),
(Err(e), _) | (_, Err(e)) => Value::Error(e),
}
}
pub fn mid(args: &[Arg]) -> Value {
if let Some(e) = first_error(args) {
return Value::Error(e);
}
let [t, s, n] = args else {
return Value::Error(CellError::Value);
};
match (t.text(), s.number(), n.number()) {
(Ok(t), Ok(start), Ok(count)) if start >= 1.0 && count >= 0.0 => {
#[expect(
clippy::cast_possible_truncation,
clippy::cast_sign_loss,
reason = "both bounds are checked just above"
)]
let (start, count) = (start as usize - 1, count as usize);
Value::Text(t.chars().skip(start).take(count).collect())
}
(Ok(_), Ok(_), Ok(_)) => Value::Error(CellError::Value),
(Err(e), _, _) | (_, Err(e), _) | (_, _, Err(e)) => Value::Error(e),
}
}
pub fn rept(args: &[Arg]) -> Value {
let [t, n] = args else {
return Value::Error(CellError::Value);
};
match (t.text(), n.number()) {
(Ok(t), Ok(n)) if n >= 0.0 => {
#[expect(
clippy::cast_possible_truncation,
clippy::cast_sign_loss,
reason = "checked non-negative; the length cap below bounds it"
)]
let times = n as usize;
if t.chars().count().saturating_mul(times) > crate::model::MAX_STRING_LENGTH {
return Value::Error(CellError::Value);
}
Value::Text(t.repeat(times))
}
(Ok(_), Ok(_)) => Value::Error(CellError::Value),
(Err(e), _) | (_, Err(e)) => Value::Error(e),
}
}
pub fn exact(args: &[Arg]) -> Value {
let [a, b] = args else {
return Value::Error(CellError::Value);
};
match (a.text(), b.text()) {
(Ok(x), Ok(y)) => Value::Bool(x == y),
(Err(e), _) | (_, Err(e)) => Value::Error(e),
}
}
pub fn find(args: &[Arg]) -> Value {
locate(args, false)
}
pub fn search(args: &[Arg]) -> Value {
locate(args, true)
}
fn locate(args: &[Arg], fold_case: bool) -> Value {
let (needle, haystack, start) = match args {
[n, h] => (n.text(), h.text(), Ok(1.0)),
[n, h, s] => (n.text(), h.text(), s.number()),
_ => return Value::Error(CellError::Value),
};
if let Some(e) = first_error(args) {
return Value::Error(e);
}
let (Ok(needle), Ok(haystack), Ok(start)) = (needle, haystack, start) else {
return Value::Error(CellError::Value);
};
if start < 1.0 {
return Value::Error(CellError::Value);
}
let (needle, haystack) = if fold_case {
(needle.to_uppercase(), haystack.to_uppercase())
} else {
(needle, haystack)
};
let chars: Vec<char> = haystack.chars().collect();
#[expect(
clippy::cast_possible_truncation,
clippy::cast_sign_loss,
reason = "checked at least 1 just above"
)]
let from = start as usize - 1;
if from > chars.len() {
return Value::Error(CellError::Value);
}
if fold_case && needle.contains(['*', '?']) {
return super::wildcard_position(&needle, &haystack, from)
.map_or(Value::Error(CellError::Value), count_value);
}
let tail: String = chars[from..].iter().collect();
match tail.find(&needle) {
Some(byte) => count_value(from + tail[..byte].chars().count() + 1),
None => Value::Error(CellError::Value),
}
}
pub fn substitute(args: &[Arg]) -> Value {
let (text, old, new, which) = match args {
[t, o, n] => (t.text(), o.text(), n.text(), Ok(0.0)),
[t, o, n, i] => (t.text(), o.text(), n.text(), i.number()),
_ => return Value::Error(CellError::Value),
};
if let Some(e) = first_error(args) {
return Value::Error(e);
}
let (Ok(text), Ok(old), Ok(new), Ok(which)) = (text, old, new, which) else {
return Value::Error(CellError::Value);
};
if old.is_empty() {
return Value::Text(text);
}
if which == 0.0 {
return Value::Text(text.replace(&old, &new));
}
if which < 1.0 {
return Value::Error(CellError::Value);
}
#[expect(
clippy::cast_possible_truncation,
clippy::cast_sign_loss,
reason = "checked at least 1; a huge index simply matches nothing"
)]
let wanted = which as usize;
let mut out = String::with_capacity(text.len());
let mut rest = text.as_str();
let mut seen = 0usize;
while let Some(at) = rest.find(&old) {
seen += 1;
out.push_str(&rest[..at]);
out.push_str(if seen == wanted { &new } else { &old });
rest = &rest[at + old.len()..];
}
out.push_str(rest);
Value::Text(out)
}
pub fn value(engine: &mut Engine<'_>, origin: Origin, args: &[Expr]) -> Value {
let [arg] = args else {
return Value::Error(CellError::Value);
};
let evaluated = engine.eval_expr(origin, arg);
let text = match evaluated.scalar() {
Value::Number(n) => return Value::Number(*n),
Value::Error(e) => return Value::Error(*e),
Value::Bool(_) => return Value::Error(CellError::Value),
other => match other.text() {
Ok(t) => t,
Err(e) => return Value::Error(e),
},
};
number_of_text(&text, engine.book().epoch).map_or(Value::Error(CellError::Value), Value::Number)
}
fn number_of_text(text: &str, epoch: crate::shared::date::Epoch) -> Option<f64> {
let trimmed = text.trim();
if trimmed.is_empty() {
return None;
}
let stripped: String = trimmed
.chars()
.filter(|c| !matches!(c, ',' | '$' | '€' | '£' | '¥' | ' '))
.collect();
let (body, scale) = match stripped.strip_suffix('%') {
Some(body) => (body, 0.01),
None => (stripped.as_str(), 1.0),
};
if let Ok(n) = Value::Text(body.to_owned()).number() {
return Some(n * scale);
}
crate::shared::date_parse::parse(trimmed).and_then(|parsed| parsed.serial(epoch))
}
pub fn text_format(engine: &mut Engine<'_>, origin: Origin, args: &[Expr]) -> Value {
let [v, f] = args else {
return Value::Error(CellError::Value);
};
let value = engine.eval_expr(origin, v);
let code = engine.eval_expr(origin, f);
if let Some(e) = value.error().or_else(|| code.error()) {
return Value::Error(e);
}
let Ok(code) = code.text() else {
return Value::Error(CellError::Value);
};
let epoch = engine.book().epoch;
let rendered = match value.scalar() {
Value::Text(t) => format::format(format::Value::Text(t), &code, epoch),
other => match other.number() {
Ok(n) => format::format(format::Value::Number(n), &code, epoch),
Err(e) => return Value::Error(e),
},
};
Value::Text(rendered)
}
fn one_text(args: &[Arg], f: impl Fn(&str) -> Value) -> Value {
match args {
[a] => match a.text() {
Ok(t) => f(&t),
Err(e) => Value::Error(e),
},
_ => Value::Error(CellError::Value),
}
}
#[expect(
clippy::cast_precision_loss,
reason = "a cell holds at most 32767 characters"
)]
fn count_value(n: usize) -> Value {
Value::Number(n as f64)
}
pub fn proper(args: &[Arg]) -> Value {
one_text(args, |t| {
let mut out = String::with_capacity(t.len());
let mut start_of_word = true;
for c in t.chars() {
if start_of_word {
out.extend(c.to_uppercase());
} else {
out.extend(c.to_lowercase());
}
start_of_word = !c.is_alphabetic();
}
Value::Text(out)
})
}
pub fn clean(args: &[Arg]) -> Value {
one_text(args, |t| {
Value::Text(t.chars().filter(|c| !c.is_control()).collect())
})
}
pub fn t(args: &[Arg]) -> Value {
let [a] = args else {
return Value::Error(CellError::Value);
};
match a.value.scalar() {
Value::Text(text) => Value::Text(text.clone()),
Value::Error(e) => Value::Error(*e),
_ => Value::Text(String::new()),
}
}
pub fn char_(args: &[Arg]) -> Value {
code_point(args, 1.0, 255.0)
}
pub fn unichar(args: &[Arg]) -> Value {
code_point(args, 1.0, f64::from(u32::from(char::MAX)))
}
fn code_point(args: &[Arg], low: f64, high: f64) -> Value {
super::one(args, |n| {
let n = n.trunc();
if n < low || n > high {
return Value::Error(CellError::Value);
}
#[expect(
clippy::cast_possible_truncation,
clippy::cast_sign_loss,
reason = "bounded by the range checked just above"
)]
let code = n as u32;
char::from_u32(code).map_or(Value::Error(CellError::Value), |c| {
Value::Text(c.to_string())
})
})
}
pub fn code(args: &[Arg]) -> Value {
first_code(args, true)
}
pub fn unicode(args: &[Arg]) -> Value {
first_code(args, false)
}
fn first_code(args: &[Arg], legacy: bool) -> Value {
one_text(args, |t| {
let Some(c) = t.chars().next() else {
return Value::Error(CellError::Value);
};
let code = u32::from(c);
let code = if legacy && code > 255 { 63 } else { code };
Value::Number(f64::from(code))
})
}
pub fn replace(args: &[Arg]) -> Value {
if let Some(e) = first_error(args) {
return Value::Error(e);
}
let [text, start, count, new] = args else {
return Value::Error(CellError::Value);
};
let (Ok(text), Ok(start), Ok(count), Ok(new)) =
(text.text(), start.number(), count.number(), new.text())
else {
return Value::Error(CellError::Value);
};
if start < 1.0 || count < 0.0 {
return Value::Error(CellError::Value);
}
let chars: Vec<char> = text.chars().collect();
#[expect(
clippy::cast_possible_truncation,
clippy::cast_sign_loss,
reason = "both checked non-negative; past the end simply appends"
)]
let (from, count) = ((start as usize - 1).min(chars.len()), count as usize);
let mut out: String = chars[..from].iter().collect();
out.push_str(&new);
out.extend(chars.iter().skip(from.saturating_add(count)));
Value::Text(out)
}
pub fn textjoin(args: &[Arg]) -> Value {
let [delimiter, ignore_empty, rest @ ..] = args else {
return Value::Error(CellError::Value);
};
if let Some(e) = first_error(&args[..2]) {
return Value::Error(e);
}
let (Ok(delimiter), Ok(ignore_empty)) = (delimiter.text(), ignore_empty.value.boolean()) else {
return Value::Error(CellError::Value);
};
let mut parts = Vec::new();
for arg in rest {
let mut flat = Vec::new();
arg.value.flatten(&mut flat);
for v in flat {
match v {
Value::Error(e) => return Value::Error(*e),
Value::Blank if ignore_empty => {}
other => {
let Ok(text) = other.text() else {
return Value::Error(CellError::Value);
};
if !(ignore_empty && text.is_empty()) {
parts.push(text);
}
}
}
}
}
Value::Text(parts.join(&delimiter))
}
pub fn textbefore(args: &[Arg]) -> Value {
split_at_delimiter(args, true)
}
pub fn textafter(args: &[Arg]) -> Value {
split_at_delimiter(args, false)
}
fn split_at_delimiter(args: &[Arg], before: bool) -> Value {
if let Some(e) = first_error(args) {
return Value::Error(e);
}
let (text, delimiter, instance) = match args {
[t, d] => (t.text(), d.text(), Ok(1.0)),
[t, d, i] => (t.text(), d.text(), i.number()),
_ => return Value::Error(CellError::Value),
};
let (Ok(text), Ok(delimiter), Ok(instance)) = (text, delimiter, instance) else {
return Value::Error(CellError::Value);
};
if delimiter.is_empty() || instance == 0.0 {
return Value::Error(CellError::Value);
}
let found: Vec<usize> = text.match_indices(&delimiter).map(|(at, _)| at).collect();
#[expect(
clippy::cast_possible_truncation,
reason = "an instance number past the matches falls through to #N/A"
)]
let wanted = instance.trunc() as isize;
let at = if wanted > 0 {
found.get(wanted.cast_unsigned() - 1).copied()
} else {
let from_end = wanted.unsigned_abs();
found
.len()
.checked_sub(from_end)
.and_then(|i| found.get(i))
.copied()
};
let Some(at) = at else {
return Value::Error(CellError::Na);
};
Value::Text(if before {
text[..at].to_owned()
} else {
text[at + delimiter.len()..].to_owned()
})
}
pub fn numbervalue(args: &[Arg]) -> Value {
if let Some(e) = first_error(args) {
return Value::Error(e);
}
let (text, decimal, group) = match args {
[t] => (t.text(), Ok(".".to_owned()), Ok(",".to_owned())),
[t, d] => (t.text(), d.text(), Ok(",".to_owned())),
[t, d, g] => (t.text(), d.text(), g.text()),
_ => return Value::Error(CellError::Value),
};
let (Ok(text), Ok(decimal), Ok(group)) = (text, decimal, group) else {
return Value::Error(CellError::Value);
};
let decimal = decimal.chars().next().unwrap_or('.');
let group = group.chars().next().unwrap_or(',');
let decimals = text.chars().filter(|c| *c == decimal).count();
if decimals > 1 {
return Value::Error(CellError::Value);
}
if let Some(at) = text.find(decimal)
&& text[at..].contains(group)
{
return Value::Error(CellError::Value);
}
let plain: String = text
.chars()
.filter(|c| *c != group && !c.is_whitespace())
.map(|c| if c == decimal { '.' } else { c })
.collect();
if plain.is_empty() {
return Value::Number(0.0);
}
let percents = plain.chars().rev().take_while(|c| *c == '%').count();
let body = &plain[..plain.len() - percents];
match body.parse::<f64>() {
Ok(n) => Value::Number(n / 100f64.powi(i32::try_from(percents).unwrap_or(0))),
Err(_) => Value::Error(CellError::Value),
}
}
pub fn fixed(args: &[Arg]) -> Value {
if let Some(e) = first_error(args) {
return Value::Error(e);
}
let (number, decimals, plain) = match args {
[n] => (n.number(), Ok(2.0), false),
[n, d] => (n.number(), d.number(), false),
[n, d, c] => (n.number(), d.number(), c.value.boolean().unwrap_or(false)),
_ => return Value::Error(CellError::Value),
};
let (Ok(number), Ok(decimals)) = (number, decimals) else {
return Value::Error(CellError::Value);
};
let decimals = decimals.trunc().clamp(-127.0, 127.0);
#[expect(
clippy::cast_possible_truncation,
reason = "clamped to -127..=127 on the line above"
)]
let places = decimals as i32;
let rounded = if places < 0 {
let step = 10f64.powi(-places);
(number / step).round() * step
} else {
number
};
let places_shown = places.max(0).unsigned_abs() as usize;
let step = 10f64.powi(places.max(0));
let rounded = (rounded * step).abs().round().copysign(rounded) / step;
let shown = format!("{rounded:.places_shown$}");
Value::Text(if plain {
shown
} else {
group_thousands(&shown)
})
}
fn group_thousands(shown: &str) -> String {
let (sign, rest) = match shown.strip_prefix('-') {
Some(rest) => ("-", rest),
None => ("", shown),
};
let (whole, fraction) = match rest.split_once('.') {
Some((w, f)) => (w, Some(f)),
None => (rest, None),
};
let mut grouped = String::with_capacity(whole.len() + whole.len() / 3);
for (i, c) in whole.chars().enumerate() {
if i > 0 && (whole.len() - i).is_multiple_of(3) {
grouped.push(',');
}
grouped.push(c);
}
match fraction {
Some(f) => format!("{sign}{grouped}.{f}"),
None => format!("{sign}{grouped}"),
}
}
pub fn dollar(args: &[Arg]) -> Value {
if let Some(e) = first_error(args) {
return Value::Error(e);
}
let (number, decimals) = match args {
[n] => (n.number(), Ok(2.0)),
[n, d] => (n.number(), d.number()),
_ => return Value::Error(CellError::Value),
};
let (Ok(number), Ok(decimals)) = (number, decimals) else {
return Value::Error(CellError::Value);
};
let Value::Text(shown) = fixed(&[
arg_of(Value::Number(number)),
arg_of(Value::Number(decimals)),
]) else {
return Value::Error(CellError::Value);
};
Value::Text(match shown.strip_prefix('-') {
Some(rest) => format!("(${rest})"),
None => format!("${shown}"),
})
}
pub fn textsplit(args: &[Arg]) -> Value {
if let Some(e) = first_error(args) {
return Value::Error(e);
}
let (text, across, down, ignore_empty) = match args {
[t, c] => (t.text(), c.text(), None, false),
[t, c, r] => (t.text(), c.text(), Some(r.text()), false),
[t, c, r, i] => (
t.text(),
c.text(),
Some(r.text()),
i.value.boolean().unwrap_or(false),
),
_ => return Value::Error(CellError::Value),
};
let (Ok(text), Ok(across)) = (text, across) else {
return Value::Error(CellError::Value);
};
let down = match down {
Some(Ok(d)) if !d.is_empty() => Some(d),
Some(Err(e)) => return Value::Error(e),
_ => None,
};
let split = |text: &str, on: &str| -> Vec<String> {
if on.is_empty() {
return vec![text.to_owned()];
}
text.split(on)
.filter(|part| !(ignore_empty && part.is_empty()))
.map(str::to_owned)
.collect()
};
let lines = match &down {
Some(down) => split(&text, down),
None => vec![text],
};
let rows: Vec<Vec<Value>> = lines
.iter()
.map(|line| split(line, &across).into_iter().map(Value::Text).collect())
.collect();
if rows.iter().all(Vec::is_empty) {
return Value::Error(CellError::Calc);
}
let width = rows.iter().map(Vec::len).max().unwrap_or(0);
Value::array(
rows.into_iter()
.map(|mut row| {
while row.len() < width {
row.push(Value::Error(CellError::Na));
}
row
})
.collect(),
)
}
pub fn arraytotext(args: &[Arg]) -> Value {
let (array, strict) = match args {
[a] => (a, false),
[a, f] => (a, f.number().unwrap_or(0.0) != 0.0),
_ => return Value::Error(CellError::Value),
};
let show = |value: &Value| match value {
Value::Text(text) if strict => format!("{text:?}"),
Value::Text(text) => text.clone(),
Value::Bool(b) => if *b { "TRUE" } else { "FALSE" }.to_owned(),
Value::Error(e) => e.as_str().to_owned(),
Value::Blank => String::new(),
other => other.text().unwrap_or_default(),
};
let Value::Array(rows) = &array.value else {
return Value::Text(show(array.value.scalar()));
};
if strict {
let lines: Vec<String> = rows
.iter()
.map(|row| row.iter().map(show).collect::<Vec<_>>().join(","))
.collect();
return Value::Text(format!("{{{}}}", lines.join(";")));
}
Value::Text(
rows.iter()
.flatten()
.map(show)
.collect::<Vec<_>>()
.join(", "),
)
}
pub fn valuetotext(args: &[Arg]) -> Value {
let [value, rest @ ..] = args else {
return Value::Error(CellError::Value);
};
let mut one = vec![arg_of(value.value.scalar().clone())];
one.extend(rest.iter().cloned());
arraytotext(&one)
}
fn arg_of(value: Value) -> Arg {
Arg {
value,
reference: false,
}
}
const KATAKANA: [(char, char); 63] = [
('。', '。'),
('「', '「'),
('」', '」'),
('、', '、'),
('・', '・'),
('ヲ', 'ヲ'),
('ァ', 'ァ'),
('ィ', 'ィ'),
('ゥ', 'ゥ'),
('ェ', 'ェ'),
('ォ', 'ォ'),
('ャ', 'ャ'),
('ュ', 'ュ'),
('ョ', 'ョ'),
('ッ', 'ッ'),
('ー', 'ー'),
('ア', 'ア'),
('イ', 'イ'),
('ウ', 'ウ'),
('エ', 'エ'),
('オ', 'オ'),
('カ', 'カ'),
('キ', 'キ'),
('ク', 'ク'),
('ケ', 'ケ'),
('コ', 'コ'),
('サ', 'サ'),
('シ', 'シ'),
('ス', 'ス'),
('セ', 'セ'),
('ソ', 'ソ'),
('タ', 'タ'),
('チ', 'チ'),
('ツ', 'ツ'),
('テ', 'テ'),
('ト', 'ト'),
('ナ', 'ナ'),
('ニ', 'ニ'),
('ヌ', 'ヌ'),
('ネ', 'ネ'),
('ノ', 'ノ'),
('ハ', 'ハ'),
('ヒ', 'ヒ'),
('フ', 'フ'),
('ヘ', 'ヘ'),
('ホ', 'ホ'),
('マ', 'マ'),
('ミ', 'ミ'),
('ム', 'ム'),
('メ', 'メ'),
('モ', 'モ'),
('ヤ', 'ヤ'),
('ユ', 'ユ'),
('ヨ', 'ヨ'),
('ラ', 'ラ'),
('リ', 'リ'),
('ル', 'ル'),
('レ', 'レ'),
('ロ', 'ロ'),
('ワ', 'ワ'),
('ン', 'ン'),
('゙', '゛'),
('゚', '゜'),
];
pub fn asc(args: &[Arg]) -> Value {
one_text(args, |t| {
let mut out = String::with_capacity(t.len());
for c in t.chars() {
match c {
'\u{FF01}'..='\u{FF5E}' => out.push(narrow(c)),
'\u{3000}' => out.push(' '),
_ => match KATAKANA.iter().find(|(_, wide)| *wide == c) {
Some((narrow, _)) => out.push(*narrow),
None => match voiced(c) {
Some((base, mark)) => {
out.push(base);
out.push(mark);
}
None => out.push(c),
},
},
}
}
Value::Text(out)
})
}
pub fn dbcs(args: &[Arg]) -> Value {
one_text(args, |t| {
let chars: Vec<char> = t.chars().collect();
let mut out = String::with_capacity(t.len());
let mut i = 0;
while i < chars.len() {
let c = chars[i];
let wide = match c {
'\u{0021}'..='\u{007E}' => Some(widen(c)),
' ' => Some('\u{3000}'),
_ => KATAKANA
.iter()
.find(|(narrow, _)| *narrow == c)
.map(|(_, wide)| *wide),
};
let wide = wide.unwrap_or(c);
if let Some(&mark) = chars.get(i + 1)
&& matches!(mark, '゙' | '゚')
&& let Some(joined) = join_voiced(wide, mark)
{
out.push(joined);
i += 2;
continue;
}
out.push(wide);
i += 1;
}
Value::Text(out)
})
}
fn narrow(c: char) -> char {
char::from_u32(c as u32 - 0xFEE0).unwrap_or(c)
}
fn widen(c: char) -> char {
char::from_u32(c as u32 + 0xFEE0).unwrap_or(c)
}
fn voiced(c: char) -> Option<(char, char)> {
let (base, mark) = match c {
'ガ'..='ヂ' | 'ヅ'..='ド' if is_voiced_pair(c) => (step_back(c, 1), '゙'),
'バ' | 'ビ' | 'ブ' | 'ベ' | 'ボ' => (step_back(c, 1), '゙'),
'パ' | 'ピ' | 'プ' | 'ペ' | 'ポ' => (step_back(c, 2), '゚'),
'ヴ' => ('ウ', '゙'),
_ => return None,
};
let narrow = KATAKANA.iter().find(|(_, wide)| *wide == base)?;
Some((narrow.0, mark))
}
fn is_voiced_pair(c: char) -> bool {
matches!(
c,
'ガ' | 'ギ'
| 'グ'
| 'ゲ'
| 'ゴ'
| 'ザ'
| 'ジ'
| 'ズ'
| 'ゼ'
| 'ゾ'
| 'ダ'
| 'ヂ'
| 'ヅ'
| 'デ'
| 'ド'
)
}
fn step_back(c: char, n: u32) -> char {
char::from_u32(c as u32 - n).unwrap_or(c)
}
fn join_voiced(base: char, mark: char) -> Option<char> {
let step = match (base, mark) {
('ウ', '゙') => return Some('ヴ'),
('カ'..='ト', '゙') if is_plain_pair(base) => 1,
('ハ' | 'ヒ' | 'フ' | 'ヘ' | 'ホ', '゙') => 1,
('ハ' | 'ヒ' | 'フ' | 'ヘ' | 'ホ', '゚') => 2,
_ => return None,
};
char::from_u32(base as u32 + step)
}
fn is_plain_pair(c: char) -> bool {
matches!(
c,
'カ' | 'キ'
| 'ク'
| 'ケ'
| 'コ'
| 'サ'
| 'シ'
| 'ス'
| 'セ'
| 'ソ'
| 'タ'
| 'チ'
| 'ツ'
| 'テ'
| 'ト'
)
}
const THAI_DIGITS: [char; 10] = ['๐', '๑', '๒', '๓', '๔', '๕', '๖', '๗', '๘', '๙'];
const THAI_WORDS: [&str; 10] = [
"ศูนย์",
"หนึ่ง",
"สอง",
"สาม",
"สี่",
"ห้า",
"หก",
"เจ็ด",
"แปด",
"เก้า",
];
const THAI_UNITS: [&str; 6] = ["สิบ", "ร้อย", "พัน", "หมื่น", "แสน", "ล้าน"];
pub fn thaidigit(args: &[Arg]) -> Value {
one_text(args, |t| {
Value::Text(
t.chars()
.map(|c| {
c.to_digit(10)
.and_then(|d| THAI_DIGITS.get(d as usize).copied())
.unwrap_or(c)
})
.collect(),
)
})
}
pub fn isthaidigit(args: &[Arg]) -> Value {
one_text(args, |t| {
Value::Bool(!t.is_empty() && t.chars().all(|c| THAI_DIGITS.contains(&c)))
})
}
pub fn roundbahtup(args: &[Arg]) -> Value {
super::one(args, |n| Value::Number(n.abs().ceil().copysign(n)))
}
pub fn roundbahtdown(args: &[Arg]) -> Value {
super::one(args, |n| Value::Number(n.abs().floor().copysign(n)))
}
pub fn bahttext(args: &[Arg]) -> Value {
let [arg] = args else {
return Value::Error(CellError::Value);
};
let number = match arg.number() {
Ok(n) => n,
Err(e) => return Value::Error(e),
};
let negative = number < 0.0;
let hundredths = (number.abs() * 100.0).round();
if !hundredths.is_finite() {
return Value::Error(CellError::Value);
}
let baht = format!("{}", (hundredths / 100.0).trunc());
let satang = format!("{:02}", (hundredths % 100.0).trunc());
let has_baht = baht != "0";
let has_satang = satang != "00";
if !has_baht && !has_satang {
return Value::Text(format!("{}บาทถ้วน", THAI_WORDS[0]));
}
let mut out = String::new();
if negative {
out.push_str("ลบ");
}
if has_baht {
out.push_str(&thai_large(&baht));
out.push_str("บาท");
}
if has_satang {
out.push_str(&thai_block(&satang));
out.push_str("สตางค์");
} else {
out.push_str("ถ้วน");
}
Value::Text(out)
}
fn thai_large(digits: &str) -> String {
let head = match digits.len() % 6 {
0 => 6,
n => n,
};
let (first, rest) = digits.split_at(head.min(digits.len()));
let mut blocks = vec![thai_block(first)];
let rest: Vec<char> = rest.chars().collect();
for block in rest.chunks(6) {
blocks.push(thai_block(&block.iter().collect::<String>()));
}
blocks.join(THAI_UNITS[5])
}
fn thai_block(block: &str) -> String {
let digits: Vec<u32> = block.chars().filter_map(|c| c.to_digit(10)).collect();
let mut out = String::new();
let length = digits.len();
let mut i = 0;
for power in (2..length).rev() {
let digit = digits[i];
i += 1;
if digit != 0 {
out.push_str(THAI_WORDS[digit as usize]);
out.push_str(THAI_UNITS[power - 1]);
}
}
let ten = if length > 1 {
let ten = digits[i];
i += 1;
ten
} else {
0
};
if ten != 0 {
match ten {
1 => {}
2 => out.push_str("ยี่"),
other => out.push_str(THAI_WORDS[other as usize]),
}
out.push_str(THAI_UNITS[0]);
}
let one = digits.get(i).copied().unwrap_or(0);
if one != 0 {
if ten != 0 && one == 1 {
out.push_str("เอ็ด");
} else {
out.push_str(THAI_WORDS[one as usize]);
}
}
out
}
pub fn phonetic(args: &[Arg]) -> Value {
let [reference] = args else {
return Value::Error(CellError::Value);
};
match reference.value.scalar() {
Value::Blank => Value::Text(String::new()),
Value::Error(e) => Value::Error(*e),
other => other.text().map_or_else(Value::Error, Value::Text),
}
}