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());
static DECODED: std::cell::Cell<bool> = const { std::cell::Cell::new(false) };
}
const TEXT_FUNCTIONS: &[&str] = &[
"mb_convert_case",
"mb_stripos",
"mb_strripos",
"mb_substr_count",
"mb_scrub",
"mb_convert_kana",
"mb_strwidth",
"mb_trim",
"mb_ltrim",
"mb_rtrim",
"mb_strstr",
"mb_stristr",
"mb_strrchr",
"mb_strrichr",
"mb_strimwidth",
"mb_encode_numericentity",
"mb_decode_numericentity",
];
fn dispatch_decoded(name: &str, args: &[Value]) -> Option<Result<Value, String>> {
let text_args: Vec<Value> = args
.iter()
.map(|a| match a {
Value::Str(s) if crate::bytes::has_raw(s) => {
Value::str(crate::bytes::mb_text(s).into_owned())
}
other => other.clone(),
})
.collect();
DECODED.set(true);
let result = dispatch(name, &text_args);
DECODED.set(false);
result.map(|r| {
r.map(|v| match v {
Value::Str(s) => text_value(&s),
other => other,
})
})
}
pub fn dispatch(name: &str, args: &[Value]) -> Option<Result<Value, String>> {
if TEXT_FUNCTIONS.contains(&name) && !DECODED.get() {
return dispatch_decoded(name, args);
}
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),
"mb_trim" => return Some(mb_trim(args, "mb_trim", true, true)),
"mb_ltrim" => return Some(mb_trim(args, "mb_ltrim", true, false)),
"mb_rtrim" => return Some(mb_trim(args, "mb_rtrim", false, true)),
"mb_strstr" => return Some(mb_strstr(args, "mb_strstr", false, false)),
"mb_stristr" => return Some(mb_strstr(args, "mb_stristr", true, false)),
"mb_strrchr" => return Some(mb_strstr(args, "mb_strrchr", false, true)),
"mb_strrichr" => return Some(mb_strstr(args, "mb_strrichr", true, true)),
"mb_strimwidth" => return Some(mb_strimwidth(args)),
"mb_encode_numericentity" => return Some(mb_encode_numericentity(args)),
"mb_decode_numericentity" => return Some(mb_decode_numericentity(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 bytes = crate::bytes::to_bytes(&s);
let units = crate::bytes::mb_units(&bytes);
let out: Vec<Value> = units
.chunks(usize::try_from(length).unwrap_or(usize::MAX))
.map(|c| Value::str(c.iter().map(|u| u.stored()).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 utf8_step(lead: u8) -> usize {
match lead {
0xC2..=0xDF => 2,
0xE0..=0xEF => 3,
0xF0..=0xF4 => 4,
_ => 1,
}
}
fn utf8_fast_len(b: &[u8]) -> usize {
b.iter().filter(|&&c| !(0x80..0xC0).contains(&c)).count()
}
fn utf8_offset(b: &[u8], start: usize, offset: i64) -> Option<usize> {
if offset < 0 {
let mut pos = b.len();
let mut offset = offset;
while offset < 0 {
if pos <= start {
return None;
}
pos -= 1;
if !(0x80..0xC0).contains(&b[pos]) {
offset += 1;
}
}
Some(pos)
} else {
let mut pos = start;
for _ in 0..offset {
if pos >= b.len() {
return None;
}
pos += utf8_step(b[pos]);
}
Some(pos.min(b.len()))
}
}
fn mb_find_strpos(
hay: &[u8],
needle: &[u8],
offset: i64,
reverse: bool,
) -> Result<Option<usize>, ()> {
let from = utf8_offset(hay, 0, offset).ok_or(())?;
if hay.len() < needle.len() {
return Ok(None);
}
let found = if !reverse {
crate::bytes::find(&hay[from..], needle).map(|i| i + from)
} else if offset >= 0 {
crate::bytes::rfind(&hay[from..], needle).map(|i| i + from)
} else {
let needle_len = utf8_fast_len(needle) as i64;
let end = utf8_offset(hay, from, needle_len).unwrap_or(hay.len());
crate::bytes::rfind(&hay[..end], needle)
};
Ok(found.map(|at| utf8_fast_len(&hay[..at])))
}
fn find_strpos_call(args: &[Value], fname: &str, reverse: bool) -> Result<Value, String> {
let hay = crate::bytes::to_bytes(&str_arg(args, 0)).into_owned();
let needle = crate::bytes::to_bytes(&str_arg(args, 1)).into_owned();
match mb_find_strpos(&hay, &needle, int_arg(args, 2), reverse) {
Ok(Some(n)) => Ok(Value::int(n as i64)),
Ok(None) => Ok(Value::bool(false)),
Err(()) => Err(throws(
"ValueError",
format!(
"{fname}(): Argument #3 ($offset) must be contained in argument #1 ($haystack)"
),
)),
}
}
fn mb_strpos(args: &[Value], ci: bool) -> Result<Value, String> {
if !ci {
return find_strpos_call(args, "mb_strpos", false);
}
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> {
if !ci {
return find_strpos_call(args, "mb_strrpos", true);
}
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 subject = crate::bytes::to_bytes(&str_arg(args, 0)).into_owned();
let s = stored_units(&subject);
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_bytes = crate::bytes::to_bytes(&pad_str).into_owned();
let pad = stored_units(&pad_bytes);
let pad_type = resolve_pad_type(&arg(args, 3));
if target <= s.len() as i64 {
return Ok(Value::str(s.concat()));
}
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<String> { pad.iter().cloned().cycle().take(n).collect() };
let mut out: Vec<String> = 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(crate::bytes::canonical(out.concat())))
}
fn stored_units(b: &[u8]) -> Vec<String> {
crate::bytes::mb_units(b)
.into_iter()
.map(crate::bytes::MbUnit::stored)
.collect()
}
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> {
let bytes = crate::bytes::to_bytes(&str_arg(args, 0)).into_owned();
match crate::bytes::mb_units(&bytes).first() {
Some(crate::bytes::MbUnit::Char(c)) => Ok(Value::int(*c as i64)),
Some(crate::bytes::MbUnit::Invalid(_)) => Ok(Value::bool(false)),
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) => text_value(c.encode_utf8(&mut [0u8; 4])),
None => Value::bool(false),
}
}
fn mb_lcfirst(s: &str) -> String {
let mut chars = s.chars();
match chars.next() {
Some(first) if crate::bytes::has_raw(first.encode_utf8(&mut [0u8; 4])) => s.to_string(),
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) if crate::bytes::has_raw(first.encode_utf8(&mut [0u8; 4])) => s.to_string(),
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"
),
));
}
let candidates: Vec<String> = match args.get(2) {
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, 2)
.split(',')
.map(|e| normalize_encoding(e.trim()))
.collect(),
_ => Vec::new(),
};
let valid_in = |cs: &str| match cs {
"ASCII" => crate::bytes::to_bytes(&s).is_ascii(),
"UTF-8" => crate::bytes::is_utf8(&s),
_ => true,
};
let from = match candidates.as_slice() {
[one] => one.clone(),
many => many
.iter()
.find(|c| valid_in(c))
.cloned()
.unwrap_or_else(|| "UTF-8".to_string()),
};
let text: String = match from.as_str() {
"ASCII" => crate::bytes::to_bytes(&s)
.iter()
.map(|&b| if b < 0x80 { char::from(b) } else { '?' })
.collect(),
"ISO-8859-1" => crate::bytes::to_bytes(&s)
.iter()
.map(|&b| char::from(b))
.collect(),
_ => crate::bytes::mb_text(&s).into_owned(),
};
Ok(match to.as_str() {
"ASCII" => Value::str(
text.chars()
.map(|c| if c.is_ascii() { c } else { '?' })
.collect::<String>(),
),
"ISO-8859-1" => {
let bytes: Vec<u8> = text
.chars()
.map(|c| u8::try_from(u32::from(c)).unwrap_or(b'?'))
.collect();
Value::str(crate::bytes::from_bytes(&bytes))
}
_ => Value::str(text),
})
}
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(),
"UTF-8" => crate::bytes::is_utf8(&s),
_ => 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(),
}
}
const KNOWN_ENCODINGS: &[&str] = &[
"BASE64",
"UUENCODE",
"HTML-ENTITIES",
"QUOTED-PRINTABLE",
"7BIT",
"8BIT",
"UCS-4",
"UCS-4BE",
"UCS-4LE",
"UCS-2",
"UCS-2BE",
"UCS-2LE",
"UTF-32",
"UTF-32BE",
"UTF-32LE",
"UTF-16",
"UTF-16BE",
"UTF-16LE",
"UTF-8",
"UTF-7",
"UTF7-IMAP",
"ASCII",
"EUC-JP",
"SJIS",
"EUCJP-WIN",
"EUC-JP-2004",
"SJIS-MOBILE#DOCOMO",
"SJIS-MOBILE#KDDI",
"SJIS-MOBILE#SOFTBANK",
"SJIS-MAC",
"SJIS-2004",
"UTF-8-MOBILE#DOCOMO",
"UTF-8-MOBILE#KDDI-A",
"UTF-8-MOBILE#KDDI-B",
"UTF-8-MOBILE#SOFTBANK",
"CP932",
"SJIS-WIN",
"CP51932",
"JIS",
"ISO-2022-JP",
"ISO-2022-JP-MS",
"GB18030",
"GB18030-2022",
"WINDOWS-1252",
"WINDOWS-1254",
"ISO-8859-1",
"ISO-8859-2",
"ISO-8859-3",
"ISO-8859-4",
"ISO-8859-5",
"ISO-8859-6",
"ISO-8859-7",
"ISO-8859-8",
"ISO-8859-9",
"ISO-8859-10",
"ISO-8859-13",
"ISO-8859-14",
"ISO-8859-15",
"ISO-8859-16",
"EUC-CN",
"CP936",
"HZ",
"EUC-TW",
"BIG-5",
"CP950",
"EUC-KR",
"UHC",
"ISO-2022-KR",
"WINDOWS-1251",
"CP866",
"KOI8-R",
"KOI8-U",
"ARMSCII-8",
"CP850",
"ISO-2022-JP-2004",
"ISO-2022-JP-MOBILE#KDDI",
"CP50220",
"CP50221",
"CP50222",
];
fn check_encoding(fname: &str, args: &[Value], at: usize) -> Result<(), String> {
match args.get(at) {
None | Some(Value::Undef) => Ok(()),
Some(_) => {
let name = str_arg(args, at);
if KNOWN_ENCODINGS.contains(&name.to_ascii_uppercase().as_str()) {
Ok(())
} else {
Err(throws(
"ValueError",
format!(
"{fname}(): Argument #{} ($encoding) must be a valid encoding, \"{name}\" given",
at + 1
),
))
}
}
}
}
fn is_default_trim_char(c: char) -> bool {
matches!(
c as u32,
0x0000 | 0x0009..=0x000D | 0x0020 | 0x0085 | 0x00A0 | 0x1680 | 0x180E
| 0x2000..=0x200A | 0x2028 | 0x2029 | 0x202F | 0x205F | 0x3000
)
}
fn mb_trim(args: &[Value], fname: &str, left: bool, right: bool) -> Result<Value, String> {
check_encoding(fname, args, 2)?;
let s = str_arg(args, 0);
let set: Option<Vec<char>> = match args.get(1) {
None | Some(Value::Undef) => None,
Some(_) => Some(str_arg(args, 1).chars().collect()),
};
let strip = |c: char| match &set {
None => is_default_trim_char(c),
Some(list) => list.contains(&c),
};
let mut out: &str = &s;
if left {
out = out.trim_start_matches(strip);
}
if right {
out = out.trim_end_matches(strip);
}
Ok(Value::str(out.to_string()))
}
fn mb_strstr(args: &[Value], fname: &str, ci: bool, last: bool) -> Result<Value, String> {
check_encoding(fname, args, 3)?;
let before = with_host(|h| h.is_truthy(&arg(args, 2)));
let hay: Vec<char> = str_arg(args, 0).chars().collect();
let (h_cmp, n_cmp) = ci_pair(args, ci);
let nlen = n_cmp.len();
if nlen > h_cmp.len() {
return Ok(Value::bool(false));
}
let matches_at = |i: usize| h_cmp[i..].starts_with(&n_cmp[..]);
let last_start = h_cmp.len() - nlen;
let found = if last {
(0..=last_start).rev().find(|&i| matches_at(i))
} else {
(0..=last_start).find(|&i| matches_at(i))
};
Ok(match found {
None => Value::bool(false),
Some(i) => {
let part: String = if before { &hay[..i] } else { &hay[i..] }.iter().collect();
Value::str(part)
}
})
}
fn mb_strimwidth(args: &[Value]) -> Result<Value, String> {
check_encoding("mb_strimwidth", args, 4)?;
let chars: Vec<char> = str_arg(args, 0).chars().collect();
let mut start = int_arg(args, 1);
let mut width = int_arg(args, 2);
let marker = match args.get(3) {
None | Some(Value::Undef) => String::new(),
Some(_) => str_arg(args, 3),
};
let char_width = |c: char| mb_strwidth(&c.to_string()) as i64;
let total: i64 = chars.iter().map(|&c| char_width(c)).sum();
if start < 0 {
start += chars.len() as i64;
}
if start < 0 || start > chars.len() as i64 {
return Err(throws(
"ValueError",
"mb_strimwidth(): Argument #2 ($start) is out of range",
));
}
if width < 0 {
with_host(|h| {
h.deprecated(
"mb_strimwidth(): passing a negative integer to argument #3 ($width) is deprecated",
)
});
let skipped: i64 = chars[..start as usize].iter().map(|&c| char_width(c)).sum();
width = total + width - skipped;
}
if width < 0 {
return Err(throws(
"ValueError",
"mb_strimwidth(): Argument #3 ($width) is out of range",
));
}
let rest = &chars[start as usize..];
let rest_width: i64 = rest.iter().map(|&c| char_width(c)).sum();
if rest_width <= width {
return Ok(Value::str(rest.iter().collect::<String>()));
}
let marker_width = mb_strwidth(&marker) as i64;
let budget = (width - marker_width).max(0);
let mut out = String::new();
let mut used = 0;
for &c in rest {
let w = char_width(c);
if used + w > budget {
break;
}
used += w;
out.push(c);
}
out.push_str(&marker);
Ok(Value::str(out))
}
fn convmap(fname: &str, args: &[Value]) -> Result<Vec<[i64; 4]>, String> {
let pairs = with_host(|h| h.array_pairs(&arg(args, 1))).unwrap_or_default();
if pairs.len() % 4 != 0 {
return Err(throws(
"ValueError",
format!("{fname}(): Argument #2 ($map) must have a multiple of 4 elements"),
));
}
let nums: Vec<i64> =
with_host(|h| pairs.iter().map(|(_, v)| h.to_number(v).to_int()).collect());
Ok(nums.chunks(4).map(|c| [c[0], c[1], c[2], c[3]]).collect())
}
fn mb_encode_numericentity(args: &[Value]) -> Result<Value, String> {
let map = convmap("mb_encode_numericentity", args)?;
check_encoding("mb_encode_numericentity", args, 2)?;
let hex = with_host(|h| h.is_truthy(&arg(args, 3)));
let mut out = String::new();
for c in str_arg(args, 0).chars() {
let cp = c as i64;
match map.iter().find(|m| cp >= m[0] && cp <= m[1]) {
Some(m) => {
let n = ((cp + m[2]) & m[3]) as u64;
if hex {
out.push_str(&format!("&#x{n:X};"));
} else {
out.push_str(&format!("&#{n};"));
}
}
None => out.push(c),
}
}
Ok(Value::str(out))
}
fn mb_decode_numericentity(args: &[Value]) -> Result<Value, String> {
let map = convmap("mb_decode_numericentity", args)?;
check_encoding("mb_decode_numericentity", args, 2)?;
let s: Vec<char> = str_arg(args, 0).chars().collect();
let mut out = String::new();
let mut i = 0;
while i < s.len() {
if s[i] == '&' && s.get(i + 1) == Some(&'#') {
let hex = s.get(i + 2) == Some(&'x');
let radix = if hex { 16 } else { 10 };
let digits_at = i + 2 + usize::from(hex);
let digits: String = s[digits_at..]
.iter()
.take_while(|c| c.is_digit(radix))
.collect();
let max_digits = if hex { 8 } else { 10 };
if !digits.is_empty() && digits.len() <= max_digits {
if let Ok(n) = i64::from_str_radix(&digits, radix) {
let end = digits_at + digits.len();
let decoded = map
.iter()
.map(|m| (n - m[2], m))
.find(|(v, m)| *v >= m[0] && *v <= m[1])
.and_then(|(v, _)| u32::try_from(v).ok().and_then(char::from_u32));
if let Some(c) = decoded {
out.push(c);
i = if s.get(end) == Some(&';') {
end + 1
} else {
end
};
continue;
}
}
}
}
out.push(s[i]);
i += 1;
}
Ok(Value::str(out))
}