use crate::host::with_host;
use crate::stdlib::common::*;
use fusevm::Value;
use std::cell::RefCell;
thread_local! {
static INTERNAL_ENCODING: RefCell<String> = RefCell::new("UTF-8".to_string());
}
pub fn dispatch(name: &str, args: &[Value]) -> Option<Result<Value, String>> {
let v = match name {
"mb_str_split" => return Some(mb_str_split(args)),
"mb_convert_case" => Value::str(mb_convert_case(args)),
"mb_strpos" => return Some(mb_strpos(args, false)),
"mb_stripos" => return Some(mb_strpos(args, true)),
"mb_strrpos" => return Some(mb_strrpos(args, false)),
"mb_strripos" => return Some(mb_strrpos(args, true)),
"mb_substr_count" => return Some(mb_substr_count(args)),
"mb_str_pad" => return Some(mb_str_pad(args)),
"mb_ord" => return Some(mb_ord(args)),
"mb_chr" => mb_chr(args),
"mb_lcfirst" => Value::str(mb_lcfirst(&str_arg(args, 0))),
"mb_ucfirst" => Value::str(mb_ucfirst(&str_arg(args, 0))),
"mb_scrub" => Value::str(str_arg(args, 0)),
"mb_strcut" => Value::str(mb_strcut(args)),
"mb_split" => mb_split(args),
"mb_convert_kana" => Value::str(mb_convert_kana(args)),
"mb_strwidth" => Value::int(mb_strwidth(&str_arg(args, 0)) as i64),
"mb_convert_encoding" => return Some(mb_convert_encoding(args)),
"mb_detect_encoding" => mb_detect_encoding(args),
"mb_check_encoding" => Value::bool(mb_check_encoding(args)),
"mb_internal_encoding" => mb_internal_encoding(args),
_ => return None,
};
Some(Ok(v))
}
fn mb_str_split(args: &[Value]) -> Result<Value, String> {
let s = str_arg(args, 0);
let length = match args.get(1) {
Some(v) if !matches!(v, Value::Undef) => v.to_int(),
_ => 1,
};
if length < 1 {
return Err(throws(
"ValueError",
"mb_str_split(): Argument #2 ($length) must be greater than 0",
));
}
let chars: Vec<char> = s.chars().collect();
let out: Vec<Value> = chars
.chunks(length as usize)
.map(|c| Value::str(c.iter().collect::<String>()))
.collect();
Ok(make_list(out))
}
fn mb_convert_case(args: &[Value]) -> String {
let s = str_arg(args, 0);
match resolve_mode(&arg(args, 1)) {
1 => s.to_lowercase(),
2 => title_case(&s),
_ => s.to_uppercase(),
}
}
fn resolve_mode(v: &Value) -> i64 {
if let Value::Str(name) = v {
match name.as_str() {
"MB_CASE_UPPER" => return 0,
"MB_CASE_LOWER" => return 1,
"MB_CASE_TITLE" => return 2,
_ => {}
}
}
v.to_int()
}
fn title_case(s: &str) -> String {
let mut out = String::with_capacity(s.len());
let mut in_word = false;
for c in s.chars() {
if is_case_ignorable(c) {
out.push(c);
} else if c.is_alphabetic() {
if in_word {
out.extend(c.to_lowercase());
} else {
out.extend(c.to_uppercase());
}
in_word = true;
} else {
out.push(c);
in_word = false;
}
}
out
}
fn is_case_ignorable(c: char) -> bool {
matches!(
c,
'\u{0027}' | '\u{002E}' | '\u{003A}' | '\u{00B7}' | '\u{0387}'
| '\u{055F}' | '\u{05F4}' | '\u{2018}' | '\u{2019}' | '\u{2024}'
| '\u{2027}' | '\u{FE13}' | '\u{FE52}' | '\u{FE55}' | '\u{FF07}'
| '\u{FF0E}' | '\u{FF1A}'
| '\u{005E}' | '\u{0060}' | '\u{00A8}' | '\u{00AF}' | '\u{00B4}'
| '\u{00B8}'
)
}
fn mb_strpos(args: &[Value], ci: bool) -> Result<Value, String> {
let (hay, needle) = ci_pair(args, ci);
let len = hay.len() as i64;
let off_raw = int_arg(args, 2);
if off_raw > len || off_raw < -len {
return Err(throws(
"ValueError",
format!(
"{}(): Argument #3 ($offset) must be contained in argument #1 ($haystack)",
if ci { "mb_stripos" } else { "mb_strpos" }
),
));
}
let off = if off_raw < 0 {
(len + off_raw) as usize
} else {
off_raw as usize
};
for i in off..=hay.len().saturating_sub(needle.len()) {
if hay[i..].starts_with(&needle[..]) {
return Ok(Value::int(i as i64));
}
}
Ok(Value::bool(false))
}
fn mb_strrpos(args: &[Value], ci: bool) -> Result<Value, String> {
let (hay, needle) = ci_pair(args, ci);
let len = hay.len();
let ilen = len as i64;
let off = int_arg(args, 2);
if off > ilen || off < -ilen {
return Err(throws(
"ValueError",
format!(
"{}(): Argument #3 ($offset) must be contained in argument #1 ($haystack)",
if ci { "mb_strripos" } else { "mb_strrpos" }
),
));
}
if needle.is_empty() {
return Ok(Value::int(len as i64));
}
let (lo, hi) = if off >= 0 {
(off as usize, len.saturating_sub(needle.len()))
} else {
let hi = (ilen + off).max(0) as usize;
(0, hi.min(len.saturating_sub(needle.len())))
};
match (lo..=hi)
.rev()
.find(|&i| i + needle.len() <= len && hay[i..].starts_with(&needle[..]))
{
Some(i) => Ok(Value::int(i as i64)),
None => Ok(Value::bool(false)),
}
}
fn mb_substr_count(args: &[Value]) -> Result<Value, String> {
let hay: Vec<char> = str_arg(args, 0).chars().collect();
let needle: Vec<char> = str_arg(args, 1).chars().collect();
if needle.is_empty() {
return Err(throws(
"ValueError",
"mb_substr_count(): Argument #2 ($needle) must not be empty",
));
}
let mut count = 0i64;
let mut i = 0;
while i + needle.len() <= hay.len() {
if hay[i..i + needle.len()] == needle[..] {
count += 1;
i += needle.len();
} else {
i += 1;
}
}
Ok(Value::int(count))
}
fn ci_pair(args: &[Value], ci: bool) -> (Vec<char>, Vec<char>) {
let (h, n) = (str_arg(args, 0), str_arg(args, 1));
if ci {
(fold_chars(&h), fold_chars(&n))
} else {
(h.chars().collect(), n.chars().collect())
}
}
fn fold_chars(s: &str) -> Vec<char> {
s.chars()
.map(|c| c.to_lowercase().next().unwrap_or(c))
.collect()
}
fn mb_str_pad(args: &[Value]) -> Result<Value, String> {
let s: Vec<char> = str_arg(args, 0).chars().collect();
let target = int_arg(args, 1);
let pad_str = match args.get(2) {
Some(v) if !matches!(v, Value::Undef) => str_arg(args, 2),
_ => " ".to_string(),
};
let pad: Vec<char> = pad_str.chars().collect();
let pad_type = resolve_pad_type(&arg(args, 3));
if target <= s.len() as i64 {
return Ok(Value::str(s.into_iter().collect::<String>()));
}
if pad.is_empty() {
return Err(throws(
"ValueError",
"mb_str_pad(): Argument #3 ($pad_string) must not be empty",
));
}
let total = target as usize - s.len();
let make = |n: usize| -> Vec<char> { pad.iter().cloned().cycle().take(n).collect() };
let mut out: Vec<char> = Vec::new();
match pad_type {
0 => {
out.extend(make(total));
out.extend(s);
}
2 => {
let left = total / 2;
let right = total - left;
out.extend(make(left));
out.extend(s);
out.extend(make(right));
}
_ => {
out.extend(s);
out.extend(make(total));
}
}
Ok(Value::str(out.into_iter().collect::<String>()))
}
fn resolve_pad_type(v: &Value) -> i64 {
if let Value::Str(name) = v {
match name.as_str() {
"STR_PAD_LEFT" => return 0,
"STR_PAD_RIGHT" => return 1,
"STR_PAD_BOTH" => return 2,
_ => {}
}
}
match v {
Value::Undef => 1,
_ => v.to_int(),
}
}
fn mb_ord(args: &[Value]) -> Result<Value, String> {
match str_arg(args, 0).chars().next() {
Some(c) => Ok(Value::int(c as i64)),
None => Err(throws(
"ValueError",
"mb_ord(): Argument #1 ($string) must not be empty",
)),
}
}
fn mb_chr(args: &[Value]) -> Value {
let cp = int_arg(args, 0);
match u32::try_from(cp).ok().and_then(char::from_u32) {
Some(c) => Value::str(c.to_string()),
None => Value::bool(false),
}
}
fn mb_lcfirst(s: &str) -> String {
let mut chars = s.chars();
match chars.next() {
Some(first) => first.to_lowercase().collect::<String>() + chars.as_str(),
None => String::new(),
}
}
fn mb_ucfirst(s: &str) -> String {
let mut chars = s.chars();
match chars.next() {
Some(first) => first.to_uppercase().collect::<String>() + chars.as_str(),
None => String::new(),
}
}
fn mb_strcut(args: &[Value]) -> String {
let s = str_arg(args, 0);
let blen = s.len() as i64;
let mut start = int_arg(args, 1);
if start < 0 {
start = (blen + start).max(0);
}
let start = start.clamp(0, blen) as usize;
let end = match args.get(2) {
Some(v) if !matches!(v, Value::Undef) => {
let l = with_host(|h| h.to_number(v).to_int());
if l < 0 {
(blen + l).max(0) as usize
} else {
(start as i64).saturating_add(l).min(blen) as usize
}
}
_ => blen as usize,
};
let start = floor_char_boundary(&s, start);
let end = floor_char_boundary(&s, end.max(start));
s[start..end].to_string()
}
fn floor_char_boundary(s: &str, mut i: usize) -> usize {
if i >= s.len() {
return s.len();
}
while i > 0 && !s.is_char_boundary(i) {
i -= 1;
}
i
}
fn mb_split(args: &[Value]) -> Value {
let pattern = str_arg(args, 0);
let subject = str_arg(args, 1);
let limit = match args.get(2) {
Some(v) if !matches!(v, Value::Undef) => int_arg(args, 2),
_ => -1,
};
if pattern.is_empty() {
return make_list(vec![Value::str(subject)]);
}
let re = match regex::Regex::new(&pattern) {
Ok(r) => r,
Err(_) => return Value::bool(false),
};
let parts: Vec<Value> = if limit > 0 {
re.splitn(&subject, limit as usize)
.map(|p| Value::str(p.to_string()))
.collect()
} else {
re.split(&subject)
.map(|p| Value::str(p.to_string()))
.collect()
};
make_list(parts)
}
fn mb_convert_kana(args: &[Value]) -> String {
let s = str_arg(args, 0);
let mode = match args.get(1) {
Some(v) if !matches!(v, Value::Undef) => str_arg(args, 1),
_ => "KV".to_string(),
};
let (fw_all, fw_letter, fw_digit) =
(mode.contains('a'), mode.contains('r'), mode.contains('n'));
let (hw_all, hw_letter, hw_digit) =
(mode.contains('A'), mode.contains('R'), mode.contains('N'));
let (fw_space, hw_space) = (mode.contains('s'), mode.contains('S'));
s.chars()
.map(|c| {
let cp = c as u32;
if cp == 0x3000 && fw_space {
return ' ';
}
if cp == 0x20 && hw_space {
return '\u{3000}';
}
if (0xFF01..=0xFF5E).contains(&cp) {
let is_letter = (0xFF21..=0xFF3A).contains(&cp) || (0xFF41..=0xFF5A).contains(&cp);
let is_digit = (0xFF10..=0xFF19).contains(&cp);
if fw_all || (fw_letter && is_letter) || (fw_digit && is_digit) {
return char::from_u32(cp - 0xFEE0).unwrap_or(c);
}
}
if (0x21..=0x7E).contains(&cp) {
let is_letter = c.is_ascii_alphabetic();
let is_digit = c.is_ascii_digit();
if hw_all || (hw_letter && is_letter) || (hw_digit && is_digit) {
return char::from_u32(cp + 0xFEE0).unwrap_or(c);
}
}
c
})
.collect()
}
const WIDE_RANGES: &[(u32, u32)] = &[
(0x1100, 0x115F),
(0x11A3, 0x11A7),
(0x11FA, 0x11FF),
(0x2329, 0x232A),
(0x2E80, 0x2E99),
(0x2E9B, 0x2EF3),
(0x2F00, 0x2FD5),
(0x2FF0, 0x2FFB),
(0x3000, 0x303E),
(0x3041, 0x33FF),
(0x3400, 0x4DBF),
(0x4E00, 0x9FFF),
(0xA000, 0xA4CF),
(0xA960, 0xA97C),
(0xAC00, 0xD7A3),
(0xF900, 0xFAFF),
(0xFE10, 0xFE19),
(0xFE30, 0xFE6B),
(0xFF00, 0xFF60),
(0xFFE0, 0xFFE6),
(0x1B000, 0x1B001),
(0x1F200, 0x1F251),
(0x20000, 0x3FFFD),
];
fn mb_strwidth(s: &str) -> usize {
s.chars()
.map(|c| {
let cp = c as u32;
if WIDE_RANGES.iter().any(|&(lo, hi)| cp >= lo && cp <= hi) {
2
} else {
1
}
})
.sum()
}
fn mb_convert_encoding(args: &[Value]) -> Result<Value, String> {
let s = str_arg(args, 0);
let raw_to = str_arg(args, 1);
let to = normalize_encoding(&raw_to);
if !SUPPORTED_ENCODINGS.contains(&to.as_str()) {
return Err(throws(
"ValueError",
format!(
"mb_convert_encoding(): Argument #2 ($to_encoding) must be a valid \
encoding, \"{raw_to}\" given"
),
));
}
Ok(Value::str(match to.as_str() {
"ASCII" => s
.chars()
.map(|c| if (c as u32) < 0x80 { c } else { '?' })
.collect(),
"ISO-8859-1" => s
.chars()
.map(|c| if (c as u32) <= 0xFF { c } else { '?' })
.collect(),
_ => s,
}))
}
const SUPPORTED_ENCODINGS: &[&str] = &["UTF-8", "ASCII", "ISO-8859-1"];
fn mb_detect_encoding(args: &[Value]) -> Value {
let s = str_arg(args, 0);
let is_ascii = s.is_ascii();
let candidates: Vec<String> = match args.get(1) {
Some(v) if with_host(|h| h.is_array(v)) => with_host(|h| {
h.array_pairs(v)
.unwrap_or_default()
.into_iter()
.map(|(_, val)| normalize_encoding(&h.to_str(&val)))
.collect()
}),
Some(v) if !matches!(v, Value::Undef) => str_arg(args, 1)
.split(',')
.map(|e| normalize_encoding(e.trim()))
.collect(),
_ => vec!["ASCII".to_string(), "UTF-8".to_string()],
};
for cand in &candidates {
let ok = match cand.as_str() {
"ASCII" => is_ascii,
"UTF-8" => true, _ => false,
};
if ok {
return Value::str(cand.clone());
}
}
Value::bool(false)
}
fn mb_check_encoding(args: &[Value]) -> bool {
let s = str_arg(args, 0);
let enc = match args.get(1) {
Some(v) if !matches!(v, Value::Undef) => normalize_encoding(&str_arg(args, 1)),
_ => normalize_encoding(¤t_internal_encoding()),
};
match enc.as_str() {
"ASCII" => s.is_ascii(),
_ => true,
}
}
fn mb_internal_encoding(args: &[Value]) -> Value {
match args.first() {
Some(v) if !matches!(v, Value::Undef) => {
let enc = str_arg(args, 0);
INTERNAL_ENCODING.with(|e| *e.borrow_mut() = enc);
Value::bool(true)
}
_ => Value::str(current_internal_encoding()),
}
}
fn current_internal_encoding() -> String {
INTERNAL_ENCODING.with(|e| e.borrow().clone())
}
fn normalize_encoding(name: &str) -> String {
let up = name.trim().to_ascii_uppercase().replace('_', "-");
match up.as_str() {
"UTF-8" | "UTF8" => "UTF-8".to_string(),
"US-ASCII" | "ASCII" => "ASCII".to_string(),
"ISO-8859-1" | "LATIN1" | "LATIN-1" | "ISO8859-1" => "ISO-8859-1".to_string(),
other => other.to_string(),
}
}