mirror of
https://github.com/pjh456/OxideJS.git
synced 2026-10-23 18:21:13 +08:00
fix: BigInt64Array/BigUint64Array 与 DataView BigInt 存取走真 BigInt 语义
TA 元素读写按 kind 分流：BigInt 类型走 ToBigInt（Number 入参抛 TypeError、 写入 mod 2^64 截断、读出为真 BigInt 值），数值类型走 ToNumber 且显式拒绝 BigInt 值；消除 64 位整数经 f64 中转的静默精度丢失。 - runtime_api 新增公共 to_bigint_full / string_to_bigint_full，bigint 构造器 与 asIntN/asUintN 改调公共版消除双实现 - sort/toSorted 默认序对 BigInt 类型按 i64/u64 值比较；reverse/copyWithin/ filter/toReversed/with 消除无谓数值中转 - 构造器第一参数非对象统一走 ToIndex（bool/null/BigInt/字符串），Symbol 抛 TypeError - DataView get/setBigInt64/getBigUint64 返回 BigInt 值、入参按 ToBigInt 校验 - 测试：精度往返 / TypeError / mod 2^64 / 字节序 / 排序 / 回调值类型断言
This commit is contained in:
@@ -234,95 +234,14 @@ fn bigint_arg<H: VmHost>(vm: &mut H, args: &[u8]) -> JsValue {
|
||||
|
||||
/// ToBigInt 抽象操作（§7.1.14）：BigInt 原样；String → StringToBigInt；
|
||||
/// Boolean → 0/1；Number/Symbol/undefined/null → TypeError；对象先 ToPrimitive 再递归。
|
||||
///
|
||||
/// 语义主体在 `oxide_runtime_api::to_bigint_full`，此处只把 String 错误恢复为
|
||||
/// 对应 kind 的异常对象（用户回调抛出的原始值经 last_uncaught_value 透传）。
|
||||
fn to_bigint<H: VmHost>(vm: &mut H, val: JsValue) -> Result<JsValue, JsValue> {
|
||||
if val.is_bigint() {
|
||||
return Ok(val);
|
||||
match oxide_runtime_api::to_bigint_full(val, vm) {
|
||||
Ok(v) => Ok(v),
|
||||
Err(e) => Err(vm
|
||||
.take_uncaught_value()
|
||||
.unwrap_or_else(|| crate::error::create_from_text(vm, &e))),
|
||||
}
|
||||
if val.is_bool() {
|
||||
return Ok(vm.new_bigint(BigInt::from(if val.as_bool() { 1 } else { 0 })));
|
||||
}
|
||||
if val.is_int() {
|
||||
// ToBigInt(Number) 抛 TypeError（与构造器不同：构造器先 ToPrimitive 再
|
||||
// NumberToBigInt；ToBigInt 直接拒绝 Number）。
|
||||
return Err(crate::error::create_type_error(vm, "Cannot convert a Number value to a BigInt"));
|
||||
}
|
||||
if val.is_double() {
|
||||
return Err(crate::error::create_type_error(vm, "Cannot convert a Number value to a BigInt"));
|
||||
}
|
||||
if val.is_string() {
|
||||
let s = oxide_runtime_api::to_string(val);
|
||||
return match string_to_bigint(vm, &s) {
|
||||
Ok(v) => Ok(v),
|
||||
Err(e) => Err(e),
|
||||
};
|
||||
}
|
||||
if val.is_object() {
|
||||
let prim = match to_primitive(val, ToPrimitiveHint::Default, vm) {
|
||||
Ok(p) => p,
|
||||
Err(_) => {
|
||||
if let Some(exc) = vm.take_uncaught_value() {
|
||||
return Err(exc);
|
||||
}
|
||||
return Err(crate::error::create_type_error(vm, "Cannot convert value to a BigInt"));
|
||||
}
|
||||
};
|
||||
return to_bigint(vm, prim);
|
||||
}
|
||||
// undefined / null / symbol。
|
||||
Err(crate::error::create_type_error(vm, "Cannot convert value to a BigInt"))
|
||||
}
|
||||
|
||||
/// StringToBigInt（§7.1.14 步骤）：去首尾空白，可选 +/- 号与 0x/0o/0b 前缀；
|
||||
/// 空串 → 0n；非法 → SyntaxError。
|
||||
fn string_to_bigint<H: VmHost>(vm: &mut H, s: &str) -> Result<JsValue, JsValue> {
|
||||
let trimmed = s.trim();
|
||||
if trimmed.is_empty() {
|
||||
return Ok(vm.new_bigint(BigInt::from(0)));
|
||||
}
|
||||
let (neg, rest) = if let Some(r) = trimmed.strip_prefix('-') {
|
||||
(true, r)
|
||||
} else if let Some(r) = trimmed.strip_prefix('+') {
|
||||
(false, r)
|
||||
} else {
|
||||
(false, trimmed)
|
||||
};
|
||||
// StringIntegerLiteral：符号只允许出现在纯十进制前；0x/0o/0b 前缀前带
|
||||
// +/-（如 "-0x1"）属于非法语法（test262 constructor-from-string-syntax-errors）。
|
||||
let (radix, digits) = if let Some(hex) = rest.strip_prefix("0x").or_else(|| rest.strip_prefix("0X")) {
|
||||
if neg {
|
||||
return Err(crate::error::create_syntax_error(
|
||||
vm,
|
||||
"Cannot convert string to BigInt: invalid integer literal",
|
||||
));
|
||||
}
|
||||
(16u32, hex)
|
||||
} else if let Some(oct) = rest.strip_prefix("0o").or_else(|| rest.strip_prefix("0O")) {
|
||||
if neg {
|
||||
return Err(crate::error::create_syntax_error(
|
||||
vm,
|
||||
"Cannot convert string to BigInt: invalid integer literal",
|
||||
));
|
||||
}
|
||||
(8u32, oct)
|
||||
} else if let Some(bin) = rest.strip_prefix("0b").or_else(|| rest.strip_prefix("0B")) {
|
||||
if neg {
|
||||
return Err(crate::error::create_syntax_error(
|
||||
vm,
|
||||
"Cannot convert string to BigInt: invalid integer literal",
|
||||
));
|
||||
}
|
||||
(2u32, bin)
|
||||
} else {
|
||||
(10u32, rest)
|
||||
};
|
||||
if digits.is_empty() {
|
||||
return Err(crate::error::create_syntax_error(
|
||||
vm,
|
||||
"Cannot convert string to BigInt: invalid integer literal",
|
||||
));
|
||||
}
|
||||
let m = BigInt::parse_bytes(digits.as_bytes(), radix).ok_or_else(|| {
|
||||
crate::error::create_syntax_error(vm, "Cannot convert string to BigInt: invalid integer literal")
|
||||
})?;
|
||||
Ok(vm.new_bigint(if neg { -m } else { m }))
|
||||
}
|
||||
|
||||
@@ -2,6 +2,9 @@ use oxide_kernel::shape_forge::EMPTY_SHAPE_ID;
|
||||
use oxide_types::object::{JsObject, NativeFnPtr, PropAttributes};
|
||||
use oxide_types::value::JsValue;
|
||||
|
||||
use num_bigint::BigInt;
|
||||
use num_traits::ToPrimitive;
|
||||
|
||||
use crate::array_buffer::array_buffer_data_ptr;
|
||||
|
||||
use oxide_runtime_api::{NativeResult, VmHost};
|
||||
@@ -323,7 +326,8 @@ pub fn data_view_get_float64<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult
|
||||
NativeResult::Ok(JsValue::float(n))
|
||||
}
|
||||
|
||||
/// `DataView.prototype.getBigInt64(byteOffset, littleEndian)`：读取 8 字节有符号 64 位整数。
|
||||
/// `DataView.prototype.getBigInt64(byteOffset, littleEndian)`：读取 8 字节有符号 64 位
|
||||
/// 整数并返回 BigInt 值。
|
||||
pub fn data_view_get_big_int64<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
|
||||
let bytes = native_try!(read_bytes::<8, H>(vm, args));
|
||||
let n = if is_little_endian(vm, args, 2) {
|
||||
@@ -331,10 +335,11 @@ pub fn data_view_get_big_int64<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResu
|
||||
} else {
|
||||
i64::from_be_bytes(bytes)
|
||||
};
|
||||
NativeResult::Ok(JsValue::float(n as f64))
|
||||
NativeResult::Ok(vm.new_bigint(BigInt::from(n)))
|
||||
}
|
||||
|
||||
/// `DataView.prototype.getBigUint64(byteOffset, littleEndian)`：读取 8 字节无符号 64 位整数。
|
||||
/// `DataView.prototype.getBigUint64(byteOffset, littleEndian)`：读取 8 字节无符号
|
||||
/// 64 位整数并返回 BigInt 值。
|
||||
pub fn data_view_get_big_uint64<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
|
||||
let bytes = native_try!(read_bytes::<8, H>(vm, args));
|
||||
let n = if is_little_endian(vm, args, 2) {
|
||||
@@ -342,7 +347,7 @@ pub fn data_view_get_big_uint64<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeRes
|
||||
} else {
|
||||
u64::from_be_bytes(bytes)
|
||||
};
|
||||
NativeResult::Ok(JsValue::float(n as f64))
|
||||
NativeResult::Ok(vm.new_bigint(BigInt::from(n)))
|
||||
}
|
||||
|
||||
/// `DataView.prototype.setInt8(byteOffset, value)`：写入 1 字节有符号整数。
|
||||
@@ -431,30 +436,46 @@ pub fn data_view_set_float64<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult
|
||||
NativeResult::Ok(JsValue::undefined())
|
||||
}
|
||||
|
||||
/// `DataView.prototype.setBigInt64(byteOffset, value, littleEndian)`：写入 8 字节有符号 64 位整数。
|
||||
/// `DataView.prototype.setBigInt64(byteOffset, value, littleEndian)`：按 ToBigInt
|
||||
/// 语义接收值（Number 入参抛 TypeError），取低 64 位位模式写入 8 字节有符号整数。
|
||||
pub fn data_view_set_big_int64<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
|
||||
let value = numeric_arg(vm, args, 2) as i64;
|
||||
let value = if args.len() > 2 { vm.reg(args[2]) } else { JsValue::undefined() };
|
||||
let b =
|
||||
native_try!(oxide_runtime_api::to_bigint_full(value, vm).map_err(|e| crate::iterator::engine_error(vm, &e)));
|
||||
let low = low64(vm, b) as i64;
|
||||
let bytes = if is_little_endian(vm, args, 3) {
|
||||
value.to_le_bytes()
|
||||
low.to_le_bytes()
|
||||
} else {
|
||||
value.to_be_bytes()
|
||||
low.to_be_bytes()
|
||||
};
|
||||
native_try!(write_bytes(vm, args, bytes));
|
||||
NativeResult::Ok(JsValue::undefined())
|
||||
}
|
||||
|
||||
/// `DataView.prototype.setBigUint64(byteOffset, value, littleEndian)`：写入 8 字节无符号 64 位整数。
|
||||
/// `DataView.prototype.setBigUint64(byteOffset, value, littleEndian)`：按 ToBigInt
|
||||
/// 语义接收值（Number 入参抛 TypeError），取低 64 位位模式写入 8 字节无符号整数。
|
||||
pub fn data_view_set_big_uint64<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
|
||||
let value = numeric_arg(vm, args, 2) as u64;
|
||||
let value = if args.len() > 2 { vm.reg(args[2]) } else { JsValue::undefined() };
|
||||
let b =
|
||||
native_try!(oxide_runtime_api::to_bigint_full(value, vm).map_err(|e| crate::iterator::engine_error(vm, &e)));
|
||||
let low = low64(vm, b);
|
||||
let bytes = if is_little_endian(vm, args, 3) {
|
||||
value.to_le_bytes()
|
||||
low.to_le_bytes()
|
||||
} else {
|
||||
value.to_be_bytes()
|
||||
low.to_be_bytes()
|
||||
};
|
||||
native_try!(write_bytes(vm, args, bytes));
|
||||
NativeResult::Ok(JsValue::undefined())
|
||||
}
|
||||
|
||||
/// 取 BigInt 值低 64 位位模式：与 2^64-1 掩码后恒非负且可转 u64。
|
||||
fn low64<H: VmHost>(vm: &mut H, val: JsValue) -> u64 {
|
||||
let v = vm.bigint_value(val);
|
||||
(v & (BigInt::from(u64::MAX)))
|
||||
.to_u64()
|
||||
.expect("与 u64::MAX 掩码后恒在 u64 范围")
|
||||
}
|
||||
|
||||
/// `DataView.prototype.toString`：校验 receiver 后返回 `[object DataView]`。
|
||||
pub fn data_view_to_string<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
|
||||
let this_val = vm.reg(if args.is_empty() { 0 } else { args[0] });
|
||||
|
||||
@@ -1,3 +1,5 @@
|
||||
use num_bigint::BigInt;
|
||||
use num_traits::ToPrimitive;
|
||||
use oxide_kernel::shape_forge::EMPTY_SHAPE_ID;
|
||||
use oxide_types::object::{JsObject, NativeFnPtr, TypedArrayKind};
|
||||
use oxide_types::private_key::{int_key_value, is_int_key};
|
||||
@@ -204,7 +206,7 @@ pub fn typed_array_element_get<H: VmHost>(vm: &mut H, obj: &JsObject, index: u32
|
||||
}
|
||||
let buffer_ptr = array_buffer_data_ptr(vm, view.buffer).map_err(|e| format!("{e}"))?;
|
||||
let buffer = unsafe { &*buffer_ptr };
|
||||
Ok(read_element(view.kind, buffer, absolute_byte_offset(view, index as usize)))
|
||||
Ok(read_element(vm, view.kind, buffer, absolute_byte_offset(view, index as usize)))
|
||||
}
|
||||
|
||||
/// 若对象是 TypedArray 且属性键是整数索引，返回 `(索引, 视图长度)`；否则 `None`。
|
||||
@@ -260,19 +262,29 @@ pub fn typed_array_element_define<H: VmHost>(
|
||||
fn write_typed_array_element<H: VmHost>(
|
||||
vm: &mut H, view: TypedArrayData, index: u32, value: JsValue,
|
||||
) -> Result<(), String> {
|
||||
// 先 ToNumber（valueOf 副作用先于越界判定触发），越界再静默忽略。
|
||||
let n = numeric_value(vm, value);
|
||||
// 先按元素类型转换（valueOf 副作用先于越界判定触发），越界再静默忽略。
|
||||
let elem = match ta_element_value(vm, view.kind, value) {
|
||||
Ok(v) => v,
|
||||
Err(err) => {
|
||||
// 转换失败恢复为可捕获的 JS 异常：主 dispatch 下就地展开到外围 catch，
|
||||
// builtin 内部展开到调用方 try 处理器；uncaught 时以文本上抛。
|
||||
let text = element_error_text(vm, err);
|
||||
return vm.raise_type_error(&text);
|
||||
}
|
||||
};
|
||||
if index as usize >= view.length {
|
||||
return Ok(());
|
||||
}
|
||||
let buffer_ptr = array_buffer_data_ptr(vm, view.buffer).map_err(|e| format!("{e}"))?;
|
||||
// SAFETY: buffer_ptr 经 array_buffer_data_ptr 校验为合法 ArrayBuffer。
|
||||
let buffer = unsafe { &mut *buffer_ptr };
|
||||
write_element(view.kind, buffer, absolute_byte_offset(view, index as usize), n);
|
||||
write_element(vm, view.kind, buffer, absolute_byte_offset(view, index as usize), elem);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn read_element(kind: TypedArrayKind, bytes: &[u8], offset: usize) -> JsValue {
|
||||
/// 读 TypedArray 元素并转为对应 JS 值：BigInt 类型读为 BigInt 值（i64/u64 位模式
|
||||
/// 原样搬运，无精度损失），数值类型按位模式读为 Number。
|
||||
fn read_element<H: VmHost>(vm: &mut H, kind: TypedArrayKind, bytes: &[u8], offset: usize) -> JsValue {
|
||||
match kind {
|
||||
TypedArrayKind::Int8 => JsValue::int(bytes[offset] as i8 as i32),
|
||||
TypedArrayKind::Uint8 | TypedArrayKind::Uint8Clamped => JsValue::int(bytes[offset] as i32),
|
||||
@@ -289,31 +301,95 @@ fn read_element(kind: TypedArrayKind, bytes: &[u8], offset: usize) -> JsValue {
|
||||
}
|
||||
TypedArrayKind::Float64 => JsValue::float(f64::from_ne_bytes(bytes[offset..offset + 8].try_into().unwrap())),
|
||||
TypedArrayKind::BigInt64 => {
|
||||
JsValue::float(i64::from_ne_bytes(bytes[offset..offset + 8].try_into().unwrap()) as f64)
|
||||
let n = i64::from_ne_bytes(bytes[offset..offset + 8].try_into().unwrap());
|
||||
vm.new_bigint(BigInt::from(n))
|
||||
}
|
||||
TypedArrayKind::BigUint64 => {
|
||||
JsValue::float(u64::from_ne_bytes(bytes[offset..offset + 8].try_into().unwrap()) as f64)
|
||||
let n = u64::from_ne_bytes(bytes[offset..offset + 8].try_into().unwrap());
|
||||
vm.new_bigint(BigInt::from(n))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn numeric_value<H: VmHost>(vm: &mut H, value: JsValue) -> f64 {
|
||||
vm.coerce_number_bounded(value).unwrap_or(f64::NAN)
|
||||
/// 元素写入统一转换入口：BigInt 类型走 ToBigInt，数值类型走 ToNumber。
|
||||
///
|
||||
/// 数值类型显式拒绝 BigInt 值（规范 ToNumber(BigInt) 抛 TypeError），避免
|
||||
/// 经 f64 近似的静默精度丢失。
|
||||
fn ta_element_value<H: VmHost>(vm: &mut H, kind: TypedArrayKind, value: JsValue) -> Result<JsValue, JsValue> {
|
||||
if is_bigint_kind(kind) {
|
||||
return oxide_runtime_api::to_bigint_full(value, vm).map_err(|e| crate::iterator::engine_error(vm, &e));
|
||||
}
|
||||
let prim = oxide_runtime_api::to_primitive(value, oxide_runtime_api::ToPrimitiveHint::Number, vm)
|
||||
.map_err(|e| crate::iterator::engine_error(vm, &e))?;
|
||||
if prim.is_bigint() {
|
||||
return Err(type_error(vm, "Cannot convert a BigInt value to a number"));
|
||||
}
|
||||
let n = oxide_runtime_api::to_number_full(prim, vm).map_err(|e| crate::iterator::engine_error(vm, &e))?;
|
||||
Ok(JsValue::float(n))
|
||||
}
|
||||
|
||||
fn write_element(kind: TypedArrayKind, bytes: &mut [u8], offset: usize, value: f64) {
|
||||
/// 元素类型是否为 BigInt 语义（BigInt64/BigUint64）。
|
||||
fn is_bigint_kind(kind: TypedArrayKind) -> bool {
|
||||
matches!(kind, TypedArrayKind::BigInt64 | TypedArrayKind::BigUint64)
|
||||
}
|
||||
|
||||
/// 把异常 JsValue 格式化为 `Kind: message` 文本（属性写路径的 String 错误契约用）。
|
||||
fn element_error_text<H: VmHost>(vm: &mut H, err: JsValue) -> String {
|
||||
if let Some(s) = vm.lookup_str(err) {
|
||||
return s;
|
||||
}
|
||||
if err.is_object() {
|
||||
let obj = unsafe { &*err.as_js_object_ptr() };
|
||||
let name_si = vm.kernel_core().perm_interner().intern("name").0;
|
||||
let message_si = vm.kernel_core().perm_interner().intern("message").0;
|
||||
let name = vm
|
||||
.resolve_property(obj, name_si)
|
||||
.and_then(|v| vm.lookup_str(v))
|
||||
.unwrap_or_else(|| "Error".to_string());
|
||||
let message = vm
|
||||
.resolve_property(obj, message_si)
|
||||
.and_then(|v| vm.lookup_str(v))
|
||||
.unwrap_or_default();
|
||||
if name.is_empty() {
|
||||
message
|
||||
} else if message.is_empty() {
|
||||
name
|
||||
} else {
|
||||
format!("{name}: {message}")
|
||||
}
|
||||
} else {
|
||||
format!("{err}")
|
||||
}
|
||||
}
|
||||
|
||||
/// 把已按元素类型转换的值（数值 kind 为 Number、BigInt kind 为 BigInt）按位模式
|
||||
/// 截断写入底层 buffer。转换由调用方 [`ta_element_value`] 完成，本函数无副作用。
|
||||
fn write_element<H: VmHost>(vm: &mut H, kind: TypedArrayKind, bytes: &mut [u8], offset: usize, value: JsValue) {
|
||||
let n = oxide_runtime_api::to_number(value);
|
||||
match kind {
|
||||
TypedArrayKind::Int8 => bytes[offset] = value as i32 as u8 as i8 as u8,
|
||||
TypedArrayKind::Uint8 => bytes[offset] = value as i32 as u8,
|
||||
TypedArrayKind::Uint8Clamped => bytes[offset] = value.clamp(0.0, 255.0).round() as u8,
|
||||
TypedArrayKind::Int16 => bytes[offset..offset + 2].copy_from_slice(&(value as i32 as u16 as i16).to_ne_bytes()),
|
||||
TypedArrayKind::Uint16 => bytes[offset..offset + 2].copy_from_slice(&(value as i32 as u16).to_ne_bytes()),
|
||||
TypedArrayKind::Int32 => bytes[offset..offset + 4].copy_from_slice(&(value as i32).to_ne_bytes()),
|
||||
TypedArrayKind::Uint32 => bytes[offset..offset + 4].copy_from_slice(&(value as u32).to_ne_bytes()),
|
||||
TypedArrayKind::Float32 => bytes[offset..offset + 4].copy_from_slice(&(value as f32).to_ne_bytes()),
|
||||
TypedArrayKind::Float64 => bytes[offset..offset + 8].copy_from_slice(&value.to_ne_bytes()),
|
||||
TypedArrayKind::BigInt64 => bytes[offset..offset + 8].copy_from_slice(&(value as i64).to_ne_bytes()),
|
||||
TypedArrayKind::BigUint64 => bytes[offset..offset + 8].copy_from_slice(&(value as u64).to_ne_bytes()),
|
||||
TypedArrayKind::Int8 => bytes[offset] = n as i32 as u8 as i8 as u8,
|
||||
TypedArrayKind::Uint8 => bytes[offset] = n as i32 as u8,
|
||||
TypedArrayKind::Uint8Clamped => bytes[offset] = n.clamp(0.0, 255.0).round() as u8,
|
||||
TypedArrayKind::Int16 => bytes[offset..offset + 2].copy_from_slice(&(n as i32 as u16 as i16).to_ne_bytes()),
|
||||
TypedArrayKind::Uint16 => bytes[offset..offset + 2].copy_from_slice(&(n as i32 as u16).to_ne_bytes()),
|
||||
TypedArrayKind::Int32 => bytes[offset..offset + 4].copy_from_slice(&(n as i32).to_ne_bytes()),
|
||||
TypedArrayKind::Uint32 => bytes[offset..offset + 4].copy_from_slice(&(n as u32).to_ne_bytes()),
|
||||
TypedArrayKind::Float32 => bytes[offset..offset + 4].copy_from_slice(&(n as f32).to_ne_bytes()),
|
||||
TypedArrayKind::Float64 => bytes[offset..offset + 8].copy_from_slice(&n.to_ne_bytes()),
|
||||
TypedArrayKind::BigInt64 | TypedArrayKind::BigUint64 => {
|
||||
// 取低 64 位位模式：与 2^64-1 掩码后恒非负且可转 u64，BigInt64 按位
|
||||
// 模式重解释为 i64（二进制补码）。
|
||||
let v = vm.bigint_value(value);
|
||||
let low = (v & (BigInt::from(u64::MAX)))
|
||||
.to_u64()
|
||||
.expect("与 u64::MAX 掩码后恒在 u64 范围");
|
||||
let bytes64 = if matches!(kind, TypedArrayKind::BigInt64) {
|
||||
(low as i64).to_ne_bytes()
|
||||
} else {
|
||||
low.to_ne_bytes()
|
||||
};
|
||||
bytes[offset..offset + 8].copy_from_slice(&bytes64);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -335,7 +411,7 @@ fn collect_array_like<H: VmHost>(vm: &mut H, value: JsValue) -> Result<Vec<JsVal
|
||||
let buffer_ptr = array_buffer_data_ptr(vm, view.buffer)?;
|
||||
let buffer = unsafe { &*buffer_ptr };
|
||||
return Ok((0..view.length)
|
||||
.map(|i| read_element(view.kind, buffer, absolute_byte_offset(view, i)))
|
||||
.map(|i| read_element(vm, view.kind, buffer, absolute_byte_offset(view, i)))
|
||||
.collect());
|
||||
}
|
||||
|
||||
@@ -380,17 +456,7 @@ fn typed_array_new<H: VmHost>(vm: &mut H, args: &[u8], kind: TypedArrayKind) ->
|
||||
let first = if args.len() > 1 { vm.reg(args[1]) } else { JsValue::int(0) };
|
||||
let bpe = kind.bytes_per_element();
|
||||
|
||||
let (buffer, byte_offset, length) = if first.is_int() || first.is_double() || first.is_undefined() {
|
||||
let len = native_try!(to_index(vm, first, "invalid TypedArray length"));
|
||||
let Some(byte_len) = len.checked_mul(bpe) else {
|
||||
return NativeResult::Err(range_error(vm, "invalid TypedArray length"));
|
||||
};
|
||||
if byte_len > MAX_ARRAY_BUFFER_LENGTH {
|
||||
return NativeResult::Err(range_error(vm, "invalid TypedArray length"));
|
||||
}
|
||||
let buffer = JsValue::from_js_object(new_array_buffer(vm, vec![0; byte_len]));
|
||||
(buffer, 0, len)
|
||||
} else if first.is_object() {
|
||||
let (buffer, byte_offset, length) = if first.is_object() {
|
||||
let first_ptr = first.as_js_object_ptr();
|
||||
let first_obj = unsafe { &*first_ptr };
|
||||
if first_obj.is_array_buffer_obj() {
|
||||
@@ -424,13 +490,26 @@ fn typed_array_new<H: VmHost>(vm: &mut H, args: &[u8], kind: TypedArrayKind) ->
|
||||
let buffer_ptr = native_try!(array_buffer_data_ptr(vm, buffer));
|
||||
let buffer_ref = unsafe { &mut *buffer_ptr };
|
||||
for (idx, value) in values.into_iter().enumerate() {
|
||||
let n = numeric_value(vm, value);
|
||||
write_element(kind, buffer_ref, idx * bpe, n);
|
||||
let elem = native_try!(ta_element_value(vm, kind, value));
|
||||
write_element(vm, kind, buffer_ref, idx * bpe, elem);
|
||||
}
|
||||
(buffer, 0, byte_len / bpe)
|
||||
}
|
||||
} else {
|
||||
return NativeResult::Err(type_error(vm, "invalid TypedArray constructor argument"));
|
||||
// 非对象第一参数统一按 ToIndex 语义处理（bool→0/1、null→0、BigInt→数值、
|
||||
// 字符串→解析、undefined→0）；Symbol 按规范抛 TypeError。
|
||||
if first.is_symbol() {
|
||||
return NativeResult::Err(type_error(vm, "invalid TypedArray length"));
|
||||
}
|
||||
let len = native_try!(to_index(vm, first, "invalid TypedArray length"));
|
||||
let Some(byte_len) = len.checked_mul(bpe) else {
|
||||
return NativeResult::Err(range_error(vm, "invalid TypedArray length"));
|
||||
};
|
||||
if byte_len > MAX_ARRAY_BUFFER_LENGTH {
|
||||
return NativeResult::Err(range_error(vm, "invalid TypedArray length"));
|
||||
}
|
||||
let buffer = JsValue::from_js_object(new_array_buffer(vm, vec![0; byte_len]));
|
||||
(buffer, 0, len)
|
||||
};
|
||||
|
||||
NativeResult::Ok(JsValue::from_js_object(create_typed_array(vm, kind, buffer, byte_offset, length)))
|
||||
@@ -473,7 +552,7 @@ pub fn typed_array_at<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
|
||||
}
|
||||
let buffer_ptr = native_try!(array_buffer_data_ptr(vm, view.buffer));
|
||||
let buffer = unsafe { &*buffer_ptr };
|
||||
NativeResult::Ok(read_element(view.kind, buffer, absolute_byte_offset(view, idx as usize)))
|
||||
NativeResult::Ok(read_element(vm, view.kind, buffer, absolute_byte_offset(view, idx as usize)))
|
||||
}
|
||||
|
||||
/// `TypedArray.prototype.fill(value, start, end)`：用给定值填充区间，返回 this。
|
||||
@@ -481,7 +560,8 @@ pub fn typed_array_fill<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
|
||||
let this_val = vm.reg(if args.is_empty() { 0 } else { args[0] });
|
||||
let view = native_try!(get_typed_array_data(vm, this_val));
|
||||
let value = if args.len() > 1 { vm.reg(args[1]) } else { JsValue::undefined() };
|
||||
let n = native_try!(ta_to_number(vm, value));
|
||||
// 值只转换一次（valueOf 副作用一次），转换结果写入每个目标元素。
|
||||
let elem = native_try!(ta_element_value(vm, view.kind, value));
|
||||
let start = if args.len() > 2 {
|
||||
native_try!(normalize_index(vm, vm.reg(args[2]), view.length))
|
||||
} else {
|
||||
@@ -495,7 +575,7 @@ pub fn typed_array_fill<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
|
||||
let buffer_ptr = native_try!(array_buffer_data_ptr(vm, view.buffer));
|
||||
let buffer = unsafe { &mut *buffer_ptr };
|
||||
for idx in start..end.max(start) {
|
||||
write_element(view.kind, buffer, absolute_byte_offset(view, idx), n);
|
||||
write_element(vm, view.kind, buffer, absolute_byte_offset(view, idx), elem);
|
||||
}
|
||||
NativeResult::Ok(this_val)
|
||||
}
|
||||
@@ -569,11 +649,14 @@ pub fn typed_array_set<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
|
||||
if offset > view.length || values.len() > view.length - offset {
|
||||
return NativeResult::Err(range_error(vm, "TypedArray.set offset out of bounds"));
|
||||
}
|
||||
let numbers: Vec<f64> = values.into_iter().map(|v| numeric_value(vm, v)).collect();
|
||||
let mut converted = Vec::with_capacity(values.len());
|
||||
for v in values {
|
||||
converted.push(native_try!(ta_element_value(vm, view.kind, v)));
|
||||
}
|
||||
let buffer_ptr = native_try!(array_buffer_data_ptr(vm, view.buffer));
|
||||
let buffer = unsafe { &mut *buffer_ptr };
|
||||
for (i, n) in numbers.into_iter().enumerate() {
|
||||
write_element(view.kind, buffer, absolute_byte_offset(view, offset + i), n);
|
||||
for (i, elem) in converted.into_iter().enumerate() {
|
||||
write_element(vm, view.kind, buffer, absolute_byte_offset(view, offset + i), elem);
|
||||
}
|
||||
NativeResult::Ok(JsValue::undefined())
|
||||
}
|
||||
@@ -648,12 +731,18 @@ fn allocate_typed_array<H: VmHost>(vm: &mut H, c: JsValue, len: usize) -> Result
|
||||
Ok(result)
|
||||
}
|
||||
|
||||
/// 按 IntegerIndexedElementSet 语义把元素写入 TypedArray：先 ToNumber（symbol 等
|
||||
/// 不可转换值抛 TypeError），越界索引静默忽略。
|
||||
/// 按 IntegerIndexedElementSet 语义把元素写入 TypedArray：先按元素类型转换
|
||||
/// （BigInt 类型走 ToBigInt、数值类型走 ToNumber，symbol 等不可转换值抛 TypeError）。
|
||||
fn set_typed_array_element<H: VmHost>(vm: &mut H, ta: JsValue, index: usize, value: JsValue) -> Result<(), JsValue> {
|
||||
let n = oxide_runtime_api::to_number_full(value, vm).map_err(|e| crate::iterator::engine_error(vm, &e))?;
|
||||
let obj = unsafe { &*ta.as_js_object_ptr() };
|
||||
typed_array_element_set(vm, obj, index as u32, JsValue::float(n)).map_err(|e| crate::iterator::engine_error(vm, &e))
|
||||
let view = get_typed_array_data(vm, ta)?;
|
||||
if index >= view.length {
|
||||
return Ok(());
|
||||
}
|
||||
let elem = ta_element_value(vm, view.kind, value)?;
|
||||
let buffer_ptr = array_buffer_data_ptr(vm, view.buffer)?;
|
||||
let buffer = unsafe { &mut *buffer_ptr };
|
||||
write_element(vm, view.kind, buffer, absolute_byte_offset(view, index), elem);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// `%TypedArray%.of(...items)`：以实参为元素构造一个以 `this`（构造器 C）为类型的
|
||||
@@ -682,28 +771,29 @@ fn ta_read<H: VmHost>(vm: &mut H, view: TypedArrayData, index: usize) -> Result<
|
||||
}
|
||||
let buffer_ptr = array_buffer_data_ptr(vm, view.buffer)?;
|
||||
let buffer = unsafe { &*buffer_ptr };
|
||||
Ok(read_element(view.kind, buffer, absolute_byte_offset(view, index)))
|
||||
Ok(read_element(vm, view.kind, buffer, absolute_byte_offset(view, index)))
|
||||
}
|
||||
|
||||
/// 把数值写入 TypedArray 指定索引（视图 data 已取出的形式，供原型方法内部使用）。
|
||||
fn ta_write<H: VmHost>(vm: &mut H, view: TypedArrayData, index: usize, value: f64) -> Result<(), JsValue> {
|
||||
/// 把已转换的值写入 TypedArray 指定索引（视图 data 已取出的形式，供原型方法内部使用）。
|
||||
fn ta_write<H: VmHost>(vm: &mut H, view: TypedArrayData, index: usize, value: JsValue) -> Result<(), JsValue> {
|
||||
let buffer_ptr = array_buffer_data_ptr(vm, view.buffer)?;
|
||||
let buffer = unsafe { &mut *buffer_ptr };
|
||||
write_element(view.kind, buffer, absolute_byte_offset(view, index), value);
|
||||
write_element(vm, view.kind, buffer, absolute_byte_offset(view, index), value);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// 把一组数值写成同类型的新 TypedArray（map/filter/toReversed/toSorted/with 共用）。
|
||||
fn create_ta_from_numbers<H: VmHost>(
|
||||
vm: &mut H, kind: TypedArrayKind, numbers: Vec<f64>,
|
||||
/// 把一组已按元素类型转换的值写成同类型的新 TypedArray
|
||||
/// （map/filter/toReversed/toSorted/with 共用）。
|
||||
fn create_ta_from_values<H: VmHost>(
|
||||
vm: &mut H, kind: TypedArrayKind, values: Vec<JsValue>,
|
||||
) -> Result<*mut JsObject, JsValue> {
|
||||
let bpe = kind.bytes_per_element();
|
||||
let len = numbers.len();
|
||||
let len = values.len();
|
||||
let buffer = JsValue::from_js_object(new_array_buffer(vm, vec![0; len * bpe]));
|
||||
let buffer_ptr = array_buffer_data_ptr(vm, buffer)?;
|
||||
let buffer_ref = unsafe { &mut *buffer_ptr };
|
||||
for (idx, n) in numbers.into_iter().enumerate() {
|
||||
write_element(kind, buffer_ref, idx * bpe, n);
|
||||
for (idx, v) in values.into_iter().enumerate() {
|
||||
write_element(vm, kind, buffer_ref, idx * bpe, v);
|
||||
}
|
||||
Ok(create_typed_array(vm, kind, buffer, 0, len))
|
||||
}
|
||||
@@ -717,7 +807,8 @@ fn invoke_cb<H: VmHost>(vm: &mut H, cb: JsValue, this_arg: JsValue, cb_args: &[J
|
||||
}
|
||||
}
|
||||
|
||||
/// ToNumber 并恢复引擎错误为原始异常值。
|
||||
/// ToNumber 并恢复引擎错误为原始异常值（索引类参数转换用；元素转换走
|
||||
/// [`ta_element_value`] 按类型分流）。
|
||||
fn ta_to_number<H: VmHost>(vm: &mut H, value: JsValue) -> Result<f64, JsValue> {
|
||||
oxide_runtime_api::to_number_full(value, vm).map_err(|e| crate::iterator::engine_error(vm, &e))
|
||||
}
|
||||
@@ -739,7 +830,7 @@ pub fn typed_array_for_each<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult
|
||||
}
|
||||
|
||||
/// `%TypedArray%.prototype.map(callback, thisArg)`：对每个元素调用 callback，
|
||||
/// 结果 ToNumber 后写入同类型的新 TypedArray。
|
||||
/// 结果按元素类型转换后写入同类型的新 TypedArray。
|
||||
pub fn typed_array_map<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
|
||||
let this_val = vm.reg(if args.is_empty() { 0 } else { args[0] });
|
||||
let view = native_try!(get_typed_array_data(vm, this_val));
|
||||
@@ -748,13 +839,13 @@ pub fn typed_array_map<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
|
||||
}
|
||||
let callback = native_try!(crate::array::require_callback(vm, vm.reg(args[1])));
|
||||
let this_arg = if args.len() > 2 { vm.reg(args[2]) } else { JsValue::undefined() };
|
||||
let mut numbers = Vec::with_capacity(view.length);
|
||||
let mut values = Vec::with_capacity(view.length);
|
||||
for i in 0..view.length {
|
||||
let elem = native_try!(ta_read(vm, view, i));
|
||||
let mapped = native_try!(invoke_cb(vm, callback, this_arg, &[elem, JsValue::int(i as i32), this_val]));
|
||||
numbers.push(native_try!(ta_to_number(vm, mapped)));
|
||||
values.push(native_try!(ta_element_value(vm, view.kind, mapped)));
|
||||
}
|
||||
let new_obj = native_try!(create_ta_from_numbers(vm, view.kind, numbers));
|
||||
let new_obj = native_try!(create_ta_from_values(vm, view.kind, values));
|
||||
NativeResult::Ok(JsValue::from_js_object(new_obj))
|
||||
}
|
||||
|
||||
@@ -768,15 +859,15 @@ pub fn typed_array_filter<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
|
||||
}
|
||||
let callback = native_try!(crate::array::require_callback(vm, vm.reg(args[1])));
|
||||
let this_arg = if args.len() > 2 { vm.reg(args[2]) } else { JsValue::undefined() };
|
||||
let mut numbers = Vec::new();
|
||||
let mut values = Vec::new();
|
||||
for i in 0..view.length {
|
||||
let elem = native_try!(ta_read(vm, view, i));
|
||||
let result = native_try!(invoke_cb(vm, callback, this_arg, &[elem, JsValue::int(i as i32), this_val]));
|
||||
if oxide_runtime_api::to_boolean(result) {
|
||||
numbers.push(native_try!(ta_to_number(vm, elem)));
|
||||
values.push(elem);
|
||||
}
|
||||
}
|
||||
let new_obj = native_try!(create_ta_from_numbers(vm, view.kind, numbers));
|
||||
let new_obj = native_try!(create_ta_from_values(vm, view.kind, values));
|
||||
NativeResult::Ok(JsValue::from_js_object(new_obj))
|
||||
}
|
||||
|
||||
@@ -1122,7 +1213,9 @@ fn default_ta_order(a: f64, b: f64) -> std::cmp::Ordering {
|
||||
}
|
||||
}
|
||||
|
||||
/// `%TypedArray%.prototype.sort(comparefn)`：原地排序，默认按数值升序（NaN 排末尾）。
|
||||
/// `%TypedArray%.prototype.sort(comparefn)`：原地排序，默认按数值升序（NaN 排末尾；
|
||||
/// BigInt 类型按 BigInt 值升序）。比较器回调收到的是元素原值（BigInt 类型为
|
||||
/// BigInt，数值类型为 Number）。
|
||||
pub fn typed_array_sort<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
|
||||
let this_val = vm.reg(if args.is_empty() { 0 } else { args[0] });
|
||||
let view = native_try!(get_typed_array_data(vm, this_val));
|
||||
@@ -1136,10 +1229,9 @@ pub fn typed_array_sort<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
|
||||
} else {
|
||||
None
|
||||
};
|
||||
let mut vals: Vec<f64> = Vec::with_capacity(view.length);
|
||||
let mut vals: Vec<JsValue> = Vec::with_capacity(view.length);
|
||||
for i in 0..view.length {
|
||||
let elem = native_try!(ta_read(vm, view, i));
|
||||
vals.push(native_try!(ta_to_number(vm, elem)));
|
||||
vals.push(native_try!(ta_read(vm, view, i)));
|
||||
}
|
||||
let mut sort_error = None;
|
||||
vals.sort_by(|a, b| {
|
||||
@@ -1147,12 +1239,7 @@ pub fn typed_array_sort<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
|
||||
return std::cmp::Ordering::Equal;
|
||||
}
|
||||
if let Some(cb) = comparator {
|
||||
match crate::array::invoke_native_callback(
|
||||
vm,
|
||||
cb,
|
||||
JsValue::undefined(),
|
||||
&[JsValue::float(*a), JsValue::float(*b)],
|
||||
) {
|
||||
match crate::array::invoke_native_callback(vm, cb, JsValue::undefined(), &[*a, *b]) {
|
||||
NativeResult::Ok(r) => {
|
||||
let n = oxide_runtime_api::to_number(r);
|
||||
if n.is_nan() || n == 0.0 {
|
||||
@@ -1173,15 +1260,25 @@ pub fn typed_array_sort<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
|
||||
std::cmp::Ordering::Equal
|
||||
}
|
||||
}
|
||||
} else if view.kind == TypedArrayKind::BigInt64 {
|
||||
// BigInt64 元素恒在 i64 范围（写入按 mod 2^64 截断为有符号位模式），按有符号序比较。
|
||||
let a_int = vm.bigint_value(*a).to_i64().unwrap_or(0);
|
||||
let b_int = vm.bigint_value(*b).to_i64().unwrap_or(0);
|
||||
a_int.cmp(&b_int)
|
||||
} else if is_bigint_kind(view.kind) {
|
||||
// BigUint64 元素恒在 u64 范围，按数值序比较。
|
||||
let a_uint = vm.bigint_value(*a).to_u64().unwrap_or(0);
|
||||
let b_uint = vm.bigint_value(*b).to_u64().unwrap_or(0);
|
||||
a_uint.cmp(&b_uint)
|
||||
} else {
|
||||
default_ta_order(*a, *b)
|
||||
default_ta_order(oxide_runtime_api::to_number(*a), oxide_runtime_api::to_number(*b))
|
||||
}
|
||||
});
|
||||
if let Some(err) = sort_error {
|
||||
return NativeResult::Err(err);
|
||||
}
|
||||
for (i, n) in vals.into_iter().enumerate() {
|
||||
native_try!(ta_write(vm, view, i, n));
|
||||
for (i, v) in vals.into_iter().enumerate() {
|
||||
native_try!(ta_write(vm, view, i, v));
|
||||
}
|
||||
NativeResult::Ok(this_val)
|
||||
}
|
||||
@@ -1194,11 +1291,9 @@ pub fn typed_array_reverse<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
|
||||
let mut j = view.length.saturating_sub(1);
|
||||
while i < j {
|
||||
let tmp = native_try!(ta_read(vm, view, i));
|
||||
let n = native_try!(ta_to_number(vm, tmp));
|
||||
let jtmp = native_try!(ta_read(vm, view, j));
|
||||
let jv = native_try!(ta_to_number(vm, jtmp));
|
||||
native_try!(ta_write(vm, view, j, n));
|
||||
native_try!(ta_write(vm, view, i, jv));
|
||||
native_try!(ta_write(vm, view, j, tmp));
|
||||
native_try!(ta_write(vm, view, i, jtmp));
|
||||
i += 1;
|
||||
j = j.saturating_sub(1);
|
||||
}
|
||||
@@ -1234,8 +1329,7 @@ pub fn typed_array_copy_within<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResu
|
||||
};
|
||||
for _ in 0..count {
|
||||
let elem = native_try!(ta_read(vm, view, from));
|
||||
let v = native_try!(ta_to_number(vm, elem));
|
||||
native_try!(ta_write(vm, view, to, v));
|
||||
native_try!(ta_write(vm, view, to, elem));
|
||||
from = (from as isize + direction) as usize;
|
||||
to = (to as isize + direction) as usize;
|
||||
}
|
||||
@@ -1284,12 +1378,11 @@ pub fn typed_array_to_locale_string<H: VmHost>(vm: &mut H, args: &[u8]) -> Nativ
|
||||
pub fn typed_array_to_reversed<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
|
||||
let this_val = vm.reg(if args.is_empty() { 0 } else { args[0] });
|
||||
let view = native_try!(get_typed_array_data(vm, this_val));
|
||||
let mut numbers = Vec::with_capacity(view.length);
|
||||
let mut values = Vec::with_capacity(view.length);
|
||||
for i in (0..view.length).rev() {
|
||||
let elem = native_try!(ta_read(vm, view, i));
|
||||
numbers.push(native_try!(ta_to_number(vm, elem)));
|
||||
values.push(native_try!(ta_read(vm, view, i)));
|
||||
}
|
||||
let new_obj = native_try!(create_ta_from_numbers(vm, view.kind, numbers));
|
||||
let new_obj = native_try!(create_ta_from_values(vm, view.kind, values));
|
||||
NativeResult::Ok(JsValue::from_js_object(new_obj))
|
||||
}
|
||||
|
||||
@@ -1308,10 +1401,9 @@ pub fn typed_array_to_sorted<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult
|
||||
} else {
|
||||
None
|
||||
};
|
||||
let mut vals: Vec<f64> = Vec::with_capacity(view.length);
|
||||
let mut vals: Vec<JsValue> = Vec::with_capacity(view.length);
|
||||
for i in 0..view.length {
|
||||
let elem = native_try!(ta_read(vm, view, i));
|
||||
vals.push(native_try!(ta_to_number(vm, elem)));
|
||||
vals.push(native_try!(ta_read(vm, view, i)));
|
||||
}
|
||||
let mut sort_error = None;
|
||||
vals.sort_by(|a, b| {
|
||||
@@ -1319,12 +1411,7 @@ pub fn typed_array_to_sorted<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult
|
||||
return std::cmp::Ordering::Equal;
|
||||
}
|
||||
if let Some(cb) = comparator {
|
||||
match crate::array::invoke_native_callback(
|
||||
vm,
|
||||
cb,
|
||||
JsValue::undefined(),
|
||||
&[JsValue::float(*a), JsValue::float(*b)],
|
||||
) {
|
||||
match crate::array::invoke_native_callback(vm, cb, JsValue::undefined(), &[*a, *b]) {
|
||||
NativeResult::Ok(r) => {
|
||||
let n = oxide_runtime_api::to_number(r);
|
||||
if n.is_nan() || n == 0.0 {
|
||||
@@ -1345,14 +1432,22 @@ pub fn typed_array_to_sorted<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult
|
||||
std::cmp::Ordering::Equal
|
||||
}
|
||||
}
|
||||
} else if view.kind == TypedArrayKind::BigInt64 {
|
||||
let a_int = vm.bigint_value(*a).to_i64().unwrap_or(0);
|
||||
let b_int = vm.bigint_value(*b).to_i64().unwrap_or(0);
|
||||
a_int.cmp(&b_int)
|
||||
} else if is_bigint_kind(view.kind) {
|
||||
let a_uint = vm.bigint_value(*a).to_u64().unwrap_or(0);
|
||||
let b_uint = vm.bigint_value(*b).to_u64().unwrap_or(0);
|
||||
a_uint.cmp(&b_uint)
|
||||
} else {
|
||||
default_ta_order(*a, *b)
|
||||
default_ta_order(oxide_runtime_api::to_number(*a), oxide_runtime_api::to_number(*b))
|
||||
}
|
||||
});
|
||||
if let Some(err) = sort_error {
|
||||
return NativeResult::Err(err);
|
||||
}
|
||||
let new_obj = native_try!(create_ta_from_numbers(vm, view.kind, vals));
|
||||
let new_obj = native_try!(create_ta_from_values(vm, view.kind, vals));
|
||||
NativeResult::Ok(JsValue::from_js_object(new_obj))
|
||||
}
|
||||
|
||||
@@ -1378,29 +1473,28 @@ pub fn typed_array_with<H: VmHost>(vm: &mut H, args: &[u8]) -> NativeResult {
|
||||
} else {
|
||||
view.length as f64 + relative_index
|
||||
};
|
||||
// 先 ToNumber(value)（可触发副作用/抛错），再做索引范围校验。
|
||||
// 先按元素类型转换 value（可触发副作用/抛错），再做索引范围校验。
|
||||
let value = if args.len() > 2 { vm.reg(args[2]) } else { JsValue::undefined() };
|
||||
let replacement = native_try!(ta_to_number(vm, value));
|
||||
let replacement = native_try!(ta_element_value(vm, view.kind, value));
|
||||
if actual_index.is_nan() || actual_index < 0.0 || actual_index >= view.length as f64 {
|
||||
return NativeResult::Err(range_error(vm, "Invalid typed array index"));
|
||||
}
|
||||
let index = actual_index as usize;
|
||||
let mut numbers = Vec::with_capacity(view.length);
|
||||
let mut values = Vec::with_capacity(view.length);
|
||||
for i in 0..view.length {
|
||||
if i == index {
|
||||
numbers.push(replacement);
|
||||
values.push(replacement);
|
||||
continue;
|
||||
}
|
||||
let elem = native_try!(ta_read(vm, view, i));
|
||||
numbers.push(native_try!(ta_to_number(vm, elem)));
|
||||
values.push(native_try!(ta_read(vm, view, i)));
|
||||
}
|
||||
let new_obj = native_try!(create_ta_from_numbers(vm, view.kind, numbers));
|
||||
let new_obj = native_try!(create_ta_from_values(vm, view.kind, values));
|
||||
NativeResult::Ok(JsValue::from_js_object(new_obj))
|
||||
}
|
||||
|
||||
/// `%TypedArray%.from(source, mapfn?, thisArg?)`：从可迭代对象或 array-like 构造
|
||||
/// 以 `this`（构造器 C）为类型的 TypedArray；`mapfn` 逐元素映射（`thisArg` 作回调
|
||||
/// this），元素经 ToNumber 写入。
|
||||
/// this），元素按结果类型转换（BigInt 类型走 ToBigInt、数值类型走 ToNumber）写入。
|
||||
///
|
||||
/// # 步骤
|
||||
/// 1. `source` 为 null/undefined 抛 TypeError；`mapfn` 非 undefined 时须可调用。
|
||||
|
||||
@@ -890,6 +890,77 @@ pub fn to_string_full<H: VmHost>(val: JsValue, host: &mut H) -> Result<String, S
|
||||
Ok(to_string(primitive))
|
||||
}
|
||||
|
||||
/// 带完整对象强制转换的 ToBigInt(input)（§7.1.14）：BigInt 原样；Boolean → 0/1；
|
||||
/// String 走 StringToBigInt；Number/Symbol/undefined/null → TypeError；对象经
|
||||
/// ToPrimitive（default hint）后递归处理。
|
||||
pub fn to_bigint_full<H: VmHost>(val: JsValue, host: &mut H) -> Result<JsValue, String> {
|
||||
let primitive = to_primitive(val, ToPrimitiveHint::Default, host)?;
|
||||
if primitive.is_bigint() {
|
||||
return Ok(primitive);
|
||||
}
|
||||
if primitive.is_bool() {
|
||||
let v = if primitive.as_bool() { 1 } else { 0 };
|
||||
return Ok(host.new_bigint(num_bigint::BigInt::from(v)));
|
||||
}
|
||||
if primitive.is_int() || primitive.is_double() {
|
||||
return Err(host.error_message_text("TypeError", "Cannot convert a Number value to a BigInt"));
|
||||
}
|
||||
if primitive.is_string() {
|
||||
return string_to_bigint_full(host, &to_string(primitive));
|
||||
}
|
||||
// undefined / null / symbol。
|
||||
Err(host.error_message_text("TypeError", "Cannot convert value to a BigInt"))
|
||||
}
|
||||
|
||||
/// StringToBigInt（§7.1.14 步骤）：去首尾空白，可选 +/- 号与 0x/0o/0b 前缀；
|
||||
/// 空串 → 0n；非法 → SyntaxError。
|
||||
fn string_to_bigint_full<H: VmHost>(host: &mut H, s: &str) -> Result<JsValue, String> {
|
||||
let trimmed = s.trim();
|
||||
if trimmed.is_empty() {
|
||||
return Ok(host.new_bigint(num_bigint::BigInt::from(0)));
|
||||
}
|
||||
let (neg, rest) = if let Some(r) = trimmed.strip_prefix('-') {
|
||||
(true, r)
|
||||
} else if let Some(r) = trimmed.strip_prefix('+') {
|
||||
(false, r)
|
||||
} else {
|
||||
(false, trimmed)
|
||||
};
|
||||
// StringIntegerLiteral：符号只允许出现在纯十进制前；0x/0o/0b 前缀前带
|
||||
// +/-（如 "-0x1"）属于非法语法。
|
||||
let (radix, digits) = if let Some(hex) = rest.strip_prefix("0x").or_else(|| rest.strip_prefix("0X")) {
|
||||
if neg {
|
||||
return Err(
|
||||
host.error_message_text("SyntaxError", "Cannot convert string to BigInt: invalid integer literal")
|
||||
);
|
||||
}
|
||||
(16u32, hex)
|
||||
} else if let Some(oct) = rest.strip_prefix("0o").or_else(|| rest.strip_prefix("0O")) {
|
||||
if neg {
|
||||
return Err(
|
||||
host.error_message_text("SyntaxError", "Cannot convert string to BigInt: invalid integer literal")
|
||||
);
|
||||
}
|
||||
(8u32, oct)
|
||||
} else if let Some(bin) = rest.strip_prefix("0b").or_else(|| rest.strip_prefix("0B")) {
|
||||
if neg {
|
||||
return Err(
|
||||
host.error_message_text("SyntaxError", "Cannot convert string to BigInt: invalid integer literal")
|
||||
);
|
||||
}
|
||||
(2u32, bin)
|
||||
} else {
|
||||
(10u32, rest)
|
||||
};
|
||||
if digits.is_empty() {
|
||||
return Err(host.error_message_text("SyntaxError", "Cannot convert string to BigInt: invalid integer literal"));
|
||||
}
|
||||
let m = num_bigint::BigInt::parse_bytes(digits.as_bytes(), radix).ok_or_else(|| {
|
||||
host.error_message_text("SyntaxError", "Cannot convert string to BigInt: invalid integer literal")
|
||||
})?;
|
||||
Ok(host.new_bigint(if neg { -m } else { m }))
|
||||
}
|
||||
|
||||
/// `String()` 构造器的字符串转换（§21.1.1.1）：Symbol 值（及本引擎以空对象表示的
|
||||
/// well-known symbol）返回描述串 `Symbol(desc)`；其余走完整 ToString。
|
||||
pub fn to_string_for_string_constructor<H: VmHost>(val: JsValue, host: &mut H) -> Result<String, String> {
|
||||
|
||||
@@ -128,3 +128,74 @@ fn data_view_to_string_is_identifiable() {
|
||||
let result = eval(&mut vm, "var dv = new DataView(new ArrayBuffer(1)); dv.toString()").unwrap();
|
||||
assert_eq!(to_str(&vm, result), "[object DataView]");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn data_view_get_big_int64_returns_bigint() {
|
||||
let mut vm = Vm::new();
|
||||
let result = eval(&mut vm, "new DataView(new ArrayBuffer(8)).getBigInt64(0)").unwrap();
|
||||
assert!(result.is_bigint());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn data_view_set_big_int64_with_number_throws() {
|
||||
let mut vm = Vm::new();
|
||||
// ToBigInt 语义：Number 入参抛 TypeError。
|
||||
let result = eval(
|
||||
&mut vm,
|
||||
"try { new DataView(new ArrayBuffer(8)).setBigInt64(0, 1); false } catch (e) { e instanceof TypeError }",
|
||||
)
|
||||
.unwrap();
|
||||
assert!(result.as_bool());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn data_view_big_int64_precision_roundtrip() {
|
||||
let mut vm = Vm::new();
|
||||
// 2^63-1（i64::MAX）超出 f64 精确范围，真 BigInt 语义读回必须原值。
|
||||
let result = eval(
|
||||
&mut vm,
|
||||
"var dv = new DataView(new ArrayBuffer(8)); \
|
||||
dv.setBigInt64(0, 9223372036854775807n); dv.getBigInt64(0) === 9223372036854775807n",
|
||||
)
|
||||
.unwrap();
|
||||
assert!(result.as_bool());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn data_view_big_uint64_precision_roundtrip() {
|
||||
let mut vm = Vm::new();
|
||||
let result = eval(
|
||||
&mut vm,
|
||||
"var dv = new DataView(new ArrayBuffer(8)); \
|
||||
dv.setBigUint64(0, 18446744073709551615n, true); dv.getBigUint64(0, true) === 18446744073709551615n",
|
||||
)
|
||||
.unwrap();
|
||||
assert!(result.as_bool());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn data_view_big_int64_little_endian_byte_order() {
|
||||
let mut vm = Vm::new();
|
||||
// 小端写入后首字节为低字节；同一字节序读回原值。
|
||||
let result = eval(
|
||||
&mut vm,
|
||||
"var dv = new DataView(new ArrayBuffer(8)); \
|
||||
dv.setBigInt64(0, 0x0102030405060708n, true); \
|
||||
dv.getUint8(0) === 8 && dv.getBigInt64(0, true) === 0x0102030405060708n",
|
||||
)
|
||||
.unwrap();
|
||||
assert!(result.as_bool());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn data_view_set_big_int64_mod_2_64_truncation() {
|
||||
let mut vm = Vm::new();
|
||||
// 超 64 位值按 mod 2^64 截断写入。
|
||||
let result = eval(
|
||||
&mut vm,
|
||||
"var dv = new DataView(new ArrayBuffer(8)); \
|
||||
dv.setBigInt64(0, 1180591620717411303429n); dv.getBigInt64(0) === 5n",
|
||||
)
|
||||
.unwrap();
|
||||
assert!(result.as_bool());
|
||||
}
|
||||
|
||||
@@ -122,10 +122,27 @@ fn typed_array_float64_roundtrips() {
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn typed_array_bigint_fallback_returns_float() {
|
||||
fn typed_array_bigint_roundtrips_bigint_values() {
|
||||
let mut vm = Vm::new();
|
||||
let result = eval(&mut vm, "var ta = new BigInt64Array(1); ta.fill(42); ta.at(0)").unwrap();
|
||||
assert_eq!(result.as_double(), 42.0);
|
||||
// BigInt64Array 元素读写为真 BigInt 值（非 f64 近似）。
|
||||
let result = eval(&mut vm, "var ta = new BigInt64Array(1); ta.fill(42n); ta.at(0)").unwrap();
|
||||
assert!(result.is_bigint());
|
||||
assert_eq!(vm.bigint_value(result).to_string(), "42");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn typed_array_bigint_fill_with_number_throws() {
|
||||
let mut vm = Vm::new();
|
||||
// 数值 TA 写 BigInt 值按规范抛 TypeError；BigInt TA 写 Number 同样抛 TypeError。
|
||||
let result = eval(
|
||||
&mut vm,
|
||||
"var ok = true; \
|
||||
try { new BigInt64Array(1).fill(42); ok = false; } catch (e) { ok = e instanceof TypeError; } \
|
||||
try { new Int8Array(1)[0] = 1n; ok = ok && false; } catch (e) { ok = ok && e instanceof TypeError; } \
|
||||
ok",
|
||||
)
|
||||
.unwrap();
|
||||
assert!(result.as_bool());
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -190,3 +207,124 @@ fn typed_array_reflect_set_writes_to_receiver() {
|
||||
.unwrap();
|
||||
assert!(result.as_bool());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn typed_array_bigint64_precision_roundtrip() {
|
||||
let mut vm = Vm::new();
|
||||
// 2^63-1（i64::MAX）超出 f64 精确范围：f64 会舍入为 2^63，真 BigInt 存储读回必须原值。
|
||||
let result = eval(
|
||||
&mut vm,
|
||||
"var a = new BigInt64Array(1); a[0] = 9223372036854775807n; a[0] === 9223372036854775807n",
|
||||
)
|
||||
.unwrap();
|
||||
assert!(result.as_bool());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn typed_array_bigint64_write_overflow_wraps() {
|
||||
let mut vm = Vm::new();
|
||||
// 2^63 写入 i64 槽按二进制补码回读为 -2^63。
|
||||
let result = eval(
|
||||
&mut vm,
|
||||
"var a = new BigInt64Array(1); a[0] = 9223372036854775808n; a[0] === -9223372036854775808n",
|
||||
)
|
||||
.unwrap();
|
||||
assert!(result.as_bool());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn typed_array_biguint64_precision_roundtrip() {
|
||||
let mut vm = Vm::new();
|
||||
let result = eval(
|
||||
&mut vm,
|
||||
"var a = new BigUint64Array(1); a[0] = 18446744073709551615n; a[0] === 18446744073709551615n && a[0] > Number.MAX_SAFE_INTEGER",
|
||||
)
|
||||
.unwrap();
|
||||
assert!(result.as_bool());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn typed_array_bigint_negative_roundtrip() {
|
||||
let mut vm = Vm::new();
|
||||
let result = eval(&mut vm, "var a = new BigInt64Array(1); a[0] = -1n; a[0] === -1n").unwrap();
|
||||
assert!(result.as_bool());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn typed_array_bigint_mod_2_64_truncation() {
|
||||
let mut vm = Vm::new();
|
||||
// 写入按 mod 2^64 截断：2^70 + 5 的低 64 位为 5。
|
||||
let result = eval(&mut vm, "var a = new BigInt64Array(1); a[0] = 1180591620717411303429n; a[0] === 5n").unwrap();
|
||||
assert!(result.as_bool());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn typed_array_bigint_write_number_throws() {
|
||||
let mut vm = Vm::new();
|
||||
let result =
|
||||
eval(&mut vm, "try { new BigInt64Array(1)[0] = 1; false } catch (e) { e instanceof TypeError }").unwrap();
|
||||
assert!(result.as_bool());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn typed_array_numeric_write_bigint_throws() {
|
||||
let mut vm = Vm::new();
|
||||
let result = eval(&mut vm, "try { new Int8Array(1)[0] = 1n; false } catch (e) { e instanceof TypeError }").unwrap();
|
||||
assert!(result.as_bool());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn typed_array_constructor_bigint_length() {
|
||||
let mut vm = Vm::new();
|
||||
// G6：第一参数 BigInt 按 ToIndex 语义建数组。
|
||||
let result = eval(
|
||||
&mut vm,
|
||||
"new BigInt64Array(5n).length === 5 && new Int8Array(true).length === 1 && new Int8Array(null).length === 0",
|
||||
)
|
||||
.unwrap();
|
||||
assert!(result.as_bool());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn typed_array_bigint_from_array_and_set() {
|
||||
let mut vm = Vm::new();
|
||||
let result = eval(
|
||||
&mut vm,
|
||||
"var a = new BigInt64Array([1n, 2n]); \
|
||||
a.length === 2 && a[0] === 1n && a[1] === 2n && \
|
||||
BigInt64Array.from([3n]).at(0) === 3n && \
|
||||
(function () { var t = new BigInt64Array(2); t.set([9n, 8n]); return t[0] === 9n && t[1] === 8n; })()",
|
||||
)
|
||||
.unwrap();
|
||||
assert!(result.as_bool());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn typed_array_bigint_sort_uses_bigint_compare() {
|
||||
let mut vm = Vm::new();
|
||||
// 超出 f64 精度的 BigInt 排序仍按 BigInt 值升序（f64 中转会静默错序）。
|
||||
let result = eval(
|
||||
&mut vm,
|
||||
"var a = new BigInt64Array([9223372036854775807n, -1n, 0n, 1n]); a.sort(); \
|
||||
a[0] === -1n && a[1] === 0n && a[2] === 1n && a[3] === 9223372036854775807n",
|
||||
)
|
||||
.unwrap();
|
||||
assert!(result.as_bool());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn typed_array_bigint_methods_receive_bigint_values() {
|
||||
let mut vm = Vm::new();
|
||||
// map/filter/reduce 回调收到的元素是真 BigInt；map 结果按元素类型转换回写。
|
||||
let result = eval(
|
||||
&mut vm,
|
||||
"var a = new BigInt64Array([1n, 2n]); \
|
||||
var seen = []; \
|
||||
var m = a.map(function (v) { seen.push(typeof v); return v + 1n; }); \
|
||||
seen[0] === 'bigint' && seen[1] === 'bigint' && m[0] === 2n && m[1] === 3n && \
|
||||
a.filter(function (v) { return v > 1n; }).length === 1 && \
|
||||
a.reduce(function (acc, v) { return acc + v; }, 0n) === 3n",
|
||||
)
|
||||
.unwrap();
|
||||
assert!(result.as_bool());
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user