mirror of
https://github.com/pjh456/OxideJS.git
synced 2026-10-24 02:31:13 +08:00
709 lines
29 KiB
Rust
709 lines
29 KiB
Rust
use oxide_runtime_api::{NativeResult, VmHost};
|
||
use oxide_types::object::JsObject;
|
||
use oxide_types::value::JsValue;
|
||
|
||
use crate::builtins_debug;
|
||
use crate::builtins_error;
|
||
|
||
use super::common::try_string;
|
||
use super::{
|
||
as_units, code_point_count, find_units, is_trim_unit, map_well_formed_segments, rfind_units, take_code_points,
|
||
this_units,
|
||
};
|
||
|
||
/// 安全地将 f64 转为 usize：NaN/±Inf/负值→0，超 u64 上限→usize::MAX。
|
||
fn f64_to_usafe_usize(v: f64) -> usize {
|
||
if v.is_finite() && v >= 0.0 {
|
||
let u = v as u64;
|
||
if u <= usize::MAX as u64 {
|
||
u as usize
|
||
} else {
|
||
usize::MAX
|
||
}
|
||
} else {
|
||
0
|
||
}
|
||
}
|
||
|
||
/// 安全地将 f64 转为 i32：NaN/±Inf→0，超 i32 范围→饱和。
|
||
fn f64_to_i32(v: f64) -> i32 {
|
||
if v.is_finite() && v >= i32::MIN as f64 && v <= i32::MAX as f64 {
|
||
v as i32
|
||
} else if v.is_nan() || v.is_infinite() {
|
||
0
|
||
} else if v > 0.0 {
|
||
i32::MAX
|
||
} else {
|
||
i32::MIN
|
||
}
|
||
}
|
||
|
||
/// 安全地将 f64 转为 isize：NaN/±Inf→0，超 isize 范围→饱和。
|
||
fn f64_to_isize(v: f64) -> isize {
|
||
if v.is_finite() && v >= isize::MIN as f64 && v <= isize::MAX as f64 {
|
||
v as isize
|
||
} else if v.is_nan() || v.is_infinite() {
|
||
0
|
||
} else if v > 0.0 {
|
||
isize::MAX
|
||
} else {
|
||
isize::MIN
|
||
}
|
||
}
|
||
|
||
// ── 静态方法 / 构造 ─────────────────────────────────────────────────────
|
||
|
||
/// `String.fromCharCode(...codes)`：把各参数按 ToUint32 低 16 位转为单元拼接
|
||
/// 为字符串（surrogate 区间合法产出孤立 surrogate 单元）。
|
||
pub fn string_from_char_code<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
|
||
builtins_debug!("String.prototype.fromCharCode called with {} args", args.len());
|
||
let mut units: Vec<u16> = Vec::new();
|
||
for &arg_reg in args.iter().skip(1) {
|
||
let code = oxide_runtime_api::to_uint32(vm.reg(arg_reg)) & 0xFFFF;
|
||
units.push(code as u16);
|
||
}
|
||
NativeResult::Ok(vm.new_string_units_owned(units))
|
||
}
|
||
|
||
/// `String.fromCodePoint(...codes)`：把各参数按 ToNumber 语义转成 code point
|
||
/// （0..0x10FFFF 的整数）拼接为字符串；非整数、NaN 或越界抛 RangeError，
|
||
/// Symbol 抛 TypeError。surrogate 区间按现行规范接受（产出孤立 surrogate
|
||
/// 单元，单元载荷可承载）。
|
||
pub fn string_from_code_point<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
|
||
builtins_debug!("String.fromCodePoint called with {} args", args.len());
|
||
let mut units: Vec<u16> = Vec::new();
|
||
// 经 native_arg_count/native_arg_at 读取：大实参集（如 harness 的
|
||
// `String.fromCodePoint.apply(null, codePoints)` 每块 10000 码位）在寄存器
|
||
// 窗口外走 spill 溢出区，小实参集与既有寄存器路径一致。
|
||
for i in 0..vm.native_arg_count(args) {
|
||
let n = match oxide_runtime_api::to_number_full(vm.native_arg_at(args, i), vm) {
|
||
Ok(n) => n,
|
||
Err(_) => {
|
||
// ToNumber 触发对象 valueOf/toString 抛出的原生异常须原样传播，
|
||
// 否则会被展平为普通 Error 丢失原始异常对象。
|
||
if let Some(exc) = vm.take_uncaught_value() {
|
||
return NativeResult::Err(exc);
|
||
}
|
||
return NativeResult::Err(crate::error::create_type_error(vm, "Cannot convert value to a number"));
|
||
}
|
||
};
|
||
if !n.is_finite() || n.trunc() != n || n < 0.0 || n > 0x10FFFF as f64 {
|
||
return NativeResult::Err(crate::error::create_range_error(vm, "Invalid code point"));
|
||
}
|
||
let code = n as u32;
|
||
if code < 0x10000 {
|
||
units.push(code as u16);
|
||
} else {
|
||
let v = code - 0x10000;
|
||
units.push(0xD800 + (v >> 10) as u16);
|
||
units.push(0xDC00 + (v & 0x3FF) as u16);
|
||
}
|
||
}
|
||
NativeResult::Ok(vm.new_string_units_owned(units))
|
||
}
|
||
|
||
/// `String.prototype.valueOf`：返回包装对象的原始字符串；其它 this 抛 TypeError。
|
||
pub fn string_value_of<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
|
||
builtins_debug!("String.prototype.valueOf called with {} args", args.len());
|
||
let this_val = vm.reg(args[0]);
|
||
if this_val.is_string() {
|
||
return NativeResult::Ok(this_val);
|
||
}
|
||
if this_val.is_object() {
|
||
let ptr = this_val.as_js_object_ptr();
|
||
if !ptr.is_null() {
|
||
let obj = unsafe { &*ptr };
|
||
if obj.is_string_obj() {
|
||
return NativeResult::Ok(obj.get_prop_at(0));
|
||
}
|
||
}
|
||
}
|
||
builtins_error!("String.prototype.valueOf: invalid receiver");
|
||
NativeResult::Err(crate::error::create_type_error(
|
||
vm,
|
||
"String.prototype.valueOf called on non-String object",
|
||
))
|
||
}
|
||
|
||
/// JS `String()` 构造逻辑：把参数转成字符串（单元保真）；new 语义返回
|
||
/// `[[StringData]]` 包装对象。
|
||
pub fn string_constructor<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
|
||
let string_proto = vm.session().builtin_world().string_proto.as_ptr() as *mut JsObject;
|
||
let this_val = vm.reg(if args.is_empty() { 0 } else { args[0] });
|
||
let is_ctor = if this_val.is_object() {
|
||
let ptr = this_val.as_js_object_ptr();
|
||
if ptr.is_null() {
|
||
false
|
||
} else {
|
||
let proto_ptr = unsafe { (*ptr).proto().as_js_object_ptr() };
|
||
!proto_ptr.is_null() && std::ptr::eq(proto_ptr, string_proto)
|
||
}
|
||
} else {
|
||
false
|
||
};
|
||
|
||
let str_val = if args.len() > 1 {
|
||
let v = vm.reg(args[1]);
|
||
if is_ctor && v.is_symbol() {
|
||
// new String(Symbol)：构造器路径走 ToString（规范步骤 3b），
|
||
// 对 Symbol 抛 TypeError——与函数调用路径（3a 描述串）相异。
|
||
return NativeResult::Err(crate::error::create_type_error(vm, "Cannot convert a Symbol value to a string"));
|
||
}
|
||
// 对象参数须经 ToPrimitive/ToString 完整转换；函数调用路径的 Symbol
|
||
// 走 SymbolDescriptiveString（规范步骤 3a，不经 ToString）。
|
||
let v = oxide_runtime_api::to_string_for_string_constructor(v, vm);
|
||
match v {
|
||
Ok(s) => vm.new_string_owned(s),
|
||
Err(_) => {
|
||
// ToString on an object may throw via toString/valueOf; propagate the original exception.
|
||
if let Some(exc) = vm.take_uncaught_value() {
|
||
return NativeResult::Err(exc);
|
||
}
|
||
return NativeResult::Err(crate::error::create_type_error(vm, "Cannot convert value to a string"));
|
||
}
|
||
}
|
||
} else {
|
||
vm.new_string("")
|
||
};
|
||
|
||
if !is_ctor {
|
||
return NativeResult::Ok(str_val);
|
||
}
|
||
|
||
let obj = unsafe { &mut *this_val.as_js_object_ptr() };
|
||
obj.type_tag = JsObject::OBJ_TYPE_STRING_OBJ;
|
||
obj.push_prop(str_val);
|
||
NativeResult::Ok(this_val)
|
||
}
|
||
|
||
/// `String.prototype.toString`：返回包装对象的原始字符串；其它 this 抛 TypeError。
|
||
pub fn string_to_string<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
|
||
let this_val = vm.reg(args[0]);
|
||
if this_val.is_string() {
|
||
return NativeResult::Ok(this_val);
|
||
}
|
||
if this_val.is_object() {
|
||
let ptr = this_val.as_js_object_ptr();
|
||
if !ptr.is_null() {
|
||
let obj = unsafe { &*ptr };
|
||
if obj.is_string_obj() {
|
||
return NativeResult::Ok(obj.get_prop_at(0));
|
||
}
|
||
}
|
||
}
|
||
NativeResult::Err(crate::error::create_type_error(
|
||
vm,
|
||
"String.prototype.toString called on non-String object",
|
||
))
|
||
}
|
||
|
||
// ── 查找 / 索引 ─────────────────────────────────────────────────────────
|
||
|
||
/// `String.prototype.indexOf(searchString, position)`：按码元查找首次出现位置。
|
||
pub fn string_index_of<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
|
||
builtins_debug!("String.prototype.indexOf called with {} args", args.len());
|
||
// 参数转换先行：search 缺省为 undefined（经 ToString 得 "undefined" 参与查找），
|
||
// position 缺省 0；均可能触发对象 ToString/ToNumber（&mut 路径）。
|
||
// 单元序列落地为 owned：借用落地后与后续 &mut 调用无交叠。
|
||
let search_val = if args.len() >= 2 { vm.reg(args[1]) } else { JsValue::undefined() };
|
||
let search: Vec<u16> = try_string!(as_units(vm, search_val)).into_owned();
|
||
let pos_raw = if args.len() > 2 {
|
||
f64_to_usafe_usize(vm.coerce_number_bounded(vm.reg(args[2])).unwrap_or(f64::NAN))
|
||
} else {
|
||
0
|
||
};
|
||
let s: Vec<u16> = try_string!(this_units(vm, args)).into_owned();
|
||
let n = s.len();
|
||
let pos = pos_raw.min(n);
|
||
|
||
if search.is_empty() {
|
||
return NativeResult::Ok(JsValue::int(pos as i32));
|
||
}
|
||
if let Some(idx) = find_units(&s, &search, pos) {
|
||
return NativeResult::Ok(JsValue::int(idx as i32));
|
||
}
|
||
NativeResult::Ok(JsValue::int(-1))
|
||
}
|
||
|
||
/// `String.prototype.includes(searchString, position)`：是否包含子串。
|
||
pub fn string_includes<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
|
||
builtins_debug!("String.prototype.includes called with {} args", args.len());
|
||
// 参数转换先行（&mut 路径）：search 缺省为 undefined（经 ToString 得 "undefined"）。
|
||
let search_val = if args.len() >= 2 { vm.reg(args[1]) } else { JsValue::undefined() };
|
||
let search: Vec<u16> = try_string!(as_units(vm, search_val)).into_owned();
|
||
let pos_raw = if args.len() > 2 {
|
||
f64_to_usafe_usize(vm.coerce_number_bounded(vm.reg(args[2])).unwrap_or(f64::NAN))
|
||
} else {
|
||
0
|
||
};
|
||
let s: Vec<u16> = try_string!(this_units(vm, args)).into_owned();
|
||
let pos = pos_raw.min(s.len());
|
||
|
||
if search.is_empty() {
|
||
return NativeResult::Ok(JsValue::bool(true));
|
||
}
|
||
NativeResult::Ok(JsValue::bool(find_units(&s, &search, pos).is_some()))
|
||
}
|
||
|
||
/// `String.prototype.charAt(index)`：返回指定码元位置的 1 单元字符串；越界返回空串。
|
||
pub fn string_char_at<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
|
||
builtins_debug!("String.prototype.charAt called with {} args", args.len());
|
||
// index 可能触发对象 ToNumber（&mut 路径），先行转换。
|
||
let idx = if args.len() >= 2 {
|
||
f64_to_i32(vm.coerce_number_bounded(vm.reg(args[1])).unwrap_or(f64::NAN))
|
||
} else {
|
||
0
|
||
};
|
||
let s: Vec<u16> = try_string!(this_units(vm, args)).into_owned();
|
||
if idx < 0 || idx as usize >= s.len() {
|
||
return NativeResult::Ok(vm.new_string(""));
|
||
}
|
||
let u = s[idx as usize];
|
||
// ASCII 单元走单字符缓存零分配，其余（含孤立 surrogate）回落 1 单元串创建。
|
||
match vm.single_unit(u) {
|
||
Some(v) => NativeResult::Ok(v),
|
||
None => NativeResult::Ok(vm.new_string_units(&[u])),
|
||
}
|
||
}
|
||
|
||
/// `String.prototype.charCodeAt(index)`：返回指定码元位置的 code unit；越界返回 NaN。
|
||
pub fn string_char_code_at<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
|
||
builtins_debug!("String.prototype.charCodeAt called with {} args", args.len());
|
||
// index 可能触发对象 ToNumber（&mut 路径），先行转换。
|
||
let idx = if args.len() >= 2 {
|
||
f64_to_i32(vm.coerce_number_bounded(vm.reg(args[1])).unwrap_or(f64::NAN))
|
||
} else {
|
||
0
|
||
};
|
||
let s = try_string!(this_units(vm, args));
|
||
if idx < 0 || idx as usize >= s.len() {
|
||
return NativeResult::Ok(JsValue::float(f64::NAN));
|
||
}
|
||
NativeResult::Ok(JsValue::int(s[idx as usize] as i32))
|
||
}
|
||
|
||
/// `String.prototype.codePointAt(pos)`：按码元位置取 code point（surrogate 对
|
||
/// 合并）；越界或孤立代理返回 undefined。
|
||
pub fn string_code_point_at<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
|
||
builtins_debug!("String.prototype.codePointAt called with {} args", args.len());
|
||
// pos 转换先行（&mut 路径），后取 this 单元序列定位。
|
||
let pos = if args.len() > 1 {
|
||
let pos_val = vm.reg(args[1]);
|
||
if pos_val.is_symbol() {
|
||
return NativeResult::Err(crate::error::create_type_error(vm, "Cannot convert a Symbol value to a number"));
|
||
}
|
||
match vm.coerce_number_bounded(pos_val) {
|
||
Ok(n) => n,
|
||
Err(_) => {
|
||
// pos 对象 valueOf/toString 抛出的异常须原样传播。
|
||
if let Some(exc) = vm.take_uncaught_value() {
|
||
return NativeResult::Err(exc);
|
||
}
|
||
return NativeResult::Err(crate::error::create_type_error(vm, "Cannot convert argument to a number"));
|
||
}
|
||
}
|
||
} else {
|
||
0.0
|
||
};
|
||
let pos = if pos.is_nan() { 0.0 } else { pos.trunc() };
|
||
if pos < 0.0 || pos > u32::MAX as f64 {
|
||
return NativeResult::Ok(JsValue::undefined());
|
||
}
|
||
let pos = pos as usize;
|
||
let s = try_string!(this_units(vm, args));
|
||
if pos >= s.len() {
|
||
return NativeResult::Ok(JsValue::undefined());
|
||
}
|
||
let first = s[pos];
|
||
if (0xD800..=0xDBFF).contains(&first) && pos + 1 < s.len() {
|
||
let second = s[pos + 1];
|
||
if (0xDC00..=0xDFFF).contains(&second) {
|
||
let cp = 0x10000 + (((first - 0xD800) as u32) << 10) + (second - 0xDC00) as u32;
|
||
return NativeResult::Ok(JsValue::int(cp as i32));
|
||
}
|
||
}
|
||
NativeResult::Ok(JsValue::int(first as i32))
|
||
}
|
||
|
||
/// `String.prototype.lastIndexOf(searchString, position)`：从后往前查找首次
|
||
/// 出现位置（起始位置 ≤ position，position 缺省串长）。
|
||
pub fn string_last_index_of<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
|
||
builtins_debug!("String.prototype.lastIndexOf called with {} args", args.len());
|
||
// 参数转换先行（&mut 路径）：search 缺省为 undefined（经 ToString 得 "undefined"）。
|
||
let search_val = if args.len() >= 2 { vm.reg(args[1]) } else { JsValue::undefined() };
|
||
let search: Vec<u16> = try_string!(as_units(vm, search_val)).into_owned();
|
||
let pos_raw = if args.len() > 2 {
|
||
let p = oxide_runtime_api::to_integer_or_infinity(vm.reg(args[2]));
|
||
if p.is_nan() {
|
||
None
|
||
} else {
|
||
Some(p as usize)
|
||
}
|
||
} else {
|
||
None
|
||
};
|
||
let s: Vec<u16> = try_string!(this_units(vm, args)).into_owned();
|
||
let n = s.len();
|
||
let pos = match pos_raw {
|
||
Some(p) => p.min(n),
|
||
None => n,
|
||
};
|
||
|
||
if search.is_empty() {
|
||
return NativeResult::Ok(JsValue::int(pos as i32));
|
||
}
|
||
// 窗口 = 前 pos+1 个码元：起始位置 ≤ pos 的末次出现。
|
||
let window = (pos + 1).min(n);
|
||
if let Some(idx) = rfind_units(&s, &search, window) {
|
||
return NativeResult::Ok(JsValue::int(idx as i32));
|
||
}
|
||
NativeResult::Ok(JsValue::int(-1))
|
||
}
|
||
|
||
// ── 切片 / 变换 ─────────────────────────────────────────────────────────
|
||
|
||
/// `String.prototype.concat(...strings)`：拼接 this 与各参数返回新字符串
|
||
/// （单元口径，参数经完整 ToString）。
|
||
pub fn string_concat<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
|
||
builtins_debug!("String.prototype.concat called with {} args", args.len());
|
||
let mut units = try_string!(this_units(vm, args)).into_owned();
|
||
for &arg_reg in args.iter().skip(1) {
|
||
match oxide_runtime_api::to_string_value_full(vm.reg(arg_reg), vm) {
|
||
Ok(v) => units.extend(vm.string_units(v).as_ref()),
|
||
Err(_) => {
|
||
// ToString on an object may throw via toString/valueOf; propagate the original exception.
|
||
if let Some(exc) = vm.take_uncaught_value() {
|
||
return NativeResult::Err(exc);
|
||
}
|
||
return NativeResult::Err(crate::error::create_type_error(vm, "Cannot convert value to a string"));
|
||
}
|
||
}
|
||
}
|
||
NativeResult::Ok(vm.new_string_units_owned(units))
|
||
}
|
||
|
||
/// `String.prototype.slice(start, end)`：按码元区间（支持负索引）取子串。
|
||
pub fn string_slice<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
|
||
builtins_debug!("String.prototype.slice called with {} args", args.len());
|
||
// 位置参数先行（&mut 转换），后借 this 取子串。
|
||
let start_raw = if args.len() > 1 {
|
||
Some(f64_to_i32(vm.coerce_number_bounded(vm.reg(args[1])).unwrap_or(f64::NAN)))
|
||
} else {
|
||
None
|
||
};
|
||
let end_raw = if args.len() > 2 {
|
||
Some(f64_to_i32(vm.coerce_number_bounded(vm.reg(args[2])).unwrap_or(f64::NAN)))
|
||
} else {
|
||
None
|
||
};
|
||
let s: Vec<u16> = try_string!(this_units(vm, args)).into_owned();
|
||
let n = s.len() as i32;
|
||
let start = match start_raw {
|
||
Some(v) => {
|
||
if v < 0 {
|
||
(n + v).max(0)
|
||
} else {
|
||
v.min(n)
|
||
}
|
||
}
|
||
None => 0,
|
||
};
|
||
let end = match end_raw {
|
||
Some(v) => {
|
||
if v < 0 {
|
||
(n + v).max(0)
|
||
} else {
|
||
v.min(n)
|
||
}
|
||
}
|
||
None => n,
|
||
};
|
||
// 码元区间精确切片（孤立 surrogate 按单元保留，不吸附字符边界）。
|
||
let out: Vec<u16> = if start < end {
|
||
let (a, b) = (start as usize, end as usize);
|
||
s[a.min(s.len())..b.min(s.len())].to_vec()
|
||
} else {
|
||
Vec::new()
|
||
};
|
||
NativeResult::Ok(vm.new_string_units_owned(out))
|
||
}
|
||
|
||
/// `String.prototype.substring(start, end)`：取子串，start/end 自动对调且取非负。
|
||
pub fn string_substring<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
|
||
builtins_debug!("String.prototype.substring called with {} args", args.len());
|
||
// 寄存器取值先行（纯函数），后借 this 取子串。
|
||
let start_arg = if args.len() > 1 { Some(vm.reg(args[1])) } else { None };
|
||
let end_arg = if args.len() > 2 { Some(vm.reg(args[2])) } else { None };
|
||
let s: Vec<u16> = try_string!(this_units(vm, args)).into_owned();
|
||
let n = s.len() as i32;
|
||
let mut start = match start_arg {
|
||
Some(v) => {
|
||
let v = oxide_runtime_api::to_integer_or_infinity(v);
|
||
if v.is_nan() || v < 0.0 {
|
||
0
|
||
} else {
|
||
(v as i32).min(n)
|
||
}
|
||
}
|
||
None => 0,
|
||
};
|
||
let mut end = match end_arg {
|
||
Some(v) => {
|
||
let v = oxide_runtime_api::to_integer_or_infinity(v);
|
||
if v.is_nan() || v < 0.0 {
|
||
0
|
||
} else {
|
||
(v as i32).min(n)
|
||
}
|
||
}
|
||
None => n,
|
||
};
|
||
if start > end {
|
||
std::mem::swap(&mut start, &mut end);
|
||
}
|
||
let out: Vec<u16> = s[start as usize..end as usize].to_vec();
|
||
NativeResult::Ok(vm.new_string_units_owned(out))
|
||
}
|
||
|
||
/// `String.prototype.substr(start, length)`：从 start 起取 length 个码元
|
||
/// （Annex B，支持负 start）。
|
||
pub fn string_substr<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
|
||
builtins_debug!("String.prototype.substr called with {} args", args.len());
|
||
// 寄存器取值先行（纯函数），后借 this 截取。
|
||
let start_arg = if args.len() > 1 { Some(vm.reg(args[1])) } else { None };
|
||
let length_arg = if args.len() > 2 { Some(vm.reg(args[2])) } else { None };
|
||
let s: Vec<u16> = try_string!(this_units(vm, args)).into_owned();
|
||
let len = s.len() as isize;
|
||
let start = match start_arg {
|
||
Some(v) => {
|
||
let n = f64_to_isize(oxide_runtime_api::to_integer_or_infinity(v));
|
||
if n < 0 {
|
||
(len + n).max(0)
|
||
} else {
|
||
n.min(len)
|
||
}
|
||
}
|
||
None => 0,
|
||
} as usize;
|
||
let length = match length_arg {
|
||
Some(v) => f64_to_isize(oxide_runtime_api::to_integer_or_infinity(v)).max(0) as usize,
|
||
None => len as usize - start,
|
||
};
|
||
let count = length.min(len as usize - start);
|
||
let out: Vec<u16> = s[start..start + count].to_vec();
|
||
NativeResult::Ok(vm.new_string_units_owned(out))
|
||
}
|
||
|
||
/// `String.prototype.at(index)`：按码元索引取 1 单元字符串（支持负索引）；
|
||
/// 越界返回 undefined。
|
||
pub fn string_at<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
|
||
builtins_debug!("String.prototype.at called with {} args", args.len());
|
||
let idx = if args.len() > 1 {
|
||
f64_to_i32(oxide_runtime_api::to_integer_or_infinity(vm.reg(args[1])))
|
||
} else {
|
||
0
|
||
};
|
||
let s = try_string!(this_units(vm, args));
|
||
let len = s.len() as i32;
|
||
let idx = if idx < 0 { len + idx } else { idx };
|
||
if idx < 0 || idx >= len {
|
||
return NativeResult::Ok(JsValue::undefined());
|
||
}
|
||
let u = s[idx as usize];
|
||
match vm.single_unit(u) {
|
||
Some(v) => NativeResult::Ok(v),
|
||
None => NativeResult::Ok(vm.new_string_units(&[u])),
|
||
}
|
||
}
|
||
|
||
/// `String.prototype.toUpperCase`：全大写转换（良形段映射，孤立 surrogate
|
||
/// 单元原样保留）。
|
||
pub fn string_to_upper_case<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
|
||
builtins_debug!("String.prototype.toUpperCase called with {} args", args.len());
|
||
let s = try_string!(this_units(vm, args));
|
||
let out = map_well_formed_segments(&s, |seg| seg.to_uppercase());
|
||
NativeResult::Ok(vm.new_string_units_owned(out))
|
||
}
|
||
|
||
/// `String.prototype.toLowerCase`：全小写转换（良形段映射，孤立 surrogate
|
||
/// 单元原样保留）。
|
||
pub fn string_to_lower_case<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
|
||
builtins_debug!("String.prototype.toLowerCase called with {} args", args.len());
|
||
let s = try_string!(this_units(vm, args));
|
||
let out = map_well_formed_segments(&s, |seg| seg.to_lowercase());
|
||
NativeResult::Ok(vm.new_string_units_owned(out))
|
||
}
|
||
|
||
/// `String.prototype.trim`：去除两端白空格（单元口径）。
|
||
pub fn string_trim<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
|
||
builtins_debug!("String.prototype.trim called with {} args", args.len());
|
||
let s: Vec<u16> = try_string!(this_units(vm, args)).into_owned();
|
||
let n = s.len();
|
||
let mut start = 0;
|
||
while start < n && is_trim_unit(s[start]) {
|
||
start += 1;
|
||
}
|
||
let mut end = n;
|
||
while end > start && is_trim_unit(s[end - 1]) {
|
||
end -= 1;
|
||
}
|
||
NativeResult::Ok(vm.new_string_units_owned(s[start..end].to_vec()))
|
||
}
|
||
|
||
/// `String.prototype.trimStart`：去除头部白空格。
|
||
pub fn string_trim_start<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
|
||
builtins_debug!("String.prototype.trimStart called with {} args", args.len());
|
||
let s: Vec<u16> = try_string!(this_units(vm, args)).into_owned();
|
||
let mut start = 0;
|
||
while start < s.len() && is_trim_unit(s[start]) {
|
||
start += 1;
|
||
}
|
||
NativeResult::Ok(vm.new_string_units_owned(s[start..].to_vec()))
|
||
}
|
||
|
||
/// `String.prototype.trimEnd`：去除尾部白空格。
|
||
pub fn string_trim_end<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
|
||
builtins_debug!("String.prototype.trimEnd called with {} args", args.len());
|
||
let s: Vec<u16> = try_string!(this_units(vm, args)).into_owned();
|
||
let mut end = s.len();
|
||
while end > 0 && is_trim_unit(s[end - 1]) {
|
||
end -= 1;
|
||
}
|
||
NativeResult::Ok(vm.new_string_units_owned(s[..end].to_vec()))
|
||
}
|
||
|
||
/// `String.prototype.repeat(count)`：重复字符串 count 次（当前上限 10000 防滥用）。
|
||
pub fn string_repeat<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
|
||
builtins_debug!("String.prototype.repeat called with {} args", args.len());
|
||
// count 转换先行（&mut 路径），后借 this 重复。
|
||
let n = if args.len() > 1 {
|
||
f64_to_usafe_usize(vm.coerce_number_bounded(vm.reg(args[1])).unwrap_or(f64::NAN)).min(10000)
|
||
} else {
|
||
1
|
||
};
|
||
let s = try_string!(this_units(vm, args));
|
||
let mut out = Vec::with_capacity(s.len() * n);
|
||
for _ in 0..n {
|
||
out.extend_from_slice(&s);
|
||
}
|
||
NativeResult::Ok(vm.new_string_units_owned(out))
|
||
}
|
||
|
||
/// `String.prototype.padStart(targetLength, padString)`：在头部补足 padString
|
||
/// 到目标码点数。
|
||
pub fn string_pad_start<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
|
||
builtins_debug!("String.prototype.padStart called with {} args", args.len());
|
||
// 参数转换先行（&mut 路径）：targetLength 与 padString 均可能触发对象转换。
|
||
let target_arg = if args.len() > 1 {
|
||
Some(f64_to_usafe_usize(vm.coerce_number_bounded(vm.reg(args[1])).unwrap_or(f64::NAN)))
|
||
} else {
|
||
None
|
||
};
|
||
let pad_val = if args.len() > 2 { vm.reg(args[2]) } else { JsValue::undefined() };
|
||
// 规范口径：padString 为 undefined（含显式传入）回落空格填充。
|
||
let pad: Vec<u16> = if pad_val.is_undefined() {
|
||
vec![0x20]
|
||
} else {
|
||
try_string!(as_units(vm, pad_val)).into_owned()
|
||
};
|
||
let s: Vec<u16> = try_string!(this_units(vm, args)).into_owned();
|
||
let s_len = code_point_count(&s);
|
||
let target = target_arg.unwrap_or(s_len);
|
||
if target > 10000 {
|
||
builtins_error!("String.prototype.padStart: invalid receiver");
|
||
return NativeResult::Err(crate::error::create_range_error(vm, "Invalid string length"));
|
||
}
|
||
if s_len >= target || pad.is_empty() {
|
||
return NativeResult::Ok(vm.new_string_units_owned(s.to_vec()));
|
||
}
|
||
let needed = target - s_len;
|
||
let pad_len = code_point_count(&pad).max(1);
|
||
let reps = needed.div_ceil(pad_len);
|
||
let mut pad_rep = Vec::with_capacity(pad.len() * reps);
|
||
for _ in 0..reps {
|
||
pad_rep.extend_from_slice(&pad);
|
||
}
|
||
let prefix = take_code_points(&pad_rep, needed);
|
||
let mut out = Vec::with_capacity(prefix.len() + s.len());
|
||
out.extend_from_slice(prefix);
|
||
out.extend_from_slice(&s);
|
||
NativeResult::Ok(vm.new_string_units_owned(out))
|
||
}
|
||
|
||
/// `String.prototype.padEnd(targetLength, padString)`：在尾部补足 padString
|
||
/// 到目标码点数。
|
||
pub fn string_pad_end<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
|
||
builtins_debug!("String.prototype.padEnd called with {} args", args.len());
|
||
// 参数转换先行（&mut 路径）：targetLength 与 padString 均可能触发对象转换。
|
||
let target_arg = if args.len() > 1 {
|
||
Some(f64_to_usafe_usize(vm.coerce_number_bounded(vm.reg(args[1])).unwrap_or(f64::NAN)))
|
||
} else {
|
||
None
|
||
};
|
||
let pad_val = if args.len() > 2 { vm.reg(args[2]) } else { JsValue::undefined() };
|
||
// 规范口径：padString 为 undefined（含显式传入）回落空格填充。
|
||
let pad: Vec<u16> = if pad_val.is_undefined() {
|
||
vec![0x20]
|
||
} else {
|
||
try_string!(as_units(vm, pad_val)).into_owned()
|
||
};
|
||
let s: Vec<u16> = try_string!(this_units(vm, args)).into_owned();
|
||
let s_len = code_point_count(&s);
|
||
let target = target_arg.unwrap_or(s_len);
|
||
if target > 10000 {
|
||
builtins_error!("String.prototype.padEnd: invalid receiver");
|
||
return NativeResult::Err(crate::error::create_range_error(vm, "Invalid string length"));
|
||
}
|
||
if s_len >= target || pad.is_empty() {
|
||
return NativeResult::Ok(vm.new_string_units_owned(s.to_vec()));
|
||
}
|
||
let needed = target - s_len;
|
||
let pad_len = code_point_count(&pad).max(1);
|
||
let reps = needed.div_ceil(pad_len);
|
||
let mut pad_rep = Vec::with_capacity(pad.len() * reps);
|
||
for _ in 0..reps {
|
||
pad_rep.extend_from_slice(&pad);
|
||
}
|
||
let suffix = take_code_points(&pad_rep, needed);
|
||
let mut out = Vec::with_capacity(s.len() + suffix.len());
|
||
out.extend_from_slice(&s);
|
||
out.extend_from_slice(suffix);
|
||
NativeResult::Ok(vm.new_string_units_owned(out))
|
||
}
|
||
|
||
/// `String.prototype.startsWith(searchString, position)`：是否以指定子串开头
|
||
/// （position 起的前缀码元比较，不做字符边界吸附——规格口径）。
|
||
pub fn string_starts_with<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
|
||
builtins_debug!("String.prototype.startsWith called with {} args", args.len());
|
||
// 参数转换先行（&mut 路径）：search 缺省为 undefined（经 ToString 得 "undefined"）。
|
||
let search_val = if args.len() >= 2 { vm.reg(args[1]) } else { JsValue::undefined() };
|
||
let search: Vec<u16> = try_string!(as_units(vm, search_val)).into_owned();
|
||
let pos_raw = if args.len() > 2 {
|
||
f64_to_usafe_usize(vm.coerce_number_bounded(vm.reg(args[2])).unwrap_or(f64::NAN))
|
||
} else {
|
||
0
|
||
};
|
||
let s: Vec<u16> = try_string!(this_units(vm, args)).into_owned();
|
||
let pos = pos_raw.min(s.len());
|
||
let result = if search.is_empty() { true } else { s[pos..].starts_with(&search) };
|
||
NativeResult::Ok(JsValue::bool(result))
|
||
}
|
||
|
||
/// `String.prototype.endsWith(searchString, endPosition)`：是否以指定子串结尾
|
||
/// （截断至 endPosition 的后缀码元比较，不做字符边界吸附——规格口径）。
|
||
pub fn string_ends_with<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
|
||
builtins_debug!("String.prototype.endsWith called with {} args", args.len());
|
||
// 参数转换先行（&mut 路径）：search 缺省为 undefined（经 ToString 得 "undefined"）。
|
||
let search_val = if args.len() >= 2 { vm.reg(args[1]) } else { JsValue::undefined() };
|
||
let search: Vec<u16> = try_string!(as_units(vm, search_val)).into_owned();
|
||
let end_pos_raw = if args.len() > 2 {
|
||
f64_to_usafe_usize(vm.coerce_number_bounded(vm.reg(args[2])).unwrap_or(f64::NAN))
|
||
} else {
|
||
usize::MAX
|
||
};
|
||
let s: Vec<u16> = try_string!(this_units(vm, args)).into_owned();
|
||
let end_pos = end_pos_raw.min(s.len());
|
||
let result = if search.is_empty() { true } else { s[..end_pos].ends_with(&search) };
|
||
NativeResult::Ok(JsValue::bool(result))
|
||
}
|