fn text_arg(v : Value) -> Result[String, XlError] {
to_text(scalarize(v))
}
fn int_arg(vals : Array[Value], i : Int) -> Result[Int, XlError] {
match arg_number(vals, i) {
Ok(d) => Ok(d.trunc().to_int())
Err(e) => Err(e)
}
}
fn fn_left(_ctx : Ctx, args : Array[Thunk]) -> Value {
let vals = eager(args)
if first_error(vals) is Some(e) {
return Value::Err(e)
}
let s = match text_arg(vals[0]) {
Ok(t) => t
Err(e) => return Value::Err(e)
}
let n = if vals.length() == 2 {
match int_arg(vals, 1) {
Ok(v) => v
Err(e) => return Value::Err(e)
}
} else {
1
}
if n < 0 {
return Value::Err(XlError::Value)
}
// Excel LEFT/RIGHT count Unicode code points: LEFT("😀abc",1) returns the
// whole emoji (2 UTF-16 units) while LEN counts 2 code units.
let chars = Array::from_iter(s.iter())
let take = if n < chars.length() { n } else { chars.length() }
Value::Text(String::from_array(chars[:take]))
}
fn fn_right(_ctx : Ctx, args : Array[Thunk]) -> Value {
let vals = eager(args)
if first_error(vals) is Some(e) {
return Value::Err(e)
}
let s = match text_arg(vals[0]) {
Ok(t) => t
Err(e) => return Value::Err(e)
}
let n = if vals.length() == 2 {
match int_arg(vals, 1) {
Ok(v) => v
Err(e) => return Value::Err(e)
}
} else {
1
}
if n < 0 {
return Value::Err(XlError::Value)
}
let chars = Array::from_iter(s.iter())
let take = if n < chars.length() { n } else { chars.length() }
Value::Text(String::from_array(chars[chars.length() - take:]))
}
fn fn_mid(_ctx : Ctx, args : Array[Thunk]) -> Value {
let vals = eager(args)
if first_error(vals) is Some(e) {
return Value::Err(e)
}
let s = match text_arg(vals[0]) {
Ok(t) => t
Err(e) => return Value::Err(e)
}
let start = match int_arg(vals, 1) {
Ok(v) => v
Err(e) => return Value::Err(e)
}
let count = match int_arg(vals, 2) {
Ok(v) => v
Err(e) => return Value::Err(e)
}
if start < 1 || count < 0 {
return Value::Err(XlError::Value)
}
let len = s.length()
let from = start - 1
if from >= len {
return Value::Text("")
}
let take = if count < len - from { count } else { len - from }
Value::Text(s.substring(start=from, end=from + take))
}
fn fn_len(_ctx : Ctx, args : Array[Thunk]) -> Value {
// Excel LEN counts UTF-16 code units: LEN("😀") = 2.
match text_arg(args[0]()) {
Err(e) => Value::Err(e)
Ok(s) => Value::Num(s.length().to_double())
}
}
// Excel TRIM only touches ASCII spaces: strip ends, collapse inner runs.
fn excel_trim(s : String) -> String {
let mut out = ""
let mut pending = false
let mut started = false
for c in s.iter() {
if c == ' ' {
if started {
pending = true
}
} else {
if pending {
out = out + " "
pending = false
}
out = out + c.to_string()
started = true
}
}
out
}
fn fn_trim(_ctx : Ctx, args : Array[Thunk]) -> Value {
match text_arg(args[0]()) {
Err(e) => Value::Err(e)
Ok(s) => Value::Text(excel_trim(s))
}
}
fn fn_upper(_ctx : Ctx, args : Array[Thunk]) -> Value {
match text_arg(args[0]()) {
Err(e) => Value::Err(e)
Ok(s) => Value::Text(@value.unicode_upper(s))
}
}
fn fn_lower(_ctx : Ctx, args : Array[Thunk]) -> Value {
match text_arg(args[0]()) {
Err(e) => Value::Err(e)
Ok(s) => Value::Text(@value.unicode_lower(s))
}
}
fn fn_concat(_ctx : Ctx, args : Array[Thunk]) -> Value {
let vals = eager(args)
let mut out = ""
for v in vals {
match v {
Range(r) =>
for c in r.cells {
match to_text(c) {
Ok(t) => out = out + t
Err(e) => return Value::Err(e)
}
}
_ =>
match to_text(scalarize(v)) {
Ok(t) => out = out + t
Err(e) => return Value::Err(e)
}
}
}
Value::Text(out)
}
fn fn_value(_ctx : Ctx, args : Array[Thunk]) -> Value {
let v = scalarize(args[0]())
match v {
Text(s) =>
match parse_excel_number(s) {
Ok(d) => Value::Num(d)
Err(e) => Value::Err(e)
}
Num(d) => Value::Num(d)
Blank => Value::Num(0.0)
Err(e) => Value::Err(e)
_ => Value::Err(XlError::Value)
}
}
fn fn_find(_ctx : Ctx, args : Array[Thunk]) -> Value {
let vals = eager(args)
if first_error(vals) is Some(e) {
return Value::Err(e)
}
let needle = match text_arg(vals[0]) {
Ok(t) => t
Err(e) => return Value::Err(e)
}
let hay = match text_arg(vals[1]) {
Ok(t) => t
Err(e) => return Value::Err(e)
}
let start = if vals.length() == 3 {
match int_arg(vals, 2) {
Ok(v) => v
Err(e) => return Value::Err(e)
}
} else {
1
}
let hc = hay.code_units()
let nc = needle.code_units()
let hlen = hc.length()
let nlen = nc.length()
if start < 1 || start > hlen + 1 {
return Value::Err(XlError::Value)
}
if nlen == 0 {
return Value::Num(start.to_double())
}
let mut i = start - 1
while i + nlen <= hlen {
let mut ok = true
for j in 0.. Value {
let vals = eager(args)
if first_error(vals) is Some(e) {
return Value::Err(e)
}
let s = match text_arg(vals[0]) {
Ok(t) => t
Err(e) => return Value::Err(e)
}
let old = match text_arg(vals[1]) {
Ok(t) => t
Err(e) => return Value::Err(e)
}
let new = match text_arg(vals[2]) {
Ok(t) => t
Err(e) => return Value::Err(e)
}
let inst = if vals.length() == 4 {
match int_arg(vals, 3) {
Ok(v) => v
Err(e) => return Value::Err(e)
}
} else {
0
}
if vals.length() == 4 && inst < 1 {
return Value::Err(XlError::Value)
}
if old == "" {
return Value::Text(s)
}
let sc = Array::from_iter(s.iter())
let oc = Array::from_iter(old.iter())
let mut out = ""
let mut i = 0
let mut count = 0
while i < sc.length() {
let mut matched = i + oc.length() <= sc.length()
if matched {
for j in 0.. Value {
let vals = eager(args)
if first_error(vals) is Some(e) {
return Value::Err(e)
}
let fmt = match text_arg(vals[1]) {
Ok(t) => t
Err(e) => return Value::Err(e)
}
let d = match scalarize(vals[0]) {
Text(s) => return Value::Text(s)
Bool(b) => return Value::Text(if b { "TRUE" } else { "FALSE" })
Blank => 0.0
v =>
match to_number(v) {
Ok(x) => x
Err(e) => return Value::Err(e)
}
}
match text_format(d, fmt) {
Ok(s) => Value::Text(s)
Err(e) => Value::Err(e)
}
}
// One TEXTJOIN piece: Blank -> empty text (skipped when ignore_empty is TRUE);
// text conversion errors propagate. `None` means "do not contribute a part".
fn textjoin_piece(v : Value, ignore_empty : Bool) -> Result[String?, XlError] {
match v {
Blank => Ok(if ignore_empty { None } else { Some("") })
_ =>
match to_text(v) {
Err(e) => Err(e)
Ok(s) => if ignore_empty && s == "" { Ok(None) } else { Ok(Some(s)) }
}
}
}
// TEXTJOIN(delimiter, ignore_empty, text1, [text2], ...): joins text pieces in
// argument/row-major order; errors propagate; result > 32767 chars -> #CALC!
// (adjudicated by corpus text-textjoin-0021 against Excel 2024).
fn fn_textjoin(_ctx : Ctx, args : Array[Thunk]) -> Value {
let delim = match text_arg(args[0]()) {
Ok(s) => s
Err(e) => return Value::Err(e)
}
let ignore_empty = match to_bool(scalarize(args[1]())) {
Ok(b) => b
Err(e) => return Value::Err(e)
}
let mut out = ""
let mut first = true
let mut i = 2
while i < args.length() {
let v = args[i]()
match v {
Range(r) =>
for c in r.cells {
match textjoin_piece(c, ignore_empty) {
Err(e) => return Value::Err(e)
Ok(None) => ()
Ok(Some(s)) => {
if !first {
out = out + delim
}
out = out + s
first = false
}
}
}
_ =>
match textjoin_piece(scalarize(v), ignore_empty) {
Err(e) => return Value::Err(e)
Ok(None) => ()
Ok(Some(s)) => {
if !first {
out = out + delim
}
out = out + s
first = false
}
}
}
i += 1
}
if out.length() > 32767 {
return Value::Err(XlError::Calc)
}
Value::Text(out)
}