From d242d08e6d802149548da73a8156cf1d25829fce Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E7=88=B1=E7=89=B9=E6=AF=8F=E7=BE=8A=E9=98=9F?= Date: Sun, 14 Jun 2026 12:58:09 +0800 Subject: [PATCH] =?UTF-8?q?refactor:=20=E6=8B=86=E5=88=86=20Kernel=20?= =?UTF-8?q?=E4=B8=AD=E5=8F=AF=E5=8F=98=20Session=20=E4=B8=8E=E4=B8=8D?= =?UTF-8?q?=E5=8F=AF=E5=8F=98=20Core?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- crates/oxide_cli/src/main.rs | 16 +-- crates/oxide_kernel/src/kernel.rs | 121 +++++++++------- crates/oxide_kernel/src/lib.rs | 2 + crates/oxide_test262/src/main.rs | 28 ++-- crates/oxide_vm/src/bindings/bind_array.rs | 17 +-- crates/oxide_vm/src/bindings/bind_boolean.rs | 14 +- crates/oxide_vm/src/bindings/bind_date.rs | 18 +-- crates/oxide_vm/src/bindings/bind_error.rs | 57 ++++---- crates/oxide_vm/src/bindings/bind_function.rs | 14 +- crates/oxide_vm/src/bindings/bind_json.rs | 14 +- crates/oxide_vm/src/bindings/bind_map.rs | 14 +- crates/oxide_vm/src/bindings/bind_math.rs | 22 +-- crates/oxide_vm/src/bindings/bind_number.rs | 28 ++-- crates/oxide_vm/src/bindings/bind_object.rs | 15 +- crates/oxide_vm/src/bindings/bind_regexp.rs | 14 +- crates/oxide_vm/src/bindings/bind_set.rs | 14 +- crates/oxide_vm/src/bindings/bind_string.rs | 16 +-- crates/oxide_vm/src/bindings/bind_symbol.rs | 32 ++--- crates/oxide_vm/src/bindings/mod.rs | 60 ++++---- crates/oxide_vm/src/builtins/array.rs | 46 +++---- crates/oxide_vm/src/builtins/boolean.rs | 4 +- crates/oxide_vm/src/builtins/date.rs | 40 +++--- crates/oxide_vm/src/builtins/error.rs | 40 +++--- crates/oxide_vm/src/builtins/function.rs | 6 +- crates/oxide_vm/src/builtins/global.rs | 4 +- crates/oxide_vm/src/builtins/json.rs | 14 +- crates/oxide_vm/src/builtins/map.rs | 2 +- crates/oxide_vm/src/builtins/math.rs | 2 +- crates/oxide_vm/src/builtins/number.rs | 28 ++-- crates/oxide_vm/src/builtins/object.rs | 54 ++++---- crates/oxide_vm/src/builtins/regexp.rs | 40 +++--- crates/oxide_vm/src/builtins/set.rs | 2 +- crates/oxide_vm/src/builtins/string.rs | 40 +++--- crates/oxide_vm/src/builtins/symbol.rs | 10 +- crates/oxide_vm/src/coercion.rs | 6 +- crates/oxide_vm/src/dispatch/arithmetic.rs | 8 +- crates/oxide_vm/src/dispatch/bitwise.rs | 26 ++-- crates/oxide_vm/src/dispatch/call.rs | 4 +- crates/oxide_vm/src/dispatch/comparison.rs | 12 +- crates/oxide_vm/src/dispatch/control_flow.rs | 6 +- crates/oxide_vm/src/dispatch/member.rs | 20 +-- crates/oxide_vm/src/dispatch/property.rs | 20 +-- crates/oxide_vm/src/vm.rs | 129 +++++++++--------- crates/oxide_vm/src/vm_dispatch_misc.rs | 26 ++-- crates/oxide_vm/src/vm_pool.rs | 33 ++--- crates/oxide_vm/src/vm_props.rs | 20 +-- crates/oxide_vm/src/vm_runtime.rs | 16 +-- crates/oxide_vm/src/vm_support.rs | 59 +++++--- crates/oxide_vm/tests/arrow_tests.rs | 2 +- .../oxide_vm/tests/builtins_boolean_tests.rs | 4 +- crates/oxide_vm/tests/builtins_date_tests.rs | 2 +- .../oxide_vm/tests/builtins_function_tests.rs | 4 +- crates/oxide_vm/tests/builtins_map_tests.rs | 2 +- .../oxide_vm/tests/builtins_number_tests.rs | 6 +- .../oxide_vm/tests/builtins_object_tests.rs | 2 +- .../oxide_vm/tests/builtins_regexp_tests.rs | 2 +- .../oxide_vm/tests/builtins_string_tests.rs | 2 +- .../oxide_vm/tests/builtins_symbol_tests.rs | 2 +- crates/oxide_vm/tests/coercion_tests.rs | 6 +- crates/oxide_vm/tests/function_tests.rs | 2 +- crates/oxide_vm/tests/json_tests.rs | 2 +- crates/oxide_vm/tests/regression_tests.rs | 8 +- crates/oxide_vm/tests/template_tests.rs | 2 +- 63 files changed, 666 insertions(+), 615 deletions(-) diff --git a/crates/oxide_cli/src/main.rs b/crates/oxide_cli/src/main.rs index d3b03df..e836436 100644 --- a/crates/oxide_cli/src/main.rs +++ b/crates/oxide_cli/src/main.rs @@ -7,7 +7,7 @@ use std::sync::Arc; use ansi_term::Colour::Red; use clap::{Parser, Subcommand}; use oxide_compiler::compiler::Compiler; -use oxide_kernel::kernel::{KernelConfig, OxideKernel}; +use oxide_kernel::kernel::{KernelConfig, KernelCore}; use oxide_kernel::shape_forge::{ShapeForge, EMPTY_SHAPE_ID}; use oxide_kernel::string_forge::StringForge; use oxide_parser::Allocator; @@ -70,17 +70,15 @@ fn main() -> ExitCode { } } -fn make_kernel() -> Arc { - let kernel = Arc::new(OxideKernel::new(KernelConfig::standard())); - oxide_vm::vm::init_kernel_builtins(&kernel); - kernel +fn make_kernel() -> Arc { + KernelCore::new(KernelConfig::standard()) } -fn make_pool(kernel: &Arc) -> Arc { - VmPool::new(Arc::clone(kernel), kernel.config().min_pool_size, kernel.config().max_pool_size) +fn make_pool(kernel: &Arc) -> Arc { + VmPool::new(Arc::clone(kernel), kernel.config.min_pool_size, kernel.config.max_pool_size) } -fn eval(code: &str, kernel: &Arc, pool: &Arc) -> ExitCode { +fn eval(code: &str, kernel: &Arc, pool: &Arc) -> ExitCode { let allocator = Allocator::default(); let program = match oxide_parser::parse(&allocator, code) { Ok(p) => p, @@ -188,7 +186,7 @@ fn format_array(string_forge: &StringForge, shape_forge: &ShapeForge, obj: &JsOb format!("[{}]", items.join(", ")) } -fn run(file: &str, kernel: &Arc, pool: &Arc) -> ExitCode { +fn run(file: &str, kernel: &Arc, pool: &Arc) -> ExitCode { match fs::read_to_string(file) { Ok(source) => eval(&source, kernel, pool), Err(err) => { diff --git a/crates/oxide_kernel/src/kernel.rs b/crates/oxide_kernel/src/kernel.rs index 0676e1d..db0b9d4 100644 --- a/crates/oxide_kernel/src/kernel.rs +++ b/crates/oxide_kernel/src/kernel.rs @@ -13,6 +13,7 @@ use crate::prop_forge::PropForge; use crate::shape_forge::{ShapeForge, EMPTY_SHAPE_ID}; use crate::string_forge::StringForge; +#[derive(Clone)] pub struct KernelConfig { pub min_pool_size: usize, pub max_pool_size: Option, @@ -75,55 +76,24 @@ impl Default for KernelConfig { } } -pub struct OxideKernel { +/// Immutable, permanently shared state across all VM instances. +/// Never rebuilt after construction — forge tables are append-only. +pub struct KernelCore { pub config: KernelConfig, pub string_forge: Arc, pub shape_forge: Arc, pub code_forge: Arc, pub prop_forge: Arc, - pub builtin_world: Arc, - pub global_object: P, } -impl OxideKernel { - pub fn new(config: KernelConfig) -> Self { +impl KernelCore { + pub fn new(config: KernelConfig) -> Arc { init_logging(&config.log_levels); - let string_forge = Arc::new(StringForge::new()); let shape_forge = Arc::new(ShapeForge::new()); - let builtin_world = Arc::new(BuiltinWorld::new(&string_forge, &shape_forge)); let code_forge = Arc::new(CodeForge::new()); let prop_forge = Arc::new(PropForge::new()); - - let mut global_obj = JsObject::new_empty(EMPTY_SHAPE_ID, JsValue::null()); - - let si_nan = string_forge.intern("NaN").0; - let si_undef = string_forge.intern("undefined").0; - let si_infinity = string_forge.intern("Infinity").0; - - let nan_shape = shape_forge.make_shape(EMPTY_SHAPE_ID, si_nan); - global_obj.set_shape_id(nan_shape); - global_obj.ensure_hash_props().push(JsValue::float(f64::NAN)); - - let undef_shape = shape_forge.make_shape(nan_shape, si_undef); - global_obj.set_shape_id(undef_shape); - global_obj.ensure_hash_props().push(JsValue::undefined()); - - let inf_shape = shape_forge.make_shape(undef_shape, si_infinity); - global_obj.set_shape_id(inf_shape); - global_obj.ensure_hash_props().push(JsValue::float(f64::INFINITY)); - - let global_object = P::new(global_obj); - - Self { - config, - string_forge, - shape_forge, - code_forge, - prop_forge, - builtin_world, - global_object, - } + Arc::new(Self { config, string_forge, shape_forge, code_forge, prop_forge }) } pub fn string_forge(&self) -> &Arc { @@ -142,19 +112,55 @@ impl OxideKernel { &self.prop_forge } - pub fn builtin_world(&self) -> &Arc { - &self.builtin_world - } - pub fn config(&self) -> &KernelConfig { &self.config } +} + +/// Per-session mutable state: builtin prototype objects and the global object. +/// Rebuilt on full_reset() to achieve complete isolation between JS executions. +pub struct KernelSession { + pub builtin_world: Arc, + pub global_object: P, +} + +impl KernelSession { + /// Build a fresh session from a KernelCore. All string/shape intern calls hit + /// cache on second and subsequent calls — net cost is < 0.5 ms. + pub fn new(core: &KernelCore) -> Self { + let builtin_world = Arc::new(BuiltinWorld::new(&core.string_forge, &core.shape_forge)); + + let mut global_obj = JsObject::new_empty(EMPTY_SHAPE_ID, JsValue::null()); + + let si_nan = core.string_forge.intern("NaN").0; + let si_undef = core.string_forge.intern("undefined").0; + let si_infinity = core.string_forge.intern("Infinity").0; + + let nan_shape = core.shape_forge.make_shape(EMPTY_SHAPE_ID, si_nan); + global_obj.set_shape_id(nan_shape); + global_obj.ensure_hash_props().push(JsValue::float(f64::NAN)); + + let undef_shape = core.shape_forge.make_shape(nan_shape, si_undef); + global_obj.set_shape_id(undef_shape); + global_obj.ensure_hash_props().push(JsValue::undefined()); + + let inf_shape = core.shape_forge.make_shape(undef_shape, si_infinity); + global_obj.set_shape_id(inf_shape); + global_obj.ensure_hash_props().push(JsValue::float(f64::INFINITY)); + + Self { builtin_world, global_object: P::new(global_obj) } + } + + pub fn builtin_world(&self) -> &Arc { + &self.builtin_world + } pub fn global_object(&self) -> &P { &self.global_object } } + #[cfg(test)] mod tests { use super::*; @@ -162,29 +168,31 @@ mod tests { #[test] fn test_kernel_new() { - let kernel = OxideKernel::new(KernelConfig::minimal()); - let (idx, _) = kernel.string_forge().intern("test"); - assert!(idx > 0); + let core = KernelCore::new(KernelConfig::minimal()); + let (i1, _) = core.string_forge().intern("test"); + let (i2, _) = core.string_forge().intern("test"); + assert_eq!(i1, i2); } #[test] fn test_kernel_builtins_accessible() { - let kernel = OxideKernel::new(KernelConfig::minimal()); - assert!(!kernel.builtin_world().object_proto.is_function()); - assert!(kernel.builtin_world().object_constructor.is_function()); + let core = KernelCore::new(KernelConfig::minimal()); + let session = KernelSession::new(&core); + assert!(!session.builtin_world().object_proto.is_function()); + assert!(session.builtin_world().object_constructor.is_function()); } #[test] fn test_kernel_shape_forge() { - let kernel = OxideKernel::new(KernelConfig::minimal()); - assert!(kernel.shape_forge().get_shape(EMPTY_SHAPE_ID).is_some()); + let core = KernelCore::new(KernelConfig::minimal()); + assert!(core.shape_forge().get_shape(EMPTY_SHAPE_ID).is_some()); } #[test] fn test_kernel_string_forge() { - let kernel = OxideKernel::new(KernelConfig::minimal()); - let (i1, _) = kernel.string_forge().intern("hello"); - let (i2, _) = kernel.string_forge().intern("hello"); + let core = KernelCore::new(KernelConfig::minimal()); + let (i1, _) = core.string_forge().intern("hello"); + let (i2, _) = core.string_forge().intern("hello"); assert_eq!(i1, i2); } @@ -200,4 +208,13 @@ mod tests { assert!(KernelConfig::full().warmup_builtin_ic); assert_eq!(KernelConfig::full().max_pool_size, None); } + + #[test] + fn test_session_rebuild_shares_forges() { + let core = KernelCore::new(KernelConfig::minimal()); + let (i1, _) = core.string_forge().intern("hello"); + let _s2 = KernelSession::new(&core); + let (i2, _) = core.string_forge().intern("hello"); + assert_eq!(i1, i2); + } } diff --git a/crates/oxide_kernel/src/lib.rs b/crates/oxide_kernel/src/lib.rs index c371689..835e6dd 100644 --- a/crates/oxide_kernel/src/lib.rs +++ b/crates/oxide_kernel/src/lib.rs @@ -7,3 +7,5 @@ pub mod logging; pub mod prop_forge; pub mod shape_forge; pub mod string_forge; + +pub use kernel::{KernelConfig, KernelCore, KernelSession}; diff --git a/crates/oxide_test262/src/main.rs b/crates/oxide_test262/src/main.rs index cbbab3c..7ce9328 100644 --- a/crates/oxide_test262/src/main.rs +++ b/crates/oxide_test262/src/main.rs @@ -1,8 +1,8 @@ #![allow(clippy::arc_with_non_send_sync)] use oxide_compiler::compiler::Compiler; -use oxide_kernel::kernel::{KernelConfig, OxideKernel}; -use oxide_vm::vm::{init_kernel_builtins, Vm}; +use oxide_kernel::kernel::{KernelConfig, KernelCore}; +use oxide_vm::vm::Vm; use serde::Deserialize; use std::collections::HashMap; use std::path::{Path, PathBuf}; @@ -385,7 +385,7 @@ fn is_skipped(meta: &TestMeta) -> Option { } fn run_test( - path: &Path, source: &str, meta: &TestMeta, kernel: &Arc, harness: &HarnessSources, + path: &Path, source: &str, meta: &TestMeta, kernel: &Arc, harness: &HarnessSources, harness_cache: &mut HarnessPrefixCache, no_skip: bool, ) -> TestResult { let start = std::time::Instant::now(); @@ -404,7 +404,7 @@ fn run_test( } fn run_test_inner( - path: &Path, source: &str, meta: &TestMeta, kernel: &Arc, harness: &HarnessSources, + path: &Path, source: &str, meta: &TestMeta, kernel: &Arc, harness: &HarnessSources, harness_cache: &mut HarnessPrefixCache, no_skip: bool, ) -> TestResult { let start = std::time::Instant::now(); @@ -463,7 +463,7 @@ fn run_test_inner( } }; - let mut vm = Vm::with_kernel(Arc::clone(kernel)); + let mut vm = Vm::with_kernel_core(Arc::clone(kernel)); match vm.run(&module) { Ok(result) => { @@ -526,7 +526,7 @@ fn discover_tests(test262_root: &Path) -> Vec { /// exactly one `TestResult`. Worker-owned state (`kernel`, `harness_sources`, /// `harness_cache`) never crosses a thread boundary. fn process_path( - path: &Path, filter: &Option, no_skip: bool, kernel: &Arc, harness_sources: &HarnessSources, + path: &Path, filter: &Option, no_skip: bool, kernel: &Arc, harness_sources: &HarnessSources, harness_cache: &mut HarnessPrefixCache, ) -> TestResult { let source = match std::fs::read_to_string(path) { @@ -574,11 +574,11 @@ fn process_path( } /// Build a runner kernel with a bounded step limit. Each parallel worker owns -/// its own kernel because `OxideKernel` is `!Send` (it holds `P` = -/// `Arc`, and `JsObject` stores raw `*mut u8` property pointers). -/// Nothing kernel-shaped can cross a thread boundary, so sharing is impossible; -/// per-worker construction is the only correct design. -fn build_runner_kernel() -> Arc { +/// its own kernel because `KernelCore` + session state is `!Send` (it holds +/// `P` = `Arc`, and `JsObject` stores raw `*mut u8` property +/// pointers). Nothing kernel-shaped can cross a thread boundary, so sharing is +/// impossible; per-worker construction is the only correct design. +fn build_runner_kernel() -> Arc { // Bound each test's execution so a single infinite-loop / unsupported-feature // loop fails (or skips) instead of stalling the run. The VM emits a // "VM step limit exceeded" error on overrun, which the runner classifies as a @@ -589,9 +589,7 @@ fn build_runner_kernel() -> Arc { // Keep test262 recursion tests from reaching Rust's native stack before the // VM converts deep JS calls into a catchable RangeError. kernel_config.max_call_depth = 256; - let kernel = Arc::new(OxideKernel::new(kernel_config)); - init_kernel_builtins(&kernel); - kernel + KernelCore::new(kernel_config) } fn categorize_fail(msg: &str) -> String { @@ -716,7 +714,7 @@ fn run_tests() -> bool { let total = paths.len(); - // Determine worker count. `OxideKernel`/`Vm` are `!Send`, so we cannot share + // Determine worker count. `KernelCore` + session state is `!Send` (it holds // one kernel via Arc across threads; instead each worker builds and owns its // own kernel + harness-source registry + prefix cache. Only `PathBuf` and // `TestResult` (both `Send`) cross thread boundaries. Workers pull test diff --git a/crates/oxide_vm/src/bindings/bind_array.rs b/crates/oxide_vm/src/bindings/bind_array.rs index 57c475c..dc605c4 100644 --- a/crates/oxide_vm/src/bindings/bind_array.rs +++ b/crates/oxide_vm/src/bindings/bind_array.rs @@ -1,11 +1,12 @@ use std::sync::Arc; -use crate::bind_constructor_hash; use oxide_kernel::builtin::ArrayMethods; -use oxide_kernel::kernel::OxideKernel; +use oxide_kernel::kernel::{KernelCore, KernelSession}; use oxide_types::object::JsObject; -pub fn bind_array(kernel: &Arc, global: &mut JsObject) { +use crate::bind_constructor_hash; + +pub fn bind_array(core: &Arc, session: &KernelSession, global: &mut JsObject) { let _array_methods = ArrayMethods { is_array: crate::builtins::array::array_is_array as *const (), push: crate::builtins::array::array_push as *const (), @@ -38,12 +39,12 @@ pub fn bind_array(kernel: &Arc, global: &mut JsObject) { sort: crate::builtins::array::array_sort as *const (), }; - kernel.builtin_world().bind_array_methods( + session.builtin_world().bind_array_methods( &_array_methods, - kernel.string_forge().as_ref(), - kernel.shape_forge().as_ref(), + core.string_forge().as_ref(), + core.shape_forge().as_ref(), ); - let ctor_ptr = kernel.builtin_world().array_constructor.as_ptr() as *mut JsObject; - bind_constructor_hash!(kernel, global, "Array", ctor_ptr, crate::builtins::array::array_constructor, 1); + let ctor_ptr = session.builtin_world().array_constructor.as_ptr() as *mut JsObject; + bind_constructor_hash!(core, global, "Array", ctor_ptr, crate::builtins::array::array_constructor, 1); } diff --git a/crates/oxide_vm/src/bindings/bind_boolean.rs b/crates/oxide_vm/src/bindings/bind_boolean.rs index 7ae1e18..71e21fb 100644 --- a/crates/oxide_vm/src/bindings/bind_boolean.rs +++ b/crates/oxide_vm/src/bindings/bind_boolean.rs @@ -2,26 +2,26 @@ use std::sync::Arc; use crate::bind_constructor_hash; use crate::bindings::{apply_binding_table, configure_native_constructor}; -use oxide_kernel::kernel::OxideKernel; +use oxide_kernel::kernel::{KernelCore, KernelSession}; use oxide_types::object::JsObject; -pub fn bind_boolean(kernel: &Arc, global: &mut JsObject) { - let ctor_ptr = kernel.builtin_world().boolean_constructor.as_ptr() as *mut JsObject; +pub fn bind_boolean(core: &Arc, session: &KernelSession, global: &mut JsObject) { + let ctor_ptr = session.builtin_world().boolean_constructor.as_ptr() as *mut JsObject; let ctor = unsafe { &mut *ctor_ptr }; - let proto_ptr = kernel.builtin_world().boolean_proto.as_ptr() as *mut JsObject; + let proto_ptr = session.builtin_world().boolean_proto.as_ptr() as *mut JsObject; let proto = unsafe { &mut *proto_ptr }; configure_native_constructor(ctor, crate::builtins::boolean::boolean_constructor as *const (), 1); apply_binding_table( - kernel.builtin_world(), + session.builtin_world(), proto, - kernel, + core, &[ ("valueOf", crate::builtins::boolean::boolean_prototype_value_of as *const (), 0), ("toString", crate::builtins::boolean::boolean_prototype_to_string as *const (), 0), ], ); - bind_constructor_hash!(kernel, global, "Boolean", ctor_ptr, crate::builtins::boolean::boolean_constructor, 1); + bind_constructor_hash!(core, global, "Boolean", ctor_ptr, crate::builtins::boolean::boolean_constructor, 1); } diff --git a/crates/oxide_vm/src/bindings/bind_date.rs b/crates/oxide_vm/src/bindings/bind_date.rs index cc15d37..e09bcbb 100644 --- a/crates/oxide_vm/src/bindings/bind_date.rs +++ b/crates/oxide_vm/src/bindings/bind_date.rs @@ -1,22 +1,22 @@ use std::sync::Arc; use crate::bindings::{apply_binding_table, bind_global_value, configure_native_constructor}; -use oxide_kernel::kernel::OxideKernel; +use oxide_kernel::kernel::{KernelCore, KernelSession}; use oxide_types::object::JsObject; use oxide_types::value::JsValue; -pub fn bind_date(kernel: &Arc, global: &mut JsObject) { - let ctor_ptr = kernel.builtin_world().date_constructor.as_ptr() as *mut JsObject; +pub fn bind_date(core: &Arc, session: &KernelSession, global: &mut JsObject) { + let ctor_ptr = session.builtin_world().date_constructor.as_ptr() as *mut JsObject; let ctor = unsafe { &mut *ctor_ptr }; - let proto_ptr = kernel.builtin_world().date_proto.as_ptr() as *mut JsObject; + let proto_ptr = session.builtin_world().date_proto.as_ptr() as *mut JsObject; let proto = unsafe { &mut *proto_ptr }; configure_native_constructor(ctor, crate::builtins::date::date_constructor as *const (), 7); apply_binding_table( - kernel.builtin_world(), + session.builtin_world(), ctor, - kernel, + core, &[ ("now", crate::builtins::date::date_now as *const (), 0), ("parse", crate::builtins::date::date_parse as *const (), 1), @@ -25,9 +25,9 @@ pub fn bind_date(kernel: &Arc, global: &mut JsObject) { ); apply_binding_table( - kernel.builtin_world(), + session.builtin_world(), proto, - kernel, + core, &[ ("getTime", crate::builtins::date::date_get_time as *const (), 0), ("getFullYear", crate::builtins::date::date_get_full_year as *const (), 0), @@ -65,5 +65,5 @@ pub fn bind_date(kernel: &Arc, global: &mut JsObject) { ], ); - bind_global_value(kernel, global, "Date", JsValue::from_js_object(ctor_ptr)); + bind_global_value(core, global, "Date", JsValue::from_js_object(ctor_ptr)); } diff --git a/crates/oxide_vm/src/bindings/bind_error.rs b/crates/oxide_vm/src/bindings/bind_error.rs index b7a2d12..3d7e071 100644 --- a/crates/oxide_vm/src/bindings/bind_error.rs +++ b/crates/oxide_vm/src/bindings/bind_error.rs @@ -1,17 +1,18 @@ use std::sync::Arc; use oxide_kernel::builtin::ErrorMethods; -use oxide_kernel::kernel::OxideKernel; +use oxide_kernel::kernel::{KernelCore, KernelSession}; use oxide_kernel::shape_forge::EMPTY_SHAPE_ID; use oxide_types::object::{JsObject, NativeFnPtr}; use oxide_types::value::JsValue; fn bind_error_subtype_constructor( - kernel: &Arc, global: &mut JsObject, name: &str, proto_ptr: *mut JsObject, ctor_fn: *const (), + core: &Arc, session: &KernelSession, global: &mut JsObject, name: &str, proto_ptr: *mut JsObject, + ctor_fn: *const (), ) { - let sf = kernel.string_forge().as_ref(); - let sh = kernel.shape_forge().as_ref(); - let function_proto_ptr = kernel.builtin_world().function_proto.as_ptr() as *mut JsObject; + let sf = core.string_forge().as_ref(); + let sh = core.shape_forge().as_ref(); + let function_proto_ptr = session.builtin_world().function_proto.as_ptr() as *mut JsObject; let mut ctor = Box::new(JsObject::new_empty(EMPTY_SHAPE_ID, JsValue::from_js_object(function_proto_ptr))); ctor.set_function(true); @@ -42,7 +43,7 @@ fn bind_error_subtype_constructor( global.bump_generation(); } -pub fn bind_error(kernel: &Arc, global: &mut JsObject) { +pub fn bind_error(core: &Arc, session: &KernelSession, global: &mut JsObject) { let error_methods = ErrorMethods { error: crate::builtins::error::error_constructor as *const (), type_error: crate::builtins::error::type_error_constructor as *const (), @@ -54,64 +55,70 @@ pub fn bind_error(kernel: &Arc, global: &mut JsObject) { to_string: crate::builtins::error::error_to_string as *const (), stack: crate::builtins::error::error_stack_getter as *const (), }; - kernel.builtin_world().bind_error_methods( + session.builtin_world().bind_error_methods( &error_methods, - kernel.string_forge().as_ref(), - kernel.shape_forge().as_ref(), + core.string_forge().as_ref(), + core.shape_forge().as_ref(), ); - let si_err = kernel.string_forge().intern("Error").0; - let err_shape = kernel.shape_forge().make_shape(global.shape_id(), si_err); - let err_val = JsValue::from_js_object(kernel.builtin_world().error_constructor.as_ptr() as *mut JsObject); + let si_err = core.string_forge().intern("Error").0; + let err_shape = core.shape_forge().make_shape(global.shape_id(), si_err); + let err_val = JsValue::from_js_object(session.builtin_world().error_constructor.as_ptr() as *mut JsObject); global.set_shape_id(err_shape); global.ensure_hash_props().push(err_val); global.bump_generation(); bind_error_subtype_constructor( - kernel, + core, + session, global, "TypeError", - kernel.builtin_world().type_error_proto.as_ptr() as *mut JsObject, + session.builtin_world().type_error_proto.as_ptr() as *mut JsObject, crate::builtins::error::type_error_constructor as *const (), ); bind_error_subtype_constructor( - kernel, + core, + session, global, "ReferenceError", - kernel.builtin_world().reference_error_proto.as_ptr() as *mut JsObject, + session.builtin_world().reference_error_proto.as_ptr() as *mut JsObject, crate::builtins::error::reference_error_constructor as *const (), ); bind_error_subtype_constructor( - kernel, + core, + session, global, "RangeError", - kernel.builtin_world().range_error_proto.as_ptr() as *mut JsObject, + session.builtin_world().range_error_proto.as_ptr() as *mut JsObject, crate::builtins::error::range_error_constructor as *const (), ); bind_error_subtype_constructor( - kernel, + core, + session, global, "SyntaxError", - kernel.builtin_world().syntax_error_proto.as_ptr() as *mut JsObject, + session.builtin_world().syntax_error_proto.as_ptr() as *mut JsObject, crate::builtins::error::syntax_error_constructor as *const (), ); bind_error_subtype_constructor( - kernel, + core, + session, global, "URIError", - kernel.builtin_world().uri_error_proto.as_ptr() as *mut JsObject, + session.builtin_world().uri_error_proto.as_ptr() as *mut JsObject, crate::builtins::error::uri_error_constructor as *const (), ); bind_error_subtype_constructor( - kernel, + core, + session, global, "EvalError", - kernel.builtin_world().eval_error_proto.as_ptr() as *mut JsObject, + session.builtin_world().eval_error_proto.as_ptr() as *mut JsObject, crate::builtins::error::eval_error_constructor as *const (), ); { - let err_ctor_ptr = kernel.builtin_world().error_constructor.as_ptr() as *mut JsObject; + let err_ctor_ptr = session.builtin_world().error_constructor.as_ptr() as *mut JsObject; let err_ctor = unsafe { &mut *err_ctor_ptr }; // SAFETY: error_constructor is a NativeFn fn-item. err_ctor.set_native_fn(Some(unsafe { diff --git a/crates/oxide_vm/src/bindings/bind_function.rs b/crates/oxide_vm/src/bindings/bind_function.rs index 28a7f37..f5ec29f 100644 --- a/crates/oxide_vm/src/bindings/bind_function.rs +++ b/crates/oxide_vm/src/bindings/bind_function.rs @@ -1,25 +1,25 @@ use std::sync::Arc; use oxide_kernel::builtin::FunctionMethods; -use oxide_kernel::kernel::OxideKernel; +use oxide_kernel::kernel::{KernelCore, KernelSession}; use oxide_types::object::JsObject; use oxide_types::value::JsValue; use super::bind_global_value; -pub fn bind_function(kernel: &Arc, global: &mut JsObject) { +pub fn bind_function(core: &Arc, session: &KernelSession, global: &mut JsObject) { let function_methods = FunctionMethods { call: crate::builtins::function::function_call as *const (), apply: crate::builtins::function::function_apply as *const (), bind: crate::builtins::function::function_bind as *const (), to_string: crate::builtins::function::function_to_string as *const (), }; - kernel.builtin_world().bind_function_methods( + session.builtin_world().bind_function_methods( &function_methods, - kernel.string_forge().as_ref(), - kernel.shape_forge().as_ref(), + core.string_forge().as_ref(), + core.shape_forge().as_ref(), ); - let function_ctor = kernel.builtin_world().function_constructor.as_ptr() as *mut JsObject; - bind_global_value(kernel, global, "Function", JsValue::from_js_object(function_ctor)); + let function_ctor = session.builtin_world().function_constructor.as_ptr() as *mut JsObject; + bind_global_value(core, global, "Function", JsValue::from_js_object(function_ctor)); } diff --git a/crates/oxide_vm/src/bindings/bind_json.rs b/crates/oxide_vm/src/bindings/bind_json.rs index 42c9262..7dcd285 100644 --- a/crates/oxide_vm/src/bindings/bind_json.rs +++ b/crates/oxide_vm/src/bindings/bind_json.rs @@ -1,18 +1,18 @@ use std::sync::Arc; use crate::bindings::{apply_binding_table, bind_global_value}; -use oxide_kernel::kernel::OxideKernel; +use oxide_kernel::kernel::{KernelCore, KernelSession}; use oxide_types::object::JsObject; use oxide_types::value::JsValue; -pub fn bind_json(kernel: &Arc, global: &mut JsObject) { - let json_ptr = kernel.builtin_world().json_object.as_ptr() as *mut JsObject; +pub fn bind_json(core: &Arc, session: &KernelSession, global: &mut JsObject) { + let json_ptr = session.builtin_world().json_object.as_ptr() as *mut JsObject; let json = unsafe { &mut *json_ptr }; apply_binding_table( - kernel.builtin_world(), + session.builtin_world(), json, - kernel, + core, &[ ("parse", crate::builtins::json::json_parse as *const (), 1), ("stringify", crate::builtins::json::json_stringify as *const (), 1), @@ -20,9 +20,9 @@ pub fn bind_json(kernel: &Arc, global: &mut JsObject) { ); bind_global_value( - kernel, + core, global, "JSON", - JsValue::from_js_object(kernel.builtin_world().json_object.as_ptr() as *mut JsObject), + JsValue::from_js_object(session.builtin_world().json_object.as_ptr() as *mut JsObject), ); } diff --git a/crates/oxide_vm/src/bindings/bind_map.rs b/crates/oxide_vm/src/bindings/bind_map.rs index 64b2217..e8ea2c2 100644 --- a/crates/oxide_vm/src/bindings/bind_map.rs +++ b/crates/oxide_vm/src/bindings/bind_map.rs @@ -2,21 +2,21 @@ use std::sync::Arc; use crate::bind_constructor_hash; use crate::bindings::{apply_binding_table, configure_native_constructor}; -use oxide_kernel::kernel::OxideKernel; +use oxide_kernel::kernel::{KernelCore, KernelSession}; use oxide_types::object::JsObject; -pub fn bind_map(kernel: &Arc, global: &mut JsObject) { - let ctor_ptr = kernel.builtin_world().map_constructor.as_ptr() as *mut JsObject; +pub fn bind_map(core: &Arc, session: &KernelSession, global: &mut JsObject) { + let ctor_ptr = session.builtin_world().map_constructor.as_ptr() as *mut JsObject; let ctor = unsafe { &mut *ctor_ptr }; - let proto_ptr = kernel.builtin_world().map_proto.as_ptr() as *mut JsObject; + let proto_ptr = session.builtin_world().map_proto.as_ptr() as *mut JsObject; configure_native_constructor(ctor, crate::builtins::map::map_constructor as *const (), 1); let proto = unsafe { &mut *proto_ptr }; apply_binding_table( - kernel.builtin_world(), + session.builtin_world(), proto, - kernel, + core, &[ ("set", crate::builtins::map::map_set as *const (), 2), ("get", crate::builtins::map::map_get as *const (), 1), @@ -27,5 +27,5 @@ pub fn bind_map(kernel: &Arc, global: &mut JsObject) { ], ); - bind_constructor_hash!(kernel, global, "Map", ctor_ptr, crate::builtins::map::map_constructor, 1); + bind_constructor_hash!(core, global, "Map", ctor_ptr, crate::builtins::map::map_constructor, 1); } diff --git a/crates/oxide_vm/src/bindings/bind_math.rs b/crates/oxide_vm/src/bindings/bind_math.rs index 8bb3634..7a6c1a5 100644 --- a/crates/oxide_vm/src/bindings/bind_math.rs +++ b/crates/oxide_vm/src/bindings/bind_math.rs @@ -1,17 +1,17 @@ use std::sync::Arc; use oxide_kernel::bind_methods; -use oxide_kernel::kernel::OxideKernel; +use oxide_kernel::kernel::{KernelCore, KernelSession}; use oxide_types::object::JsObject; use oxide_types::value::JsValue; -pub fn bind_math(kernel: &Arc, global: &mut JsObject) { - let math_ptr = kernel.builtin_world().math_object.as_ptr() as *mut JsObject; +pub fn bind_math(core: &Arc, session: &KernelSession, global: &mut JsObject) { + let math_ptr = session.builtin_world().math_object.as_ptr() as *mut JsObject; let math = unsafe { &mut *math_ptr }; - let bw = kernel.builtin_world(); - let sf = kernel.string_forge().as_ref(); - let sh = kernel.shape_forge().as_ref(); + let bw = session.builtin_world(); + let sf = core.string_forge().as_ref(); + let sh = core.shape_forge().as_ref(); bind_methods!( bw, @@ -65,15 +65,15 @@ pub fn bind_math(kernel: &Arc, global: &mut JsObject) { ("SQRT1_2", std::f64::consts::FRAC_1_SQRT_2), ("SQRT2", std::f64::consts::SQRT_2), ] { - let si = kernel.string_forge().as_ref().intern(name).0; - let sh_c = kernel.shape_forge().as_ref().make_shape(math.shape_id(), si); + let si = core.string_forge().as_ref().intern(name).0; + let sh_c = core.shape_forge().as_ref().make_shape(math.shape_id(), si); math.set_shape_id(sh_c); math.ensure_hash_props().push(JsValue::float(val)); } - let si_m = kernel.string_forge().intern("Math").0; - let m_shape = kernel.shape_forge().make_shape(global.shape_id(), si_m); - let m_val = JsValue::from_js_object(kernel.builtin_world().math_object.as_ptr() as *mut JsObject); + let si_m = core.string_forge().intern("Math").0; + let m_shape = core.shape_forge().make_shape(global.shape_id(), si_m); + let m_val = JsValue::from_js_object(session.builtin_world().math_object.as_ptr() as *mut JsObject); global.set_shape_id(m_shape); global.ensure_hash_props().push(m_val); global.bump_generation(); diff --git a/crates/oxide_vm/src/bindings/bind_number.rs b/crates/oxide_vm/src/bindings/bind_number.rs index 8862977..c0238fd 100644 --- a/crates/oxide_vm/src/bindings/bind_number.rs +++ b/crates/oxide_vm/src/bindings/bind_number.rs @@ -2,11 +2,11 @@ use std::sync::Arc; use oxide_kernel::bind_methods; use oxide_kernel::builtin::NumberMethods; -use oxide_kernel::kernel::OxideKernel; +use oxide_kernel::kernel::{KernelCore, KernelSession}; use oxide_types::object::{JsObject, NativeFnPtr}; use oxide_types::value::JsValue; -pub fn bind_number(kernel: &Arc, global: &mut JsObject) { +pub fn bind_number(core: &Arc, session: &KernelSession, global: &mut JsObject) { let number_methods = NumberMethods { is_nan: crate::builtins::number::number_is_nan as *const (), is_finite: crate::builtins::number::number_is_finite as *const (), @@ -20,21 +20,21 @@ pub fn bind_number(kernel: &Arc, global: &mut JsObject) { to_precision: crate::builtins::number::number_to_precision as *const (), value_of: crate::builtins::number::number_value_of as *const (), }; - kernel.builtin_world().bind_number_methods( + session.builtin_world().bind_number_methods( &number_methods, - kernel.string_forge().as_ref(), - kernel.shape_forge().as_ref(), + core.string_forge().as_ref(), + core.shape_forge().as_ref(), ); - let si_num = kernel.string_forge().intern("Number").0; - let num_shape = kernel.shape_forge().make_shape(global.shape_id(), si_num); - let num_val = JsValue::from_js_object(kernel.builtin_world().number_constructor.as_ptr() as *mut JsObject); + let si_num = core.string_forge().intern("Number").0; + let num_shape = core.shape_forge().make_shape(global.shape_id(), si_num); + let num_val = JsValue::from_js_object(session.builtin_world().number_constructor.as_ptr() as *mut JsObject); global.set_shape_id(num_shape); global.ensure_hash_props().push(num_val); global.bump_generation(); { - let num_ctor_ptr = kernel.builtin_world().number_constructor.as_ptr() as *mut JsObject; + let num_ctor_ptr = session.builtin_world().number_constructor.as_ptr() as *mut JsObject; let num_ctor = unsafe { &mut *num_ctor_ptr }; // SAFETY: number_constructor is a NativeFn fn-item. num_ctor.set_native_fn(Some(unsafe { @@ -53,8 +53,8 @@ pub fn bind_number(kernel: &Arc, global: &mut JsObject) { ("POSITIVE_INFINITY", JsValue::float(f64::INFINITY)), ] { num_ctor.ensure_hash_props().push(value); - let prop_si = kernel.string_forge().intern(name).0; - let next_shape = kernel.shape_forge().make_shape(num_ctor.shape_id(), prop_si); + let prop_si = core.string_forge().intern(name).0; + let next_shape = core.shape_forge().make_shape(num_ctor.shape_id(), prop_si); num_ctor.set_shape_id(next_shape); } } @@ -62,10 +62,10 @@ pub fn bind_number(kernel: &Arc, global: &mut JsObject) { let pi_fn = crate::builtins::number::number_parse_int as *const (); let pf_fn = crate::builtins::number::number_parse_float as *const (); bind_methods!( - kernel.builtin_world(), + session.builtin_world(), global, - kernel.string_forge().as_ref(), - kernel.shape_forge().as_ref(), + core.string_forge().as_ref(), + core.shape_forge().as_ref(), ("parseInt", pi_fn, 1), ("parseFloat", pf_fn, 1), ); diff --git a/crates/oxide_vm/src/bindings/bind_object.rs b/crates/oxide_vm/src/bindings/bind_object.rs index 6a661c4..7618369 100644 --- a/crates/oxide_vm/src/bindings/bind_object.rs +++ b/crates/oxide_vm/src/bindings/bind_object.rs @@ -1,11 +1,12 @@ use std::sync::Arc; -use crate::bind_constructor; use oxide_kernel::builtin::ObjectMethods; -use oxide_kernel::kernel::OxideKernel; +use oxide_kernel::kernel::{KernelCore, KernelSession}; use oxide_types::object::JsObject; -pub fn bind_object(kernel: &Arc, global: &mut JsObject) { +use crate::bind_constructor; + +pub fn bind_object(core: &Arc, session: &KernelSession, global: &mut JsObject) { let methods = ObjectMethods { keys: crate::builtins::object::object_keys as *const (), create: crate::builtins::object::object_create as *const (), @@ -29,10 +30,10 @@ pub fn bind_object(kernel: &Arc, global: &mut JsObject) { has_own_property: crate::builtins::object::object_proto_has_own_property as *const (), property_is_enumerable: crate::builtins::object::object_proto_property_is_enumerable as *const (), }; - kernel + session .builtin_world() - .bind_object_methods(&methods, kernel.string_forge().as_ref(), kernel.shape_forge().as_ref()); + .bind_object_methods(&methods, core.string_forge().as_ref(), core.shape_forge().as_ref()); - let ctor_ptr = kernel.builtin_world().object_constructor.as_ptr() as *mut JsObject; - bind_constructor!(kernel, global, "Object", ctor_ptr, crate::builtins::object::object_constructor, 1); + let ctor_ptr = session.builtin_world().object_constructor.as_ptr() as *mut JsObject; + bind_constructor!(core, global, "Object", ctor_ptr, crate::builtins::object::object_constructor, 1); } diff --git a/crates/oxide_vm/src/bindings/bind_regexp.rs b/crates/oxide_vm/src/bindings/bind_regexp.rs index cac4332..26cca18 100644 --- a/crates/oxide_vm/src/bindings/bind_regexp.rs +++ b/crates/oxide_vm/src/bindings/bind_regexp.rs @@ -1,23 +1,23 @@ use std::sync::Arc; use crate::bindings::{apply_binding_table, configure_native_constructor}; -use oxide_kernel::kernel::OxideKernel; +use oxide_kernel::kernel::{KernelCore, KernelSession}; use oxide_types::object::JsObject; use crate::bind_constructor_hash; -pub fn bind_regexp(kernel: &Arc, global: &mut JsObject) { - let ctor_ptr = kernel.builtin_world().regexp_constructor.as_ptr() as *mut JsObject; +pub fn bind_regexp(core: &Arc, session: &KernelSession, global: &mut JsObject) { + let ctor_ptr = session.builtin_world().regexp_constructor.as_ptr() as *mut JsObject; let ctor = unsafe { &mut *ctor_ptr }; - let proto_ptr = kernel.builtin_world().regexp_proto.as_ptr() as *mut JsObject; + let proto_ptr = session.builtin_world().regexp_proto.as_ptr() as *mut JsObject; let proto = unsafe { &mut *proto_ptr }; configure_native_constructor(ctor, crate::builtins::regexp::regexp_constructor as *const (), 2); apply_binding_table( - kernel.builtin_world(), + session.builtin_world(), proto, - kernel, + core, &[ ("exec", crate::builtins::regexp::regexp_exec as *const (), 1), ("test", crate::builtins::regexp::regexp_test as *const (), 1), @@ -25,5 +25,5 @@ pub fn bind_regexp(kernel: &Arc, global: &mut JsObject) { ], ); - bind_constructor_hash!(kernel, global, "RegExp", ctor_ptr, crate::builtins::regexp::regexp_constructor, 2); + bind_constructor_hash!(core, global, "RegExp", ctor_ptr, crate::builtins::regexp::regexp_constructor, 2); } diff --git a/crates/oxide_vm/src/bindings/bind_set.rs b/crates/oxide_vm/src/bindings/bind_set.rs index 7b2b533..9629dd3 100644 --- a/crates/oxide_vm/src/bindings/bind_set.rs +++ b/crates/oxide_vm/src/bindings/bind_set.rs @@ -2,21 +2,21 @@ use std::sync::Arc; use crate::bind_constructor_hash; use crate::bindings::{apply_binding_table, configure_native_constructor}; -use oxide_kernel::kernel::OxideKernel; +use oxide_kernel::kernel::{KernelCore, KernelSession}; use oxide_types::object::JsObject; -pub fn bind_set(kernel: &Arc, global: &mut JsObject) { - let ctor_ptr = kernel.builtin_world().set_constructor.as_ptr() as *mut JsObject; +pub fn bind_set(core: &Arc, session: &KernelSession, global: &mut JsObject) { + let ctor_ptr = session.builtin_world().set_constructor.as_ptr() as *mut JsObject; let ctor = unsafe { &mut *ctor_ptr }; - let proto_ptr = kernel.builtin_world().set_proto.as_ptr() as *mut JsObject; + let proto_ptr = session.builtin_world().set_proto.as_ptr() as *mut JsObject; configure_native_constructor(ctor, crate::builtins::set::set_constructor as *const (), 1); let proto = unsafe { &mut *proto_ptr }; apply_binding_table( - kernel.builtin_world(), + session.builtin_world(), proto, - kernel, + core, &[ ("add", crate::builtins::set::set_add as *const (), 1), ("has", crate::builtins::set::set_has as *const (), 1), @@ -26,5 +26,5 @@ pub fn bind_set(kernel: &Arc, global: &mut JsObject) { ], ); - bind_constructor_hash!(kernel, global, "Set", ctor_ptr, crate::builtins::set::set_constructor, 1); + bind_constructor_hash!(core, global, "Set", ctor_ptr, crate::builtins::set::set_constructor, 1); } diff --git a/crates/oxide_vm/src/bindings/bind_string.rs b/crates/oxide_vm/src/bindings/bind_string.rs index 96a461e..6dfea76 100644 --- a/crates/oxide_vm/src/bindings/bind_string.rs +++ b/crates/oxide_vm/src/bindings/bind_string.rs @@ -1,11 +1,11 @@ use std::sync::Arc; use oxide_kernel::builtin::StringMethods; -use oxide_kernel::kernel::OxideKernel; +use oxide_kernel::kernel::{KernelCore, KernelSession}; use oxide_types::object::JsObject; use oxide_types::value::JsValue; -pub fn bind_string(kernel: &Arc, global: &mut JsObject) { +pub fn bind_string(core: &Arc, session: &KernelSession, global: &mut JsObject) { let string_methods = StringMethods { index_of: crate::builtins::string::string_index_of as *const (), includes: crate::builtins::string::string_includes as *const (), @@ -34,15 +34,15 @@ pub fn bind_string(kernel: &Arc, global: &mut JsObject) { replace_all: crate::builtins::string::string_replace_all as *const (), value_of: crate::builtins::string::string_value_of as *const (), }; - kernel.builtin_world().bind_string_methods( + session.builtin_world().bind_string_methods( &string_methods, - kernel.string_forge().as_ref(), - kernel.shape_forge().as_ref(), + core.string_forge().as_ref(), + core.shape_forge().as_ref(), ); - let si_str = kernel.string_forge().intern("String").0; - let str_shape = kernel.shape_forge().make_shape(global.shape_id(), si_str); - let str_val = JsValue::from_js_object(kernel.builtin_world().string_constructor.as_ptr() as *mut JsObject); + let si_str = core.string_forge().intern("String").0; + let str_shape = core.shape_forge().make_shape(global.shape_id(), si_str); + let str_val = JsValue::from_js_object(session.builtin_world().string_constructor.as_ptr() as *mut JsObject); global.set_shape_id(str_shape); global.ensure_hash_props().push(str_val); global.bump_generation(); diff --git a/crates/oxide_vm/src/bindings/bind_symbol.rs b/crates/oxide_vm/src/bindings/bind_symbol.rs index b77928e..8a9366a 100644 --- a/crates/oxide_vm/src/bindings/bind_symbol.rs +++ b/crates/oxide_vm/src/bindings/bind_symbol.rs @@ -1,58 +1,58 @@ use std::sync::Arc; use crate::bindings::{apply_binding_table, configure_native_constructor}; -use oxide_kernel::kernel::OxideKernel; +use oxide_kernel::kernel::{KernelCore, KernelSession}; use oxide_types::object::JsObject; use oxide_types::value::JsValue; use crate::bind_constructor_hash; -pub fn bind_symbol(kernel: &Arc, global: &mut JsObject) { - let ctor_ptr = kernel.builtin_world().symbol_constructor.as_ptr() as *mut JsObject; +pub fn bind_symbol(core: &Arc, session: &KernelSession, global: &mut JsObject) { + let ctor_ptr = session.builtin_world().symbol_constructor.as_ptr() as *mut JsObject; let ctor = unsafe { &mut *ctor_ptr }; - let proto_ptr = kernel.builtin_world().symbol_proto.as_ptr() as *mut JsObject; + let proto_ptr = session.builtin_world().symbol_proto.as_ptr() as *mut JsObject; let proto = unsafe { &mut *proto_ptr }; configure_native_constructor(ctor, crate::builtins::symbol::symbol_constructor as *const (), 1); apply_binding_table( - kernel.builtin_world(), + session.builtin_world(), proto, - kernel, + core, &[("toString", crate::builtins::symbol::symbol_to_string as *const (), 0)], ); for (name, val) in [ ( "match", - JsValue::from_js_object(kernel.builtin_world().sym_match.as_ptr() as *mut JsObject), + JsValue::from_js_object(session.builtin_world().sym_match.as_ptr() as *mut JsObject), ), ( "replace", - JsValue::from_js_object(kernel.builtin_world().sym_replace.as_ptr() as *mut JsObject), + JsValue::from_js_object(session.builtin_world().sym_replace.as_ptr() as *mut JsObject), ), ( "search", - JsValue::from_js_object(kernel.builtin_world().sym_search.as_ptr() as *mut JsObject), + JsValue::from_js_object(session.builtin_world().sym_search.as_ptr() as *mut JsObject), ), ( "split", - JsValue::from_js_object(kernel.builtin_world().sym_split.as_ptr() as *mut JsObject), + JsValue::from_js_object(session.builtin_world().sym_split.as_ptr() as *mut JsObject), ), ( "iterator", - JsValue::from_js_object(kernel.builtin_world().sym_iterator.as_ptr() as *mut JsObject), + JsValue::from_js_object(session.builtin_world().sym_iterator.as_ptr() as *mut JsObject), ), ] { - bind_well_known_symbol(kernel, ctor, name, val); + bind_well_known_symbol(core, ctor, name, val); } - bind_constructor_hash!(kernel, global, "Symbol", ctor_ptr, crate::builtins::symbol::symbol_constructor, 1); + bind_constructor_hash!(core, global, "Symbol", ctor_ptr, crate::builtins::symbol::symbol_constructor, 1); } -fn bind_well_known_symbol(kernel: &Arc, ctor: &mut JsObject, name: &str, val: JsValue) { - let si = kernel.string_forge().intern(name).0; - let shape_id = kernel.shape_forge().make_shape(ctor.shape_id(), si); +fn bind_well_known_symbol(core: &Arc, ctor: &mut JsObject, name: &str, val: JsValue) { + let si = core.string_forge().intern(name).0; + let shape_id = core.shape_forge().make_shape(ctor.shape_id(), si); ctor.set_shape_id(shape_id); ctor.ensure_hash_props().push(val); ctor.bump_generation(); diff --git a/crates/oxide_vm/src/bindings/mod.rs b/crates/oxide_vm/src/bindings/mod.rs index 368f50a..337b2ea 100644 --- a/crates/oxide_vm/src/bindings/mod.rs +++ b/crates/oxide_vm/src/bindings/mod.rs @@ -16,15 +16,15 @@ pub mod bind_symbol; use std::sync::Arc; use oxide_kernel::builtin::BuiltinWorld; -use oxide_kernel::kernel::OxideKernel; +use oxide_kernel::kernel::{KernelCore, KernelSession}; use oxide_types::object::{JsObject, NativeFnPtr}; use oxide_types::value::JsValue; #[macro_export] macro_rules! bind_constructor { - ($kernel:expr, $global:expr, $name:literal, $ctor_ptr:expr, $ctor_fn:path, $nargs:literal) => {{ - let si = $kernel.string_forge().intern($name).0; - let shape = $kernel.shape_forge().make_shape($global.shape_id(), si); + ($core:expr, $global:expr, $name:literal, $ctor_ptr:expr, $ctor_fn:path, $nargs:literal) => {{ + let si = $core.string_forge().intern($name).0; + let shape = $core.shape_forge().make_shape($global.shape_id(), si); let val = $crate::JsValue::from_js_object($ctor_ptr); $global.set_shape_id(shape); $global.push_prop(val); @@ -37,9 +37,9 @@ macro_rules! bind_constructor { #[macro_export] macro_rules! bind_constructor_hash { - ($kernel:expr, $global:expr, $name:literal, $ctor_ptr:expr, $ctor_fn:path, $nargs:literal) => {{ - let si = $kernel.string_forge().intern($name).0; - let shape = $kernel.shape_forge().make_shape($global.shape_id(), si); + ($core:expr, $global:expr, $name:literal, $ctor_ptr:expr, $ctor_fn:path, $nargs:literal) => {{ + let si = $core.string_forge().intern($name).0; + let shape = $core.shape_forge().make_shape($global.shape_id(), si); let val = $crate::JsValue::from_js_object($ctor_ptr); $global.set_shape_id(shape); $global.ensure_hash_props().push(val); @@ -58,10 +58,10 @@ pub(crate) fn configure_native_constructor(ctor: &mut JsObject, native_fn: *cons } pub(crate) fn apply_binding_table( - world: &BuiltinWorld, target: &mut JsObject, kernel: &Arc, bindings: &[(&'static str, *const (), u8)], + world: &BuiltinWorld, target: &mut JsObject, core: &Arc, bindings: &[(&'static str, *const (), u8)], ) { - let shape_forge = kernel.shape_forge().as_ref(); - let string_forge = kernel.string_forge().as_ref(); + let shape_forge = core.shape_forge().as_ref(); + let string_forge = core.string_forge().as_ref(); for (name, func, nargs) in bindings { // SAFETY: all entries in the binding table are NativeFn fn-item pointers cast to *const (). let fn_ptr = unsafe { oxide_types::object::NativeFnPtr::from_raw(*func) }; @@ -69,32 +69,32 @@ pub(crate) fn apply_binding_table( } } -pub(crate) fn bind_global_value(kernel: &Arc, global: &mut JsObject, name: &str, value: JsValue) { - let si = kernel.string_forge().intern(name).0; - let shape = kernel.shape_forge().make_shape(global.shape_id(), si); +pub(crate) fn bind_global_value(core: &Arc, global: &mut JsObject, name: &str, value: JsValue) { + let si = core.string_forge().intern(name).0; + let shape = core.shape_forge().make_shape(global.shape_id(), si); global.set_shape_id(shape); global.ensure_hash_props().push(value); global.bump_generation(); } -pub fn init_kernel_builtins(kernel: &Arc) { - let global_ptr = kernel.global_object().as_ptr() as *mut oxide_types::object::JsObject; +pub fn init_kernel_builtins(core: &Arc, session: &KernelSession) { + let global_ptr = session.global_object().as_ptr() as *mut oxide_types::object::JsObject; let global = unsafe { &mut *global_ptr }; - bind_object::bind_object(kernel, global); - bind_array::bind_array(kernel, global); - bind_error::bind_error(kernel, global); - bind_string::bind_string(kernel, global); - bind_number::bind_number(kernel, global); - bind_math::bind_math(kernel, global); - bind_json::bind_json(kernel, global); - bind_date::bind_date(kernel, global); - bind_set::bind_set(kernel, global); - bind_map::bind_map(kernel, global); - bind_boolean::bind_boolean(kernel, global); - bind_function::bind_function(kernel, global); - bind_regexp::bind_regexp(kernel, global); - bind_symbol::bind_symbol(kernel, global); + bind_object::bind_object(core, session, global); + bind_array::bind_array(core, session, global); + bind_error::bind_error(core, session, global); + bind_string::bind_string(core, session, global); + bind_number::bind_number(core, session, global); + bind_math::bind_math(core, session, global); + bind_json::bind_json(core, session, global); + bind_date::bind_date(core, session, global); + bind_set::bind_set(core, session, global); + bind_map::bind_map(core, session, global); + bind_boolean::bind_boolean(core, session, global); + bind_function::bind_function(core, session, global); + bind_regexp::bind_regexp(core, session, global); + bind_symbol::bind_symbol(core, session, global); - bind_global_value(kernel, global, "globalThis", JsValue::from_js_object(global_ptr)); + bind_global_value(core, global, "globalThis", JsValue::from_js_object(global_ptr)); } diff --git a/crates/oxide_vm/src/builtins/array.rs b/crates/oxide_vm/src/builtins/array.rs index d178c7b..88b049e 100644 --- a/crates/oxide_vm/src/builtins/array.rs +++ b/crates/oxide_vm/src/builtins/array.rs @@ -39,7 +39,7 @@ fn get_this_array_ref(val: JsValue) -> Result<*mut JsObject, JsValue> { } fn create_new_array(vm: &mut Vm, n: usize) -> *mut JsObject { - let proto = vm.kernel().builtin_world().array_proto.as_ptr() as *mut JsObject; + let proto = vm.session().builtin_world().array_proto.as_ptr() as *mut JsObject; vm.epoch() .alloc(JsObject::new_array(EMPTY_SHAPE_ID, JsValue::from_js_object(proto), n, vm.epoch().bump())) } @@ -74,7 +74,7 @@ fn invoke_native_callback(vm: &mut Vm, callback_val: JsValue, this_val: JsValue, } pub fn array_constructor(vm: &mut Vm, args: &[u8]) -> NativeResult { - let proto = vm.kernel().builtin_world().array_proto.as_ptr() as *mut JsObject; + let proto = vm.session().builtin_world().array_proto.as_ptr() as *mut JsObject; let proto_val = JsValue::from_js_object(proto); if args.len() == 2 { @@ -155,12 +155,12 @@ pub fn array_slice(vm: &mut Vm, args: &[u8]) -> NativeResult { let arr = unsafe { &*arr_ptr }; let n = arr.prop_count() as usize; let start = if args.len() > 1 { - (coercion::to_number(vm.reg(args[1]), vm.kernel().string_forge().as_ref()) as i32) as usize + (coercion::to_number(vm.reg(args[1]), vm.kernel_core().string_forge().as_ref()) as i32) as usize } else { 0 }; let end = if args.len() > 2 { - (coercion::to_number(vm.reg(args[2]), vm.kernel().string_forge().as_ref()) as i32) as usize + (coercion::to_number(vm.reg(args[2]), vm.kernel_core().string_forge().as_ref()) as i32) as usize } else { n }; @@ -184,7 +184,7 @@ pub fn array_splice(vm: &mut Vm, args: &[u8]) -> NativeResult { let n = arr.prop_count() as usize; let start = if args.len() > 1 { - let v = coercion::to_number(vm.reg(args[1]), vm.kernel().string_forge().as_ref()); + let v = coercion::to_number(vm.reg(args[1]), vm.kernel_core().string_forge().as_ref()); let s = v as i32; if s < 0 { (n as i32 + s).max(0) as usize @@ -196,7 +196,7 @@ pub fn array_splice(vm: &mut Vm, args: &[u8]) -> NativeResult { }; let delete_count = if args.len() > 2 { - let v = coercion::to_number(vm.reg(args[2]), vm.kernel().string_forge().as_ref()); + let v = coercion::to_number(vm.reg(args[2]), vm.kernel_core().string_forge().as_ref()); (v as usize).min(n - start) } else { n - start @@ -280,11 +280,11 @@ pub fn array_join(vm: &mut Vm, args: &[u8]) -> NativeResult { let arr = unsafe { &*arr_ptr }; let n = arr.prop_count() as usize; let sep = if args.len() > 1 { - coercion::to_string(vm.kernel().string_forge().as_ref(), vm.reg(args[1])) + coercion::to_string(vm.kernel_core().string_forge().as_ref(), vm.reg(args[1])) } else { ",".to_string() }; - let sf = vm.kernel().string_forge().as_ref(); + let sf = vm.kernel_core().string_forge().as_ref(); let parts: Vec = (0..n) .map(|i| { let v = arr.get_prop_at(i); @@ -361,7 +361,7 @@ pub fn array_flat(vm: &mut Vm, args: &[u8]) -> NativeResult { let arr = unsafe { &*arr_ptr }; let n = arr.prop_count() as usize; let depth = if args.len() > 1 { - (coercion::to_number(vm.reg(args[1]), vm.kernel().string_forge().as_ref()) as i32).max(1) as usize + (coercion::to_number(vm.reg(args[1]), vm.kernel_core().string_forge().as_ref()) as i32).max(1) as usize } else { 1 }; @@ -457,7 +457,7 @@ pub fn array_filter(vm: &mut Vm, args: &[u8]) -> NativeResult { let elem = unsafe { (*arr_ptr).get_prop_at(i) }; match invoke_native_callback(vm, callback_val, this_val, &[elem, JsValue::int(i as i32), vm.reg(args[0])]) { NativeResult::Ok(result_val) => { - let sf = vm.kernel().string_forge().as_ref(); + let sf = vm.kernel_core().string_forge().as_ref(); if coercion::to_boolean(result_val, sf) { kept.push(elem); } @@ -527,7 +527,7 @@ pub fn array_find(vm: &mut Vm, args: &[u8]) -> NativeResult { let elem = unsafe { (*arr_ptr).get_prop_at(i) }; match invoke_native_callback(vm, callback_val, this_val, &[elem, JsValue::int(i as i32), vm.reg(args[0])]) { NativeResult::Ok(result_val) => { - let sf = vm.kernel().string_forge().as_ref(); + let sf = vm.kernel_core().string_forge().as_ref(); if coercion::to_boolean(result_val, sf) { return NativeResult::Ok(elem); } @@ -552,7 +552,7 @@ pub fn array_some(vm: &mut Vm, args: &[u8]) -> NativeResult { let elem = unsafe { (*arr_ptr).get_prop_at(i) }; match invoke_native_callback(vm, callback_val, this_val, &[elem, JsValue::int(i as i32), vm.reg(args[0])]) { NativeResult::Ok(result_val) => { - let sf = vm.kernel().string_forge().as_ref(); + let sf = vm.kernel_core().string_forge().as_ref(); if coercion::to_boolean(result_val, sf) { return NativeResult::Ok(JsValue::bool(true)); } @@ -577,7 +577,7 @@ pub fn array_every(vm: &mut Vm, args: &[u8]) -> NativeResult { let elem = unsafe { (*arr_ptr).get_prop_at(i) }; match invoke_native_callback(vm, callback_val, this_val, &[elem, JsValue::int(i as i32), vm.reg(args[0])]) { NativeResult::Ok(result_val) => { - let sf = vm.kernel().string_forge().as_ref(); + let sf = vm.kernel_core().string_forge().as_ref(); if !coercion::to_boolean(result_val, sf) { return NativeResult::Ok(JsValue::bool(false)); } @@ -670,12 +670,12 @@ pub fn array_fill(vm: &mut Vm, args: &[u8]) -> NativeResult { let len = arr.prop_count() as usize; let value = if args.len() > 1 { vm.reg(args[1]) } else { JsValue::undefined() }; let start = if args.len() > 2 { - (coercion::to_number(vm.reg(args[2]), vm.kernel().string_forge().as_ref()) as i32).max(0) as usize + (coercion::to_number(vm.reg(args[2]), vm.kernel_core().string_forge().as_ref()) as i32).max(0) as usize } else { 0 }; let end = if args.len() > 3 { - let e = coercion::to_number(vm.reg(args[3]), vm.kernel().string_forge().as_ref()) as i32; + let e = coercion::to_number(vm.reg(args[3]), vm.kernel_core().string_forge().as_ref()) as i32; (e as usize).min(len) } else { len @@ -694,17 +694,17 @@ pub fn array_copy_within(vm: &mut Vm, args: &[u8]) -> NativeResult { return NativeResult::Ok(vm.reg(args[0])); } let target = if args.len() > 1 { - (coercion::to_number(vm.reg(args[1]), vm.kernel().string_forge().as_ref()) as i32) as usize + (coercion::to_number(vm.reg(args[1]), vm.kernel_core().string_forge().as_ref()) as i32) as usize } else { 0 }; let start = if args.len() > 2 { - (coercion::to_number(vm.reg(args[2]), vm.kernel().string_forge().as_ref()) as i32) as usize + (coercion::to_number(vm.reg(args[2]), vm.kernel_core().string_forge().as_ref()) as i32) as usize } else { 0 }; let end = if args.len() > 3 { - (coercion::to_number(vm.reg(args[3]), vm.kernel().string_forge().as_ref()) as i32 as usize).min(len) + (coercion::to_number(vm.reg(args[3]), vm.kernel_core().string_forge().as_ref()) as i32 as usize).min(len) } else { len }; @@ -725,7 +725,7 @@ pub fn array_at(vm: &mut Vm, args: &[u8]) -> NativeResult { let arr = unsafe { &*arr_ptr }; let len = arr.prop_count() as i32; let mut index = if args.len() > 1 { - coercion::to_number(vm.reg(args[1]), vm.kernel().string_forge().as_ref()) as i32 + coercion::to_number(vm.reg(args[1]), vm.kernel_core().string_forge().as_ref()) as i32 } else { 0 }; @@ -762,7 +762,7 @@ pub fn array_find_index(vm: &mut Vm, args: &[u8]) -> NativeResult { let elem = unsafe { (*arr_ptr).get_prop_at(i) }; match invoke_native_callback(vm, callback_val, this_val, &[elem, JsValue::int(i as i32), vm.reg(args[0])]) { NativeResult::Ok(r) => { - if coercion::to_boolean(r, vm.kernel().string_forge().as_ref()) { + if coercion::to_boolean(r, vm.kernel_core().string_forge().as_ref()) { return NativeResult::Ok(JsValue::int(i as i32)); } } @@ -786,7 +786,7 @@ pub fn array_find_last(vm: &mut Vm, args: &[u8]) -> NativeResult { let elem = unsafe { (*arr_ptr).get_prop_at(i) }; match invoke_native_callback(vm, callback_val, this_val, &[elem, JsValue::int(i), vm.reg(args[0])]) { NativeResult::Ok(r) => { - if coercion::to_boolean(r, vm.kernel().string_forge().as_ref()) { + if coercion::to_boolean(r, vm.kernel_core().string_forge().as_ref()) { return NativeResult::Ok(elem); } } @@ -831,8 +831,8 @@ pub fn array_sort(vm: &mut Vm, _args: &[u8]) -> NativeResult { let len = arr.prop_count() as usize; let mut vals: Vec = (0..len).map(|i| arr.get_prop_at(i)).collect(); vals.sort_by(|a, b| { - let sa = coercion::to_string(vm.kernel().string_forge().as_ref(), *a); - let sb = coercion::to_string(vm.kernel().string_forge().as_ref(), *b); + let sa = coercion::to_string(vm.kernel_core().string_forge().as_ref(), *a); + let sb = coercion::to_string(vm.kernel_core().string_forge().as_ref(), *b); sa.cmp(&sb) }); for (i, &v) in vals.iter().enumerate() { diff --git a/crates/oxide_vm/src/builtins/boolean.rs b/crates/oxide_vm/src/builtins/boolean.rs index 9450ed2..9570d08 100644 --- a/crates/oxide_vm/src/builtins/boolean.rs +++ b/crates/oxide_vm/src/builtins/boolean.rs @@ -13,7 +13,7 @@ pub fn boolean_constructor(vm: &mut Vm, args: &[u8]) -> NativeResult { } else if arg.is_bool() { arg.as_bool() } else if arg.is_string() { - let s = vm.kernel().string_forge().lookup(arg.as_string_index()).unwrap_or_default(); + let s = vm.kernel_core().string_forge().lookup(arg.as_string_index()).unwrap_or_default(); !s.is_empty() } else if arg.is_object() { true @@ -28,7 +28,7 @@ pub fn boolean_constructor(vm: &mut Vm, args: &[u8]) -> NativeResult { false }; - let boolean_proto = vm.kernel().builtin_world().boolean_proto.as_ptr() as *mut JsObject; + let boolean_proto = vm.session().builtin_world().boolean_proto.as_ptr() as *mut JsObject; let is_ctor = if this_val.is_object() { let ptr = this_val.as_js_object_ptr(); if ptr.is_null() { diff --git a/crates/oxide_vm/src/builtins/date.rs b/crates/oxide_vm/src/builtins/date.rs index 486d6cd..9e1ff39 100644 --- a/crates/oxide_vm/src/builtins/date.rs +++ b/crates/oxide_vm/src/builtins/date.rs @@ -82,7 +82,7 @@ pub fn date_constructor(vm: &mut Vm, args: &[u8]) -> NativeResult { if ptr.is_null() { false } else { - let date_proto = vm.kernel().builtin_world().date_proto.as_ptr() as *mut JsObject; + let date_proto = vm.session().builtin_world().date_proto.as_ptr() as *mut JsObject; if date_proto.is_null() { false } else { @@ -100,30 +100,30 @@ pub fn date_constructor(vm: &mut Vm, args: &[u8]) -> NativeResult { let timestamp = if args.len() < 2 { Utc::now().timestamp_millis() as f64 } else if args.len() > 2 { - let y = coercion::to_number(vm.reg(args[1]), vm.kernel().string_forge().as_ref()) as i32; - let m = coercion::to_number(vm.reg(args[2]), vm.kernel().string_forge().as_ref()) as u32; + let y = coercion::to_number(vm.reg(args[1]), vm.kernel_core().string_forge().as_ref()) as i32; + let m = coercion::to_number(vm.reg(args[2]), vm.kernel_core().string_forge().as_ref()) as u32; let d = if args.len() > 3 { - coercion::to_number(vm.reg(args[3]), vm.kernel().string_forge().as_ref()) as u32 + coercion::to_number(vm.reg(args[3]), vm.kernel_core().string_forge().as_ref()) as u32 } else { 1 }; let h = if args.len() > 4 { - coercion::to_number(vm.reg(args[4]), vm.kernel().string_forge().as_ref()) as u32 + coercion::to_number(vm.reg(args[4]), vm.kernel_core().string_forge().as_ref()) as u32 } else { 0 }; let min = if args.len() > 5 { - coercion::to_number(vm.reg(args[5]), vm.kernel().string_forge().as_ref()) as u32 + coercion::to_number(vm.reg(args[5]), vm.kernel_core().string_forge().as_ref()) as u32 } else { 0 }; let sec = if args.len() > 6 { - coercion::to_number(vm.reg(args[6]), vm.kernel().string_forge().as_ref()) as u32 + coercion::to_number(vm.reg(args[6]), vm.kernel_core().string_forge().as_ref()) as u32 } else { 0 }; let ms = if args.len() > 7 { - coercion::to_number(vm.reg(args[7]), vm.kernel().string_forge().as_ref()) as u32 + coercion::to_number(vm.reg(args[7]), vm.kernel_core().string_forge().as_ref()) as u32 } else { 0 }; @@ -137,7 +137,7 @@ pub fn date_constructor(vm: &mut Vm, args: &[u8]) -> NativeResult { } else { let val = vm.reg(args[1]); if val.is_string() { - let s = vm.kernel().string_forge().lookup(val.as_string_index()).unwrap_or_default(); + let s = vm.kernel_core().string_forge().lookup(val.as_string_index()).unwrap_or_default(); let formats = ["%Y-%m-%dT%H:%M:%S%.fZ", "%Y-%m-%dT%H:%M:%S%.f"]; let mut ts = f64::NAN; for fmt in &formats { @@ -188,7 +188,7 @@ pub fn date_constructor(vm: &mut Vm, args: &[u8]) -> NativeResult { let mut obj = JsObject::new_empty( EMPTY_SHAPE_ID, - JsValue::from_js_object(vm.kernel().builtin_world().date_proto.as_ptr() as *mut JsObject), + JsValue::from_js_object(vm.session().builtin_world().date_proto.as_ptr() as *mut JsObject), ); obj.type_tag = JsObject::OBJ_TYPE_DATE; obj.set_prop_at(0, JsValue::float(timestamp)); @@ -209,7 +209,7 @@ pub fn date_parse(vm: &mut Vm, args: &[u8]) -> NativeResult { if !val.is_string() { return NativeResult::Ok(JsValue::float(f64::NAN)); } - let s = vm.kernel().string_forge().lookup(val.as_string_index()).unwrap_or_default(); + let s = vm.kernel_core().string_forge().lookup(val.as_string_index()).unwrap_or_default(); let formats = ["%Y-%m-%dT%H:%M:%S%.fZ", "%Y-%m-%dT%H:%M:%S%.f"]; let mut ts = f64::NAN; for fmt in &formats { @@ -303,7 +303,7 @@ fn local_offset_minutes() -> i32 { fn get_opt_arg(vm: &Vm, args: &[u8], idx: usize, default: u32) -> u32 { if args.len() > idx { - coercion::to_number(vm.reg(args[idx]), vm.kernel().string_forge().as_ref()) as u32 + coercion::to_number(vm.reg(args[idx]), vm.kernel_core().string_forge().as_ref()) as u32 } else { default } @@ -312,7 +312,7 @@ fn get_opt_arg(vm: &Vm, args: &[u8], idx: usize, default: u32) -> u32 { pub fn date_set_time(vm: &mut Vm, args: &[u8]) -> NativeResult { let obj = unsafe { &mut *native_try!(date_this_mut(vm, args)) }; let val = if args.len() > 1 { - coercion::to_number(vm.reg(args[1]), vm.kernel().string_forge().as_ref()) + coercion::to_number(vm.reg(args[1]), vm.kernel_core().string_forge().as_ref()) } else { f64::NAN }; @@ -322,7 +322,7 @@ pub fn date_set_time(vm: &mut Vm, args: &[u8]) -> NativeResult { pub fn date_set_full_year(vm: &mut Vm, args: &[u8]) -> NativeResult { let val = if args.len() > 1 { vm.reg(args[1]) } else { JsValue::undefined() }; - let v = coercion::to_number(val, vm.kernel().string_forge().as_ref()); + let v = coercion::to_number(val, vm.kernel_core().string_forge().as_ref()); let obj = unsafe { &mut *native_try!(date_this_mut(vm, args)) }; let ms = get_timestamp(obj); if !ms.is_finite() { @@ -345,7 +345,7 @@ pub fn date_set_full_year(vm: &mut Vm, args: &[u8]) -> NativeResult { } pub fn date_set_month(vm: &mut Vm, args: &[u8]) -> NativeResult { let val = if args.len() > 1 { vm.reg(args[1]) } else { JsValue::undefined() }; - let v = coercion::to_number(val, vm.kernel().string_forge().as_ref()); + let v = coercion::to_number(val, vm.kernel_core().string_forge().as_ref()); let obj = unsafe { &mut *native_try!(date_this_mut(vm, args)) }; let ms = get_timestamp(obj); if !ms.is_finite() { @@ -363,7 +363,7 @@ pub fn date_set_month(vm: &mut Vm, args: &[u8]) -> NativeResult { } pub fn date_set_date(vm: &mut Vm, args: &[u8]) -> NativeResult { let val = if args.len() > 1 { vm.reg(args[1]) } else { JsValue::undefined() }; - let v = coercion::to_number(val, vm.kernel().string_forge().as_ref()); + let v = coercion::to_number(val, vm.kernel_core().string_forge().as_ref()); let obj = unsafe { &mut *native_try!(date_this_mut(vm, args)) }; let ms = get_timestamp(obj); if !ms.is_finite() { @@ -380,7 +380,7 @@ pub fn date_set_date(vm: &mut Vm, args: &[u8]) -> NativeResult { } pub fn date_set_hours(vm: &mut Vm, args: &[u8]) -> NativeResult { let val = if args.len() > 1 { vm.reg(args[1]) } else { JsValue::undefined() }; - let v = coercion::to_number(val, vm.kernel().string_forge().as_ref()); + let v = coercion::to_number(val, vm.kernel_core().string_forge().as_ref()); let obj = unsafe { &mut *native_try!(date_this_mut(vm, args)) }; let ms = get_timestamp(obj); if !ms.is_finite() { @@ -405,7 +405,7 @@ pub fn date_set_hours(vm: &mut Vm, args: &[u8]) -> NativeResult { } pub fn date_set_minutes(vm: &mut Vm, args: &[u8]) -> NativeResult { let val = if args.len() > 1 { vm.reg(args[1]) } else { JsValue::undefined() }; - let v = coercion::to_number(val, vm.kernel().string_forge().as_ref()); + let v = coercion::to_number(val, vm.kernel_core().string_forge().as_ref()); let obj = unsafe { &mut *native_try!(date_this_mut(vm, args)) }; let ms = get_timestamp(obj); if !ms.is_finite() { @@ -428,7 +428,7 @@ pub fn date_set_minutes(vm: &mut Vm, args: &[u8]) -> NativeResult { } pub fn date_set_seconds(vm: &mut Vm, args: &[u8]) -> NativeResult { let val = if args.len() > 1 { vm.reg(args[1]) } else { JsValue::undefined() }; - let v = coercion::to_number(val, vm.kernel().string_forge().as_ref()); + let v = coercion::to_number(val, vm.kernel_core().string_forge().as_ref()); let obj = unsafe { &mut *native_try!(date_this_mut(vm, args)) }; let ms = get_timestamp(obj); if !ms.is_finite() { @@ -449,7 +449,7 @@ pub fn date_set_seconds(vm: &mut Vm, args: &[u8]) -> NativeResult { } pub fn date_set_milliseconds(vm: &mut Vm, args: &[u8]) -> NativeResult { let val = if args.len() > 1 { vm.reg(args[1]) } else { JsValue::undefined() }; - let v = coercion::to_number(val, vm.kernel().string_forge().as_ref()); + let v = coercion::to_number(val, vm.kernel_core().string_forge().as_ref()); let obj = unsafe { &mut *native_try!(date_this_mut(vm, args)) }; let ms = get_timestamp(obj); if !ms.is_finite() { diff --git a/crates/oxide_vm/src/builtins/error.rs b/crates/oxide_vm/src/builtins/error.rs index 8616c5a..99bfe7b 100644 --- a/crates/oxide_vm/src/builtins/error.rs +++ b/crates/oxide_vm/src/builtins/error.rs @@ -14,8 +14,8 @@ fn create_error_object(vm: &mut Vm, error_proto_ptr: *mut JsObject, name: &str, .epoch() .alloc(JsObject::new_empty(EMPTY_SHAPE_ID, JsValue::from_js_object(error_proto_ptr))); - let sf = Arc::clone(vm.kernel().string_forge()); - let sh = Arc::clone(vm.kernel().shape_forge()); + let sf = Arc::clone(vm.kernel_core().string_forge()); + let sh = Arc::clone(vm.kernel_core().shape_forge()); let si_message = sf.intern("message").0; let sh_message = sh.make_shape(EMPTY_SHAPE_ID, si_message); @@ -37,33 +37,33 @@ fn create_error_object(vm: &mut Vm, error_proto_ptr: *mut JsObject, name: &str, } pub fn create_type_error(vm: &mut Vm, msg: &str) -> JsValue { - let proto_ptr = P::as_ptr(&vm.kernel().builtin_world().type_error_proto) as *mut JsObject; + let proto_ptr = P::as_ptr(&vm.session().builtin_world().type_error_proto) as *mut JsObject; create_error_object(vm, proto_ptr, "TypeError", msg) } pub fn create_error(vm: &mut Vm, msg: &str) -> JsValue { - let proto_ptr = P::as_ptr(&vm.kernel().builtin_world().error_proto) as *mut JsObject; + let proto_ptr = P::as_ptr(&vm.session().builtin_world().error_proto) as *mut JsObject; create_error_object(vm, proto_ptr, "Error", msg) } pub fn create_reference_error(vm: &mut Vm, msg: &str) -> JsValue { - let proto_ptr = P::as_ptr(&vm.kernel().builtin_world().reference_error_proto) as *mut JsObject; + let proto_ptr = P::as_ptr(&vm.session().builtin_world().reference_error_proto) as *mut JsObject; create_error_object(vm, proto_ptr, "ReferenceError", msg) } pub fn create_range_error(vm: &mut Vm, msg: &str) -> JsValue { - let proto_ptr = P::as_ptr(&vm.kernel().builtin_world().range_error_proto) as *mut JsObject; + let proto_ptr = P::as_ptr(&vm.session().builtin_world().range_error_proto) as *mut JsObject; create_error_object(vm, proto_ptr, "RangeError", msg) } pub fn create_syntax_error(vm: &mut Vm, msg: &str) -> JsValue { - let proto_ptr = P::as_ptr(&vm.kernel().builtin_world().syntax_error_proto) as *mut JsObject; + let proto_ptr = P::as_ptr(&vm.session().builtin_world().syntax_error_proto) as *mut JsObject; create_error_object(vm, proto_ptr, "SyntaxError", msg) } fn get_msg(vm: &mut Vm, args: &[u8]) -> String { if args.len() > 1 { - coercion::to_string(vm.kernel().string_forge().as_ref(), vm.reg(args[1])) + coercion::to_string(vm.kernel_core().string_forge().as_ref(), vm.reg(args[1])) } else { String::new() } @@ -71,43 +71,43 @@ fn get_msg(vm: &mut Vm, args: &[u8]) -> String { pub fn error_constructor(vm: &mut Vm, args: &[u8]) -> NativeResult { let msg = get_msg(vm, args); - let proto_ptr = P::as_ptr(&vm.kernel().builtin_world().error_proto) as *mut JsObject; + let proto_ptr = P::as_ptr(&vm.session().builtin_world().error_proto) as *mut JsObject; NativeResult::Ok(create_error_object(vm, proto_ptr, "Error", &msg)) } pub fn type_error_constructor(vm: &mut Vm, args: &[u8]) -> NativeResult { let msg = get_msg(vm, args); - let proto_ptr = P::as_ptr(&vm.kernel().builtin_world().type_error_proto) as *mut JsObject; + let proto_ptr = P::as_ptr(&vm.session().builtin_world().type_error_proto) as *mut JsObject; NativeResult::Ok(create_error_object(vm, proto_ptr, "TypeError", &msg)) } pub fn reference_error_constructor(vm: &mut Vm, args: &[u8]) -> NativeResult { let msg = get_msg(vm, args); - let proto_ptr = P::as_ptr(&vm.kernel().builtin_world().reference_error_proto) as *mut JsObject; + let proto_ptr = P::as_ptr(&vm.session().builtin_world().reference_error_proto) as *mut JsObject; NativeResult::Ok(create_error_object(vm, proto_ptr, "ReferenceError", &msg)) } pub fn range_error_constructor(vm: &mut Vm, args: &[u8]) -> NativeResult { let msg = get_msg(vm, args); - let proto_ptr = P::as_ptr(&vm.kernel().builtin_world().range_error_proto) as *mut JsObject; + let proto_ptr = P::as_ptr(&vm.session().builtin_world().range_error_proto) as *mut JsObject; NativeResult::Ok(create_error_object(vm, proto_ptr, "RangeError", &msg)) } pub fn syntax_error_constructor(vm: &mut Vm, args: &[u8]) -> NativeResult { let msg = get_msg(vm, args); - let proto_ptr = P::as_ptr(&vm.kernel().builtin_world().syntax_error_proto) as *mut JsObject; + let proto_ptr = P::as_ptr(&vm.session().builtin_world().syntax_error_proto) as *mut JsObject; NativeResult::Ok(create_error_object(vm, proto_ptr, "SyntaxError", &msg)) } pub fn uri_error_constructor(vm: &mut Vm, args: &[u8]) -> NativeResult { let msg = get_msg(vm, args); - let proto_ptr = P::as_ptr(&vm.kernel().builtin_world().uri_error_proto) as *mut JsObject; + let proto_ptr = P::as_ptr(&vm.session().builtin_world().uri_error_proto) as *mut JsObject; NativeResult::Ok(create_error_object(vm, proto_ptr, "URIError", &msg)) } pub fn eval_error_constructor(vm: &mut Vm, args: &[u8]) -> NativeResult { let msg = get_msg(vm, args); - let proto_ptr = P::as_ptr(&vm.kernel().builtin_world().eval_error_proto) as *mut JsObject; + let proto_ptr = P::as_ptr(&vm.session().builtin_world().eval_error_proto) as *mut JsObject; NativeResult::Ok(create_error_object(vm, proto_ptr, "EvalError", &msg)) } @@ -133,7 +133,7 @@ pub fn error_to_string(vm: &mut Vm, args: &[u8]) -> NativeResult { ("Error".to_string(), String::new()) }; let result = if msg.is_empty() { name } else { format!("{}: {}", name, msg) }; - let si = vm.kernel().string_forge().intern(&result).0; + let si = vm.kernel_core().string_forge().intern(&result).0; NativeResult::Ok(JsValue::string(si, 0)) } @@ -141,7 +141,7 @@ pub fn error_stack_getter(vm: &mut Vm, _args: &[u8]) -> NativeResult { let mut lines = vec![]; for frame in vm.frames.iter().rev() { let func_name = vm - .kernel() + .kernel_core() .string_forge() .lookup(frame.function_name) .unwrap_or_else(|| "".to_string()); @@ -149,7 +149,7 @@ pub fn error_stack_getter(vm: &mut Vm, _args: &[u8]) -> NativeResult { } lines.push(" at (native)".to_string()); let result = lines.join("\n"); - let si = vm.kernel().string_forge().intern(&result).0; + let si = vm.kernel_core().string_forge().intern(&result).0; NativeResult::Ok(JsValue::string(si, 0)) } @@ -162,7 +162,7 @@ mod tests { #[test] fn error_stack_uses_call_frame_function_name() { let mut vm = Vm::new(); - let name_si = vm.kernel().string_forge().intern("foo").0; + let name_si = vm.kernel_core().string_forge().intern("foo").0; vm.frames.push(CallFrame { return_addr: 0, function_name: name_si, @@ -178,7 +178,7 @@ mod tests { }); let stack = error_stack_getter(&mut vm, &[0]).unwrap(); - let stack_str = vm.kernel().string_forge().lookup(stack.as_string_index()).unwrap_or_default(); + let stack_str = vm.kernel_core().string_forge().lookup(stack.as_string_index()).unwrap_or_default(); assert!(stack_str.contains("foo"), "expected function name in stack: {stack_str}"); } } diff --git a/crates/oxide_vm/src/builtins/function.rs b/crates/oxide_vm/src/builtins/function.rs index ed02ae0..4e77c83 100644 --- a/crates/oxide_vm/src/builtins/function.rs +++ b/crates/oxide_vm/src/builtins/function.rs @@ -121,12 +121,12 @@ pub fn function_to_string(vm: &mut Vm, args: &[u8]) -> NativeResult { )); } - let name_si = vm.kernel().string_forge().intern("name").0; + let name_si = vm.kernel_core().string_forge().intern("name").0; let name = vm .resolve_property(func, name_si) .and_then(|v| { if v.is_string() { - vm.kernel().string_forge().lookup(v.as_string_index()) + vm.kernel_core().string_forge().lookup(v.as_string_index()) } else { None } @@ -146,6 +146,6 @@ pub fn function_to_string(vm: &mut Vm, args: &[u8]) -> NativeResult { } else { format!("function {name}() {{ {body} }}") }; - let si = vm.kernel().string_forge().intern(&result).0; + let si = vm.kernel_core().string_forge().intern(&result).0; NativeResult::Ok(JsValue::string(si, 0)) } diff --git a/crates/oxide_vm/src/builtins/global.rs b/crates/oxide_vm/src/builtins/global.rs index a1b2a56..d6c2dfe 100644 --- a/crates/oxide_vm/src/builtins/global.rs +++ b/crates/oxide_vm/src/builtins/global.rs @@ -1,7 +1,7 @@ use std::sync::Arc; -use oxide_kernel::kernel::OxideKernel; +use oxide_kernel::kernel::KernelCore; -pub fn register_global_properties(_kernel: &Arc, _bump: &bumpalo::Bump) -> Result<(), String> { +pub fn register_global_properties(_kernel: &Arc, _bump: &bumpalo::Bump) -> Result<(), String> { Ok(()) } diff --git a/crates/oxide_vm/src/builtins/json.rs b/crates/oxide_vm/src/builtins/json.rs index ebb2b43..187228b 100644 --- a/crates/oxide_vm/src/builtins/json.rs +++ b/crates/oxide_vm/src/builtins/json.rs @@ -22,7 +22,7 @@ pub fn json_parse(vm: &mut Vm, args: &[u8]) -> NativeResult { } let text = { let si = val.as_string_index(); - vm.kernel().string_forge().lookup(si).unwrap_or_default() + vm.kernel_core().string_forge().lookup(si).unwrap_or_default() }; let parsed: serde_json::Value = match serde_json::from_str(&text) { @@ -46,7 +46,7 @@ fn value_to_jsvalue(vm: &mut Vm, val: &serde_json::Value) -> JsValue { } serde_json::Value::String(s) => vm.intern(s), serde_json::Value::Array(arr) => { - let array_proto = vm.kernel().builtin_world().array_proto.as_ptr() as *mut JsObject; + let array_proto = vm.session().builtin_world().array_proto.as_ptr() as *mut JsObject; let n = arr.len(); let array_obj = vm.epoch().alloc(JsObject::new_array( EMPTY_SHAPE_ID, @@ -63,12 +63,12 @@ fn value_to_jsvalue(vm: &mut Vm, val: &serde_json::Value) -> JsValue { JsValue::from_js_object(array_obj) } serde_json::Value::Object(map) => { - let object_proto = vm.kernel().builtin_world().object_proto.as_ptr() as *mut JsObject; + let object_proto = vm.session().builtin_world().object_proto.as_ptr() as *mut JsObject; let mut obj = JsObject::new_empty(EMPTY_SHAPE_ID, JsValue::from_js_object(object_proto)); for (key, val) in map { - let si = vm.kernel().string_forge().intern(key).0; + let si = vm.kernel_core().string_forge().intern(key).0; let jsv = value_to_jsvalue(vm, val); - let new_shape = vm.kernel().shape_forge().make_shape(obj.shape_id(), si); + let new_shape = vm.kernel_core().shape_forge().make_shape(obj.shape_id(), si); obj.set_shape_id(new_shape); obj.ensure_hash_props().push(jsv); } @@ -114,7 +114,7 @@ fn jsvalue_to_json(vm: &Vm, val: JsValue, visited: &mut HashSet<*const u8>, out: } } else if val.is_string() { let si = val.as_string_index(); - let s = vm.kernel().string_forge().lookup(si).unwrap_or_default(); + let s = vm.kernel_core().string_forge().lookup(si).unwrap_or_default(); stringify_string(&s, out); } else if val.is_object() { let obj_ptr = val.as_js_object_ptr(); @@ -184,7 +184,7 @@ fn stringify_object(vm: &Vm, obj: &JsObject, visited: &mut HashSet<*const u8>, o out.push(','); } first = false; - let name = vm.kernel().string_forge().lookup(si).unwrap_or_default(); + let name = vm.kernel_core().string_forge().lookup(si).unwrap_or_default(); stringify_string(&name, out); out.push(':'); jsvalue_to_json(vm, val, visited, out)?; diff --git a/crates/oxide_vm/src/builtins/map.rs b/crates/oxide_vm/src/builtins/map.rs index f7cb911..cee4604 100644 --- a/crates/oxide_vm/src/builtins/map.rs +++ b/crates/oxide_vm/src/builtins/map.rs @@ -69,7 +69,7 @@ fn new_map_inner() -> *mut indexmap::IndexMap { } fn alloc_map(vm: &mut Vm) -> *mut JsObject { - let map_proto = vm.kernel().builtin_world().map_proto.as_ptr() as *mut JsObject; + let map_proto = vm.session().builtin_world().map_proto.as_ptr() as *mut JsObject; let mut obj = JsObject::new_empty(EMPTY_SHAPE_ID, JsValue::from_js_object(map_proto)); obj.set_map(true); // SAFETY: new_map_inner() returns a valid Box pointer; stored as a JsValue diff --git a/crates/oxide_vm/src/builtins/math.rs b/crates/oxide_vm/src/builtins/math.rs index d9bdcbc..acd3840 100644 --- a/crates/oxide_vm/src/builtins/math.rs +++ b/crates/oxide_vm/src/builtins/math.rs @@ -5,7 +5,7 @@ use crate::native::NativeResult; use crate::vm::Vm; fn num(vm: &Vm, reg: u8) -> f64 { - coercion::to_number(vm.reg(reg), vm.kernel().string_forge().as_ref()) + coercion::to_number(vm.reg(reg), vm.kernel_core().string_forge().as_ref()) } fn arg1(vm: &Vm, args: &[u8]) -> f64 { diff --git a/crates/oxide_vm/src/builtins/number.rs b/crates/oxide_vm/src/builtins/number.rs index df0a849..b455929 100644 --- a/crates/oxide_vm/src/builtins/number.rs +++ b/crates/oxide_vm/src/builtins/number.rs @@ -6,7 +6,7 @@ use crate::vm::Vm; pub fn number_constructor(vm: &mut Vm, args: &[u8]) -> NativeResult { let n = if args.len() > 1 { - coercion::to_number(vm.reg(args[1]), vm.kernel().string_forge().as_ref()) + coercion::to_number(vm.reg(args[1]), vm.kernel_core().string_forge().as_ref()) } else { 0.0 }; @@ -40,7 +40,7 @@ pub fn number_is_finite(vm: &mut Vm, args: &[u8]) -> NativeResult { if val.is_double() { return NativeResult::Ok(JsValue::bool(val.as_double().is_finite())); } - let n = coercion::to_number(val, vm.kernel().string_forge().as_ref()); + let n = coercion::to_number(val, vm.kernel_core().string_forge().as_ref()); NativeResult::Ok(JsValue::bool(n.is_finite())) } @@ -48,7 +48,7 @@ pub fn number_parse_int(vm: &mut Vm, args: &[u8]) -> NativeResult { if args.len() < 2 { return NativeResult::Ok(JsValue::float(f64::NAN)); } - let sf = vm.kernel().string_forge().as_ref(); + let sf = vm.kernel_core().string_forge().as_ref(); let s = coercion::to_string(sf, vm.reg(args[1])); let s = s.trim(); @@ -90,7 +90,7 @@ pub fn number_parse_float(vm: &mut Vm, args: &[u8]) -> NativeResult { if args.len() < 2 { return NativeResult::Ok(JsValue::float(f64::NAN)); } - let sf = vm.kernel().string_forge().as_ref(); + let sf = vm.kernel_core().string_forge().as_ref(); let s = coercion::to_string(sf, vm.reg(args[1])); let s = s.trim(); @@ -105,9 +105,9 @@ pub fn number_parse_float(vm: &mut Vm, args: &[u8]) -> NativeResult { } pub fn number_to_string(vm: &mut Vm, args: &[u8]) -> NativeResult { - let n = coercion::to_number(vm.reg(args[0]), vm.kernel().string_forge().as_ref()); + let n = coercion::to_number(vm.reg(args[0]), vm.kernel_core().string_forge().as_ref()); let radix = if args.len() > 1 { - let r = coercion::to_number(vm.reg(args[1]), vm.kernel().string_forge().as_ref()) as u32; + let r = coercion::to_number(vm.reg(args[1]), vm.kernel_core().string_forge().as_ref()) as u32; r.clamp(2, 36) } else { 10u32 @@ -156,9 +156,9 @@ pub fn number_to_string(vm: &mut Vm, args: &[u8]) -> NativeResult { } pub fn number_to_fixed(vm: &mut Vm, args: &[u8]) -> NativeResult { - let n = coercion::to_number(vm.reg(args[0]), vm.kernel().string_forge().as_ref()); + let n = coercion::to_number(vm.reg(args[0]), vm.kernel_core().string_forge().as_ref()); let digits = if args.len() > 1 { - coercion::to_number(vm.reg(args[1]), vm.kernel().string_forge().as_ref()) as usize + coercion::to_number(vm.reg(args[1]), vm.kernel_core().string_forge().as_ref()) as usize } else { 0usize } @@ -170,21 +170,21 @@ pub fn number_to_fixed(vm: &mut Vm, args: &[u8]) -> NativeResult { pub fn number_is_integer(vm: &mut Vm, args: &[u8]) -> NativeResult { let val = vm.reg(if args.len() > 1 { args[1] } else { args[0] }); - let n = coercion::to_number(val, vm.kernel().string_forge().as_ref()); + let n = coercion::to_number(val, vm.kernel_core().string_forge().as_ref()); NativeResult::Ok(JsValue::bool(n.trunc() == n && n.is_finite())) } pub fn number_is_safe_integer(vm: &mut Vm, args: &[u8]) -> NativeResult { let val = vm.reg(if args.len() > 1 { args[1] } else { args[0] }); - let n = coercion::to_number(val, vm.kernel().string_forge().as_ref()); + let n = coercion::to_number(val, vm.kernel_core().string_forge().as_ref()); let safe = n.trunc() == n && n.is_finite() && n >= -9007199254740991i64 as f64 && n <= 9007199254740991i64 as f64; NativeResult::Ok(JsValue::bool(safe)) } pub fn number_to_exponential(vm: &mut Vm, args: &[u8]) -> NativeResult { - let n = coercion::to_number(vm.reg(args[0]), vm.kernel().string_forge().as_ref()); + let n = coercion::to_number(vm.reg(args[0]), vm.kernel_core().string_forge().as_ref()); let digits = if args.len() > 1 { - coercion::to_number(vm.reg(args[1]), vm.kernel().string_forge().as_ref()) as usize + coercion::to_number(vm.reg(args[1]), vm.kernel_core().string_forge().as_ref()) as usize } else { 0usize } @@ -200,9 +200,9 @@ pub fn number_to_exponential(vm: &mut Vm, args: &[u8]) -> NativeResult { } pub fn number_to_precision(vm: &mut Vm, args: &[u8]) -> NativeResult { - let n = coercion::to_number(vm.reg(args[0]), vm.kernel().string_forge().as_ref()); + let n = coercion::to_number(vm.reg(args[0]), vm.kernel_core().string_forge().as_ref()); let precision = if args.len() > 1 { - coercion::to_number(vm.reg(args[1]), vm.kernel().string_forge().as_ref()) as usize + coercion::to_number(vm.reg(args[1]), vm.kernel_core().string_forge().as_ref()) as usize } else { 0usize } diff --git a/crates/oxide_vm/src/builtins/object.rs b/crates/oxide_vm/src/builtins/object.rs index 598dd63..e008467 100644 --- a/crates/oxide_vm/src/builtins/object.rs +++ b/crates/oxide_vm/src/builtins/object.rs @@ -17,7 +17,7 @@ pub(crate) fn walk_own_keys(vm: &Vm, obj: &JsObject) -> Vec<(u32, u32)> { if id == EMPTY_SHAPE_ID { break; } - if let Some(shape) = vm.kernel().shape_forge().get_shape(id) { + if let Some(shape) = vm.kernel_core().shape_forge().get_shape(id) { cursor = shape.parent; if shape.property_name != u32::MAX { shape_ids.push(id); @@ -27,7 +27,7 @@ pub(crate) fn walk_own_keys(vm: &Vm, obj: &JsObject) -> Vec<(u32, u32)> { } } for id in shape_ids.iter().rev() { - if let Some(shape) = vm.kernel().shape_forge().get_shape(*id) { + if let Some(shape) = vm.kernel_core().shape_forge().get_shape(*id) { if shape.property_name != 0 { keys.push((shape.property_name, pos)); } @@ -61,12 +61,12 @@ pub fn object_keys(vm: &mut Vm, args: &[u8]) -> NativeResult { let keys = walk_own_keys(vm, obj); key_names = keys .iter() - .map(|(si, _offset)| vm.kernel().string_forge().lookup(*si).unwrap_or_default()) + .map(|(si, _offset)| vm.kernel_core().string_forge().lookup(*si).unwrap_or_default()) .collect(); } let n = key_names.len(); - let array_proto = vm.kernel().builtin_world().array_proto.as_ptr() as *mut JsObject; + let array_proto = vm.session().builtin_world().array_proto.as_ptr() as *mut JsObject; let arr = vm.epoch().alloc(JsObject::new_array( EMPTY_SHAPE_ID, JsValue::from_js_object(array_proto), @@ -158,15 +158,15 @@ pub fn object_define_property(vm: &mut Vm, args: &[u8]) -> NativeResult { if desc_ptr.is_null() { return NativeResult::Err(JsValue::undefined()); } - let prop_name_str = coercion::to_string(vm.kernel().string_forge().as_ref(), vm.reg(args[2])); - let si = vm.kernel().string_forge().intern(&prop_name_str).0; + let prop_name_str = coercion::to_string(vm.kernel_core().string_forge().as_ref(), vm.reg(args[2])); + let si = vm.kernel_core().string_forge().intern(&prop_name_str).0; - let value_si = vm.kernel().string_forge().intern("value").0; - let get_si = vm.kernel().string_forge().intern("get").0; - let set_si = vm.kernel().string_forge().intern("set").0; - let writable_si = vm.kernel().string_forge().intern("writable").0; - let enumerable_si = vm.kernel().string_forge().intern("enumerable").0; - let configurable_si = vm.kernel().string_forge().intern("configurable").0; + let value_si = vm.kernel_core().string_forge().intern("value").0; + let get_si = vm.kernel_core().string_forge().intern("get").0; + let set_si = vm.kernel_core().string_forge().intern("set").0; + let writable_si = vm.kernel_core().string_forge().intern("writable").0; + let enumerable_si = vm.kernel_core().string_forge().intern("enumerable").0; + let configurable_si = vm.kernel_core().string_forge().intern("configurable").0; let desc = unsafe { &*desc_ptr }; let value_field = own_field(vm, desc, value_si); @@ -174,10 +174,10 @@ pub fn object_define_property(vm: &mut Vm, args: &[u8]) -> NativeResult { let set_field = own_field(vm, desc, set_si); let writable_field = own_field(vm, desc, writable_si); let enumerable = own_field(vm, desc, enumerable_si) - .map(|v| coercion::to_boolean(v, vm.kernel().string_forge().as_ref())) + .map(|v| coercion::to_boolean(v, vm.kernel_core().string_forge().as_ref())) .unwrap_or(false); let configurable = own_field(vm, desc, configurable_si) - .map(|v| coercion::to_boolean(v, vm.kernel().string_forge().as_ref())) + .map(|v| coercion::to_boolean(v, vm.kernel_core().string_forge().as_ref())) .unwrap_or(false); let has_data = value_field.is_some() || writable_field.is_some(); @@ -208,7 +208,7 @@ pub fn object_define_property(vm: &mut Vm, args: &[u8]) -> NativeResult { } else { let value = value_field.unwrap_or(JsValue::undefined()); let writable = writable_field - .map(|v| coercion::to_boolean(v, vm.kernel().string_forge().as_ref())) + .map(|v| coercion::to_boolean(v, vm.kernel_core().string_forge().as_ref())) .unwrap_or(false); if vm .define_data_property(obj, si, value, PropAttributes::new(writable, enumerable, configurable)) @@ -232,8 +232,8 @@ pub fn object_get_own_property_descriptor(vm: &mut Vm, args: &[u8]) -> NativeRes if obj_ptr.is_null() { return NativeResult::Ok(JsValue::undefined()); } - let prop_name_str = coercion::to_string(vm.kernel().string_forge().as_ref(), vm.reg(args[2])); - let si = vm.kernel().string_forge().intern(&prop_name_str).0; + let prop_name_str = coercion::to_string(vm.kernel_core().string_forge().as_ref(), vm.reg(args[2])); + let si = vm.kernel_core().string_forge().intern(&prop_name_str).0; let (found_value, found_meta, found) = { let obj = unsafe { &*obj_ptr }; @@ -256,9 +256,9 @@ pub fn object_get_own_property_descriptor(vm: &mut Vm, args: &[u8]) -> NativeRes return NativeResult::Ok(JsValue::undefined()); } - let sf_ptr = vm.kernel().string_forge().as_ref() as *const StringForge; - let sh_ptr = vm.kernel().shape_forge().as_ref() as *const ShapeForge; - let desc_proto = vm.kernel().builtin_world().object_proto.as_ptr() as *mut JsObject; + let sf_ptr = vm.kernel_core().string_forge().as_ref() as *const StringForge; + let sh_ptr = vm.kernel_core().shape_forge().as_ref() as *const ShapeForge; + let desc_proto = vm.session().builtin_world().object_proto.as_ptr() as *mut JsObject; let desc = vm .epoch() .alloc(JsObject::new_empty(EMPTY_SHAPE_ID, JsValue::from_js_object(desc_proto))); @@ -283,7 +283,7 @@ pub fn object_get_own_property_descriptor(vm: &mut Vm, args: &[u8]) -> NativeRes } fn own_field(vm: &Vm, obj: &JsObject, prop_si: u32) -> Option { - vm.kernel() + vm.kernel_core() .shape_forge() .lookup_position(obj.shape_id(), prop_si) .and_then(|pos| { @@ -405,12 +405,12 @@ pub fn object_get_own_property_names(vm: &mut Vm, args: &[u8]) -> NativeResult { let obj = unsafe { &*obj_ptr }; let keys = walk_own_keys(vm, obj); keys.iter() - .map(|(si, _)| vm.kernel().string_forge().lookup(*si).unwrap_or_default()) + .map(|(si, _)| vm.kernel_core().string_forge().lookup(*si).unwrap_or_default()) .collect() }; let n = key_names.len(); - let array_proto = vm.kernel().builtin_world().array_proto.as_ptr() as *mut JsObject; + let array_proto = vm.session().builtin_world().array_proto.as_ptr() as *mut JsObject; let arr = vm.epoch().alloc(JsObject::new_array( EMPTY_SHAPE_ID, JsValue::from_js_object(array_proto), @@ -451,7 +451,7 @@ pub fn object_from_entries(vm: &mut Vm, args: &[u8]) -> NativeResult { } let obj_ptr = vm.epoch().alloc(JsObject::new_empty( EMPTY_SHAPE_ID, - JsValue::from_js_object(vm.kernel().builtin_world().object_proto.as_ptr() as *mut JsObject), + JsValue::from_js_object(vm.session().builtin_world().object_proto.as_ptr() as *mut JsObject), )); NativeResult::Ok(JsValue::from_js_object(obj_ptr)) } @@ -515,7 +515,7 @@ pub fn object_entries(vm: &mut Vm, args: &[u8]) -> NativeResult { let obj = unsafe { &*obj_ptr }; let keys = walk_own_keys(vm, obj); let n = keys.len(); - let array_proto = vm.kernel().builtin_world().array_proto.as_ptr() as *mut JsObject; + let array_proto = vm.session().builtin_world().array_proto.as_ptr() as *mut JsObject; let arr = vm.epoch().alloc(JsObject::new_array( EMPTY_SHAPE_ID, JsValue::from_js_object(array_proto), @@ -523,7 +523,7 @@ pub fn object_entries(vm: &mut Vm, args: &[u8]) -> NativeResult { vm.epoch().bump(), )); for (i, (si, offset)) in keys.iter().enumerate() { - let key_str = vm.kernel().string_forge().lookup(*si).unwrap_or_default(); + let key_str = vm.kernel_core().string_forge().lookup(*si).unwrap_or_default(); let key_val = vm.intern(&key_str); let val = obj.get_prop_at(*offset); let pair = vm.epoch().alloc(JsObject::new_array( @@ -550,7 +550,7 @@ pub fn object_values(vm: &mut Vm, args: &[u8]) -> NativeResult { let obj = unsafe { &*obj_ptr }; let keys = walk_own_keys(vm, obj); let n = keys.len(); - let array_proto = vm.kernel().builtin_world().array_proto.as_ptr() as *mut JsObject; + let array_proto = vm.session().builtin_world().array_proto.as_ptr() as *mut JsObject; let arr = vm.epoch().alloc(JsObject::new_array( EMPTY_SHAPE_ID, JsValue::from_js_object(array_proto), diff --git a/crates/oxide_vm/src/builtins/regexp.rs b/crates/oxide_vm/src/builtins/regexp.rs index 1a7f430..b8b3a0e 100644 --- a/crates/oxide_vm/src/builtins/regexp.rs +++ b/crates/oxide_vm/src/builtins/regexp.rs @@ -10,7 +10,7 @@ fn get_regexp_ptr(vm: &Vm, args: &[u8]) -> Result<*mut JsObject, JsValue> { let this_val = vm.reg(args[0]); if !this_val.is_object() { return Err(JsValue::string( - vm.kernel() + vm.kernel_core() .string_forge() .intern("TypeError: RegExp.prototype method called on non-object") .0, @@ -19,11 +19,11 @@ fn get_regexp_ptr(vm: &Vm, args: &[u8]) -> Result<*mut JsObject, JsValue> { } let ptr = this_val.as_js_object_ptr(); if ptr.is_null() { - return Err(JsValue::string(vm.kernel().string_forge().intern("TypeError: null object").0, 0)); + return Err(JsValue::string(vm.kernel_core().string_forge().intern("TypeError: null object").0, 0)); } if !unsafe { &*ptr }.is_regexp_obj() { return Err(JsValue::string( - vm.kernel().string_forge().intern("TypeError: RegExp.prototype method called on non-RegExp object").0, + vm.kernel_core().string_forge().intern("TypeError: RegExp.prototype method called on non-RegExp object").0, 0, )); } @@ -46,8 +46,8 @@ fn parse_flags(flags: &str) -> (bool, bool, bool) { } fn set_prop(obj: &mut JsObject, name: &str, val: JsValue, vm: &Vm) { - let si = vm.kernel().string_forge().intern(name).0; - let shape_id = vm.kernel().shape_forge().make_shape(obj.shape_id(), si); + let si = vm.kernel_core().string_forge().intern(name).0; + let shape_id = vm.kernel_core().shape_forge().make_shape(obj.shape_id(), si); obj.set_shape_id(shape_id); obj.ensure_hash_props().push(val); } @@ -74,11 +74,11 @@ pub fn regexp_constructor(vm: &mut Vm, args: &[u8]) -> NativeResult { let (pattern, flags) = if args.len() < 2 { (String::new(), String::new()) } else if args.len() < 3 { - let pat = coercion::to_string(vm.kernel().string_forge().as_ref(), vm.reg(args[1])); + let pat = coercion::to_string(vm.kernel_core().string_forge().as_ref(), vm.reg(args[1])); (pat, String::new()) } else { - let pat = coercion::to_string(vm.kernel().string_forge().as_ref(), vm.reg(args[1])); - let fl = coercion::to_string(vm.kernel().string_forge().as_ref(), vm.reg(args[2])); + let pat = coercion::to_string(vm.kernel_core().string_forge().as_ref(), vm.reg(args[1])); + let fl = coercion::to_string(vm.kernel_core().string_forge().as_ref(), vm.reg(args[2])); (pat, fl) }; @@ -86,7 +86,7 @@ pub fn regexp_constructor(vm: &mut Vm, args: &[u8]) -> NativeResult { let mut obj = JsObject::new_empty( EMPTY_SHAPE_ID, - JsValue::from_js_object(vm.kernel().builtin_world().regexp_proto.as_ptr() as *mut JsObject), + JsValue::from_js_object(vm.session().builtin_world().regexp_proto.as_ptr() as *mut JsObject), ); let compiled = regex::RegexBuilder::new(&pattern) @@ -105,7 +105,7 @@ pub fn regexp_constructor(vm: &mut Vm, args: &[u8]) -> NativeResult { } Err(e) => { let msg = format!("SyntaxError: Invalid regular expression: {}", e); - return NativeResult::Err(JsValue::string(vm.kernel().string_forge().intern(&msg).0, 0)); + return NativeResult::Err(JsValue::string(vm.kernel_core().string_forge().intern(&msg).0, 0)); } } @@ -134,7 +134,7 @@ pub fn regexp_test(vm: &mut Vm, args: &[u8]) -> NativeResult { let fn_ptr = match re.native_fn() { None => { return NativeResult::Err(JsValue::string( - vm.kernel().string_forge().intern("TypeError: invalid RegExp").0, + vm.kernel_core().string_forge().intern("TypeError: invalid RegExp").0, 0, )); } @@ -144,10 +144,10 @@ pub fn regexp_test(vm: &mut Vm, args: &[u8]) -> NativeResult { // SAFETY: fn_ptr holds a Box pointer stored by regexp_constructor. let regex = unsafe { &*(fn_ptr.as_ptr() as *const regex::Regex) }; let haystack = coercion::to_string( - vm.kernel().string_forge().as_ref(), + vm.kernel_core().string_forge().as_ref(), vm.reg(if args.len() > 1 { args[1] } else { args[0] }), ); - let last_index = coercion::to_number(get_prop(re, 0), vm.kernel().string_forge().as_ref()) as usize; + let last_index = coercion::to_number(get_prop(re, 0), vm.kernel_core().string_forge().as_ref()) as usize; let is_global = get_prop(re, 3).as_bool(); if is_global { @@ -169,7 +169,7 @@ pub fn regexp_exec(vm: &mut Vm, args: &[u8]) -> NativeResult { match re.native_fn() { None => { return NativeResult::Err(JsValue::string( - vm.kernel().string_forge().intern("TypeError: invalid RegExp").0, + vm.kernel_core().string_forge().intern("TypeError: invalid RegExp").0, 0, )); } @@ -180,13 +180,13 @@ pub fn regexp_exec(vm: &mut Vm, args: &[u8]) -> NativeResult { // SAFETY: fn_ptr holds a Box pointer stored by regexp_constructor. let regex = unsafe { &*(fn_ptr.as_ptr() as *const regex::Regex) }; let haystack = coercion::to_string( - vm.kernel().string_forge().as_ref(), + vm.kernel_core().string_forge().as_ref(), vm.reg(if args.len() > 1 { args[1] } else { args[0] }), ); let (last_index, is_global) = { let re = unsafe { &*re_ptr }; - let li = coercion::to_number(get_prop(re, 0), vm.kernel().string_forge().as_ref()) as usize; + let li = coercion::to_number(get_prop(re, 0), vm.kernel_core().string_forge().as_ref()) as usize; let g = get_prop(re, 3).as_bool(); (li, g) }; @@ -203,18 +203,18 @@ pub fn regexp_exec(vm: &mut Vm, args: &[u8]) -> NativeResult { if let Some(m) = match_result { let mut match_obj = JsObject::new_empty( EMPTY_SHAPE_ID, - JsValue::from_js_object(vm.kernel().builtin_world().array_proto.as_ptr() as *mut JsObject), + JsValue::from_js_object(vm.session().builtin_world().array_proto.as_ptr() as *mut JsObject), ); let full_match = &haystack[m.start()..m.end()]; - let full_si = vm.kernel().string_forge().intern(full_match).0; + let full_si = vm.kernel_core().string_forge().intern(full_match).0; match_obj.ensure_hash_props().push(JsValue::string(full_si, 0)); let captures = regex.captures(&haystack[m.start()..m.end()]); if let Some(caps) = &captures { for i in 1..caps.len() { let cap_str = caps.get(i).map(|cm| cm.as_str()).unwrap_or(""); - let si = vm.kernel().string_forge().intern(cap_str).0; + let si = vm.kernel_core().string_forge().intern(cap_str).0; match_obj.ensure_hash_props().push(JsValue::string(si, 0)); } } @@ -253,6 +253,6 @@ pub fn regexp_to_string(vm: &mut Vm, args: &[u8]) -> NativeResult { vm.lookup_str(val).unwrap_or_default() }; let result = format!("/{}/{}", source, flags); - let si = vm.kernel().string_forge().intern(&result).0; + let si = vm.kernel_core().string_forge().intern(&result).0; NativeResult::Ok(JsValue::string(si, 0)) } diff --git a/crates/oxide_vm/src/builtins/set.rs b/crates/oxide_vm/src/builtins/set.rs index 4e216af..92c25ee 100644 --- a/crates/oxide_vm/src/builtins/set.rs +++ b/crates/oxide_vm/src/builtins/set.rs @@ -109,7 +109,7 @@ fn new_set_inner() -> *mut indexmap::IndexSet { } fn alloc_set(vm: &mut Vm) -> *mut JsObject { - let set_proto = vm.kernel().builtin_world().set_proto.as_ptr() as *mut JsObject; + let set_proto = vm.session().builtin_world().set_proto.as_ptr() as *mut JsObject; let mut obj = JsObject::new_empty(EMPTY_SHAPE_ID, JsValue::from_js_object(set_proto)); obj.set_set(true); // SAFETY: new_set_inner() returns a valid Box pointer; stored as a JsValue diff --git a/crates/oxide_vm/src/builtins/string.rs b/crates/oxide_vm/src/builtins/string.rs index 99afb67..5cbb7e5 100644 --- a/crates/oxide_vm/src/builtins/string.rs +++ b/crates/oxide_vm/src/builtins/string.rs @@ -8,7 +8,7 @@ use crate::vm::Vm; use memchr::memchr; fn this_string(vm: &Vm, args: &[u8]) -> String { - coercion::to_string(vm.kernel().string_forge().as_ref(), vm.reg(args[0])) + coercion::to_string(vm.kernel_core().string_forge().as_ref(), vm.reg(args[0])) } pub fn string_value_of(vm: &mut Vm, args: &[u8]) -> NativeResult { @@ -32,7 +32,7 @@ pub fn string_value_of(vm: &mut Vm, args: &[u8]) -> NativeResult { } fn make_string_array(vm: &mut Vm, parts: &[String]) -> JsValue { - let proto = vm.kernel().builtin_world().array_proto.as_ptr() as *mut JsObject; + let proto = vm.session().builtin_world().array_proto.as_ptr() as *mut JsObject; let n = parts.len(); let arr = vm.epoch() @@ -48,7 +48,7 @@ fn make_string_array(vm: &mut Vm, parts: &[String]) -> JsValue { } fn as_string(vm: &Vm, val: JsValue) -> String { - coercion::to_string(vm.kernel().string_forge().as_ref(), val) + coercion::to_string(vm.kernel_core().string_forge().as_ref(), val) } fn char_len(s: &str) -> usize { @@ -89,7 +89,7 @@ fn is_regexp_obj(val: JsValue, vm: &Vm) -> bool { if proto_ptr.is_null() { return false; } - let rp = vm.kernel().builtin_world().regexp_proto.as_ptr() as *mut JsObject; + let rp = vm.session().builtin_world().regexp_proto.as_ptr() as *mut JsObject; std::ptr::eq(proto_ptr, rp) } @@ -101,7 +101,7 @@ pub fn string_index_of(vm: &mut Vm, args: &[u8]) -> NativeResult { } let search = as_string(vm, vm.reg(args[1])); let pos = if args.len() > 2 { - (coercion::to_number(vm.reg(args[2]), vm.kernel().string_forge().as_ref()) as usize).min(n) + (coercion::to_number(vm.reg(args[2]), vm.kernel_core().string_forge().as_ref()) as usize).min(n) } else { 0 }; @@ -132,7 +132,7 @@ pub fn string_includes(vm: &mut Vm, args: &[u8]) -> NativeResult { } let search = as_string(vm, vm.reg(args[1])); let pos = if args.len() > 2 { - (coercion::to_number(vm.reg(args[2]), vm.kernel().string_forge().as_ref()) as usize).min(n) + (coercion::to_number(vm.reg(args[2]), vm.kernel_core().string_forge().as_ref()) as usize).min(n) } else { 0 }; @@ -157,7 +157,7 @@ pub fn string_char_at(vm: &mut Vm, args: &[u8]) -> NativeResult { } return NativeResult::Ok(vm.intern(&take_chars(&s, 1))); } - let idx = coercion::to_number(vm.reg(args[1]), vm.kernel().string_forge().as_ref()) as i32; + let idx = coercion::to_number(vm.reg(args[1]), vm.kernel_core().string_forge().as_ref()) as i32; if idx < 0 || idx as usize >= char_len(&s) { return NativeResult::Ok(vm.intern("")); } @@ -173,7 +173,7 @@ pub fn string_char_code_at(vm: &mut Vm, args: &[u8]) -> NativeResult { } return NativeResult::Ok(JsValue::int(s.chars().next().unwrap() as i32)); } - let idx = coercion::to_number(vm.reg(args[1]), vm.kernel().string_forge().as_ref()) as i32; + let idx = coercion::to_number(vm.reg(args[1]), vm.kernel_core().string_forge().as_ref()) as i32; if idx < 0 || idx as usize >= char_len(&s) { return NativeResult::Ok(JsValue::float(f64::NAN)); } @@ -182,7 +182,7 @@ pub fn string_char_code_at(vm: &mut Vm, args: &[u8]) -> NativeResult { pub fn string_concat(vm: &mut Vm, args: &[u8]) -> NativeResult { let mut result = this_string(vm, args); - let sf = vm.kernel().string_forge().as_ref(); + let sf = vm.kernel_core().string_forge().as_ref(); for &arg_reg in args.iter().skip(1) { result.push_str(&coercion::to_string(sf, vm.reg(arg_reg))); } @@ -193,7 +193,7 @@ pub fn string_slice(vm: &mut Vm, args: &[u8]) -> NativeResult { let s = this_string(vm, args); let n = char_len(&s) as i32; let start = if args.len() > 1 { - let v = coercion::to_number(vm.reg(args[1]), vm.kernel().string_forge().as_ref()) as i32; + let v = coercion::to_number(vm.reg(args[1]), vm.kernel_core().string_forge().as_ref()) as i32; if v < 0 { (n + v).max(0) } else { @@ -203,7 +203,7 @@ pub fn string_slice(vm: &mut Vm, args: &[u8]) -> NativeResult { 0 }; let end = if args.len() > 2 { - let v = coercion::to_number(vm.reg(args[2]), vm.kernel().string_forge().as_ref()) as i32; + let v = coercion::to_number(vm.reg(args[2]), vm.kernel_core().string_forge().as_ref()) as i32; if v < 0 { (n + v).max(0) } else { @@ -222,14 +222,14 @@ pub fn string_substring(vm: &mut Vm, args: &[u8]) -> NativeResult { let s = this_string(vm, args); let n = char_len(&s) as i32; let mut start = if args.len() > 1 { - (coercion::to_number(vm.reg(args[1]), vm.kernel().string_forge().as_ref()) as i32) + (coercion::to_number(vm.reg(args[1]), vm.kernel_core().string_forge().as_ref()) as i32) .max(0) .min(n) } else { 0 }; let mut end = if args.len() > 2 { - (coercion::to_number(vm.reg(args[2]), vm.kernel().string_forge().as_ref()) as i32) + (coercion::to_number(vm.reg(args[2]), vm.kernel_core().string_forge().as_ref()) as i32) .max(0) .min(n) } else { @@ -260,7 +260,7 @@ pub fn string_trim(vm: &mut Vm, args: &[u8]) -> NativeResult { pub fn string_repeat(vm: &mut Vm, args: &[u8]) -> NativeResult { let s = this_string(vm, args); let n = if args.len() > 1 { - (coercion::to_number(vm.reg(args[1]), vm.kernel().string_forge().as_ref()) as usize).min(10000) + (coercion::to_number(vm.reg(args[1]), vm.kernel_core().string_forge().as_ref()) as usize).min(10000) } else { 1 }; @@ -271,7 +271,7 @@ pub fn string_pad_start(vm: &mut Vm, args: &[u8]) -> NativeResult { let s = this_string(vm, args); let s_len = char_len(&s); let target = if args.len() > 1 { - coercion::to_number(vm.reg(args[1]), vm.kernel().string_forge().as_ref()) as usize + coercion::to_number(vm.reg(args[1]), vm.kernel_core().string_forge().as_ref()) as usize } else { s_len }; @@ -291,7 +291,7 @@ pub fn string_pad_end(vm: &mut Vm, args: &[u8]) -> NativeResult { let s = this_string(vm, args); let s_len = char_len(&s); let target = if args.len() > 1 { - coercion::to_number(vm.reg(args[1]), vm.kernel().string_forge().as_ref()) as usize + coercion::to_number(vm.reg(args[1]), vm.kernel_core().string_forge().as_ref()) as usize } else { s_len }; @@ -315,7 +315,7 @@ pub fn string_starts_with(vm: &mut Vm, args: &[u8]) -> NativeResult { } let search = as_string(vm, vm.reg(args[1])); let pos = if args.len() > 2 { - (coercion::to_number(vm.reg(args[2]), vm.kernel().string_forge().as_ref()) as usize).min(n) + (coercion::to_number(vm.reg(args[2]), vm.kernel_core().string_forge().as_ref()) as usize).min(n) } else { 0 }; @@ -330,7 +330,7 @@ pub fn string_ends_with(vm: &mut Vm, args: &[u8]) -> NativeResult { } let search = as_string(vm, vm.reg(args[1])); let end_pos = if args.len() > 2 { - (coercion::to_number(vm.reg(args[2]), vm.kernel().string_forge().as_ref()) as usize).min(n) + (coercion::to_number(vm.reg(args[2]), vm.kernel_core().string_forge().as_ref()) as usize).min(n) } else { n }; @@ -345,7 +345,7 @@ pub fn string_split(vm: &mut Vm, args: &[u8]) -> NativeResult { } let sep_val = vm.reg(args[1]); let limit = if args.len() > 2 { - coercion::to_number(vm.reg(args[2]), vm.kernel().string_forge().as_ref()) as usize + coercion::to_number(vm.reg(args[2]), vm.kernel_core().string_forge().as_ref()) as usize } else { usize::MAX }; @@ -471,7 +471,7 @@ pub fn string_trim_end(vm: &mut Vm, args: &[u8]) -> NativeResult { pub fn string_code_point_at(vm: &mut Vm, args: &[u8]) -> NativeResult { let s = this_string(vm, args); let pos = if args.len() > 1 { - coercion::to_number(vm.reg(args[1]), vm.kernel().string_forge().as_ref()) as usize + coercion::to_number(vm.reg(args[1]), vm.kernel_core().string_forge().as_ref()) as usize } else { 0 }; diff --git a/crates/oxide_vm/src/builtins/symbol.rs b/crates/oxide_vm/src/builtins/symbol.rs index b13c85a..3be72a6 100644 --- a/crates/oxide_vm/src/builtins/symbol.rs +++ b/crates/oxide_vm/src/builtins/symbol.rs @@ -15,10 +15,10 @@ pub fn symbol_constructor(vm: &mut Vm, args: &[u8]) -> NativeResult { if proto.is_object() { let proto_ptr = proto.as_js_object_ptr(); if !proto_ptr.is_null() { - let sp = vm.kernel().builtin_world().symbol_proto.as_ptr() as *mut JsObject; + let sp = vm.session().builtin_world().symbol_proto.as_ptr() as *mut JsObject; if std::ptr::eq(proto_ptr, sp) { return NativeResult::Err(JsValue::string( - vm.kernel().string_forge().intern("TypeError: Symbol is not a constructor").0, + vm.kernel_core().string_forge().intern("TypeError: Symbol is not a constructor").0, 0, )); } @@ -28,7 +28,7 @@ pub fn symbol_constructor(vm: &mut Vm, args: &[u8]) -> NativeResult { } let description = if args.len() > 1 { - coercion::to_string(vm.kernel().string_forge().as_ref(), vm.reg(args[1])) + coercion::to_string(vm.kernel_core().string_forge().as_ref(), vm.reg(args[1])) } else { String::new() }; @@ -43,7 +43,7 @@ pub fn symbol_to_string(vm: &mut Vm, args: &[u8]) -> NativeResult { let this_val = vm.reg(args[0]); if !this_val.is_symbol() { return NativeResult::Err(JsValue::string( - vm.kernel() + vm.kernel_core() .string_forge() .intern("TypeError: Symbol.prototype.toString requires a Symbol") .0, @@ -54,6 +54,6 @@ pub fn symbol_to_string(vm: &mut Vm, args: &[u8]) -> NativeResult { let idx = this_val.as_symbol_index(); let desc = vm.symbol_descriptions.get(idx as usize).cloned().unwrap_or_default(); let result = format!("Symbol({})", desc); - let si = vm.kernel().string_forge().intern(&result).0; + let si = vm.kernel_core().string_forge().intern(&result).0; NativeResult::Ok(JsValue::string(si, 0)) } diff --git a/crates/oxide_vm/src/coercion.rs b/crates/oxide_vm/src/coercion.rs index 45920ae..4c4367f 100644 --- a/crates/oxide_vm/src/coercion.rs +++ b/crates/oxide_vm/src/coercion.rs @@ -294,11 +294,11 @@ pub fn to_object(val: JsValue, vm: &mut Vm) -> Result { return Err("TypeError: Cannot convert null or undefined to object"); } let (proto_ptr, type_tag) = if val.is_string() { - (vm.kernel().builtin_world().string_proto.as_ptr() as *mut JsObject, JsObject::OBJ_TYPE_STRING_OBJ) + (vm.session().builtin_world().string_proto.as_ptr() as *mut JsObject, JsObject::OBJ_TYPE_STRING_OBJ) } else if val.is_int() || val.is_double() { - (vm.kernel().builtin_world().number_proto.as_ptr() as *mut JsObject, JsObject::OBJ_TYPE_NUMBER_OBJ) + (vm.session().builtin_world().number_proto.as_ptr() as *mut JsObject, JsObject::OBJ_TYPE_NUMBER_OBJ) } else if val.is_bool() { - (vm.kernel().builtin_world().boolean_proto.as_ptr() as *mut JsObject, JsObject::OBJ_TYPE_BOOLEAN_OBJ) + (vm.session().builtin_world().boolean_proto.as_ptr() as *mut JsObject, JsObject::OBJ_TYPE_BOOLEAN_OBJ) } else { (&*vm.object_prototype as *const JsObject as *mut JsObject, JsObject::OBJ_TYPE_PLAIN) }; diff --git a/crates/oxide_vm/src/dispatch/arithmetic.rs b/crates/oxide_vm/src/dispatch/arithmetic.rs index d8e449b..f0f6b05 100644 --- a/crates/oxide_vm/src/dispatch/arithmetic.rs +++ b/crates/oxide_vm/src/dispatch/arithmetic.rs @@ -8,13 +8,13 @@ impl Vm { let lhs = self.regs[a]; let rhs = self.regs[b]; if lhs.is_string() || rhs.is_string() { - let ls = coercion::to_string(self.kernel.string_forge().as_ref(), lhs); - let rs = coercion::to_string(self.kernel.string_forge().as_ref(), rhs); + let ls = coercion::to_string(self.kernel_core.string_forge().as_ref(), lhs); + let rs = coercion::to_string(self.kernel_core.string_forge().as_ref(), rhs); let concat = format!("{ls}{rs}"); self.regs[rd] = self.intern(&concat); } else { - let ln = coercion::to_number(lhs, self.kernel.string_forge().as_ref()); - let rn = coercion::to_number(rhs, self.kernel.string_forge().as_ref()); + let ln = coercion::to_number(lhs, self.kernel_core.string_forge().as_ref()); + let rn = coercion::to_number(rhs, self.kernel_core.string_forge().as_ref()); self.regs[rd] = JsValue::float(ln + rn); } } diff --git a/crates/oxide_vm/src/dispatch/bitwise.rs b/crates/oxide_vm/src/dispatch/bitwise.rs index 388f410..0a59aa0 100644 --- a/crates/oxide_vm/src/dispatch/bitwise.rs +++ b/crates/oxide_vm/src/dispatch/bitwise.rs @@ -14,25 +14,25 @@ impl Vm { #[inline(always)] pub(crate) fn dispatch_bit_and(&mut self, rd: usize, a: usize, b: usize) { - let sf = self.kernel.string_forge().as_ref(); + let sf = self.kernel_core.string_forge().as_ref(); self.regs[rd] = JsValue::int(coercion::to_int32(self.regs[a], sf) & coercion::to_int32(self.regs[b], sf)); } #[inline(always)] pub(crate) fn dispatch_bit_or(&mut self, rd: usize, a: usize, b: usize) { - let sf = self.kernel.string_forge().as_ref(); + let sf = self.kernel_core.string_forge().as_ref(); self.regs[rd] = JsValue::int(coercion::to_int32(self.regs[a], sf) | coercion::to_int32(self.regs[b], sf)); } #[inline(always)] pub(crate) fn dispatch_bit_xor(&mut self, rd: usize, a: usize, b: usize) { - let sf = self.kernel.string_forge().as_ref(); + let sf = self.kernel_core.string_forge().as_ref(); self.regs[rd] = JsValue::int(coercion::to_int32(self.regs[a], sf) ^ coercion::to_int32(self.regs[b], sf)); } #[inline(always)] pub(crate) fn dispatch_shl(&mut self, rd: usize, a: usize, b: usize) { - let sf = self.kernel.string_forge().as_ref(); + let sf = self.kernel_core.string_forge().as_ref(); let lhs = coercion::to_int32(self.regs[a], sf); let shift = coercion::to_uint32(self.regs[b], sf) & 0x1F; self.regs[rd] = JsValue::int(lhs.wrapping_shl(shift)); @@ -40,7 +40,7 @@ impl Vm { #[inline(always)] pub(crate) fn dispatch_shr(&mut self, rd: usize, a: usize, b: usize) { - let sf = self.kernel.string_forge().as_ref(); + let sf = self.kernel_core.string_forge().as_ref(); let lhs = coercion::to_int32(self.regs[a], sf); let shift = coercion::to_uint32(self.regs[b], sf) & 0x1F; self.regs[rd] = JsValue::int(lhs >> shift); @@ -48,7 +48,7 @@ impl Vm { #[inline(always)] pub(crate) fn dispatch_ushr(&mut self, rd: usize, a: usize, b: usize) { - let sf = self.kernel.string_forge().as_ref(); + let sf = self.kernel_core.string_forge().as_ref(); let lhs = coercion::to_uint32(self.regs[a], sf); let shift = coercion::to_uint32(self.regs[b], sf) & 0x1F; self.write_ushr_result(rd, lhs >> shift); @@ -56,31 +56,31 @@ impl Vm { #[inline(always)] pub(crate) fn dispatch_bit_not(&mut self, rd: usize, a: usize) { - let sf = self.kernel.string_forge().as_ref(); + let sf = self.kernel_core.string_forge().as_ref(); self.regs[rd] = JsValue::int(!coercion::to_int32(self.regs[a], sf)); } #[inline(always)] pub(crate) fn dispatch_compound_bit_and(&mut self, rd: usize, a: usize) { - let sf = self.kernel.string_forge().as_ref(); + let sf = self.kernel_core.string_forge().as_ref(); self.regs[rd] = JsValue::int(coercion::to_int32(self.regs[rd], sf) & coercion::to_int32(self.regs[a], sf)); } #[inline(always)] pub(crate) fn dispatch_compound_bit_or(&mut self, rd: usize, a: usize) { - let sf = self.kernel.string_forge().as_ref(); + let sf = self.kernel_core.string_forge().as_ref(); self.regs[rd] = JsValue::int(coercion::to_int32(self.regs[rd], sf) | coercion::to_int32(self.regs[a], sf)); } #[inline(always)] pub(crate) fn dispatch_compound_bit_xor(&mut self, rd: usize, a: usize) { - let sf = self.kernel.string_forge().as_ref(); + let sf = self.kernel_core.string_forge().as_ref(); self.regs[rd] = JsValue::int(coercion::to_int32(self.regs[rd], sf) ^ coercion::to_int32(self.regs[a], sf)); } #[inline(always)] pub(crate) fn dispatch_compound_shl(&mut self, rd: usize, a: usize) { - let sf = self.kernel.string_forge().as_ref(); + let sf = self.kernel_core.string_forge().as_ref(); let lhs = coercion::to_int32(self.regs[rd], sf); let shift = coercion::to_uint32(self.regs[a], sf) & 0x1F; self.regs[rd] = JsValue::int(lhs.wrapping_shl(shift)); @@ -88,7 +88,7 @@ impl Vm { #[inline(always)] pub(crate) fn dispatch_compound_shr(&mut self, rd: usize, a: usize) { - let sf = self.kernel.string_forge().as_ref(); + let sf = self.kernel_core.string_forge().as_ref(); let lhs = coercion::to_int32(self.regs[rd], sf); let shift = coercion::to_uint32(self.regs[a], sf) & 0x1F; self.regs[rd] = JsValue::int(lhs >> shift); @@ -96,7 +96,7 @@ impl Vm { #[inline(always)] pub(crate) fn dispatch_compound_ushr(&mut self, rd: usize, a: usize) { - let sf = self.kernel.string_forge().as_ref(); + let sf = self.kernel_core.string_forge().as_ref(); let lhs = coercion::to_uint32(self.regs[rd], sf); let shift = coercion::to_uint32(self.regs[a], sf) & 0x1F; self.write_ushr_result(rd, lhs >> shift); diff --git a/crates/oxide_vm/src/dispatch/call.rs b/crates/oxide_vm/src/dispatch/call.rs index 73e32b9..ca6cad8 100644 --- a/crates/oxide_vm/src/dispatch/call.rs +++ b/crates/oxide_vm/src/dispatch/call.rs @@ -20,7 +20,7 @@ impl Vm { pub(crate) fn dispatch_native_call( &mut self, obj: &JsObject, callee: JsValue, this_reg: u8, first_arg_reg: u8, arg_count: usize, ) -> Result<(), String> { - if self.native_call_depth >= self.kernel.config.max_call_depth { + if self.native_call_depth >= self.kernel_core.config.max_call_depth { return Err("RangeError: Maximum call stack size exceeded".into()); } let (args_buf, len) = Self::build_native_args(first_arg_reg, arg_count, this_reg); @@ -45,7 +45,7 @@ impl Vm { (err_val, self.thrown_error_kind(err_val)) } else { let msg = if err_val.is_string() { - self.kernel() + self.kernel_core .string_forge() .lookup(err_val.as_string_index()) .unwrap_or_else(|| format!("{err_val}")) diff --git a/crates/oxide_vm/src/dispatch/comparison.rs b/crates/oxide_vm/src/dispatch/comparison.rs index 7b19ac2..c958739 100644 --- a/crates/oxide_vm/src/dispatch/comparison.rs +++ b/crates/oxide_vm/src/dispatch/comparison.rs @@ -5,37 +5,37 @@ use oxide_types::value::JsValue; impl Vm { #[inline(always)] pub(crate) fn dispatch_eq(&mut self, rd: usize, a: usize, b: usize) { - let eq = coercion::abstract_eq(self.regs[a], self.regs[b], self.kernel.string_forge().as_ref()); + let eq = coercion::abstract_eq(self.regs[a], self.regs[b], self.kernel_core.string_forge().as_ref()); self.regs[rd] = JsValue::bool(eq); } #[inline(always)] pub(crate) fn dispatch_neq(&mut self, rd: usize, a: usize, b: usize) { - let ne = !coercion::abstract_eq(self.regs[a], self.regs[b], self.kernel.string_forge().as_ref()); + let ne = !coercion::abstract_eq(self.regs[a], self.regs[b], self.kernel_core.string_forge().as_ref()); self.regs[rd] = JsValue::bool(ne); } #[inline(always)] pub(crate) fn dispatch_lt(&mut self, rd: usize, a: usize, b: usize) { - let rel = coercion::relational_compare(self.kernel.string_forge().as_ref(), self.regs[a], self.regs[b]); + let rel = coercion::relational_compare(self.kernel_core.string_forge().as_ref(), self.regs[a], self.regs[b]); self.regs[rd] = JsValue::bool(rel.unwrap_or(false)); } #[inline(always)] pub(crate) fn dispatch_gt(&mut self, rd: usize, a: usize, b: usize) { - let rel = coercion::relational_compare(self.kernel.string_forge().as_ref(), self.regs[b], self.regs[a]); + let rel = coercion::relational_compare(self.kernel_core.string_forge().as_ref(), self.regs[b], self.regs[a]); self.regs[rd] = JsValue::bool(rel.unwrap_or(false)); } #[inline(always)] pub(crate) fn dispatch_lte(&mut self, rd: usize, a: usize, b: usize) { - let rel = coercion::relational_compare(self.kernel.string_forge().as_ref(), self.regs[b], self.regs[a]); + let rel = coercion::relational_compare(self.kernel_core.string_forge().as_ref(), self.regs[b], self.regs[a]); self.regs[rd] = JsValue::bool(!rel.unwrap_or(true)); } #[inline(always)] pub(crate) fn dispatch_gte(&mut self, rd: usize, a: usize, b: usize) { - let rel = coercion::relational_compare(self.kernel.string_forge().as_ref(), self.regs[a], self.regs[b]); + let rel = coercion::relational_compare(self.kernel_core.string_forge().as_ref(), self.regs[a], self.regs[b]); self.regs[rd] = JsValue::bool(!rel.unwrap_or(true)); } diff --git a/crates/oxide_vm/src/dispatch/control_flow.rs b/crates/oxide_vm/src/dispatch/control_flow.rs index 6610384..90ecad6 100644 --- a/crates/oxide_vm/src/dispatch/control_flow.rs +++ b/crates/oxide_vm/src/dispatch/control_flow.rs @@ -6,7 +6,7 @@ impl Vm { #[inline(always)] pub(crate) fn dispatch_and(&mut self, rd: usize, a: usize, b: usize) { let val = self.regs[a]; - if coercion::to_boolean(val, self.kernel.string_forge().as_ref()) { + if coercion::to_boolean(val, self.kernel_core.string_forge().as_ref()) { self.regs[rd] = self.regs[b]; } else { self.regs[rd] = val; @@ -16,7 +16,7 @@ impl Vm { #[inline(always)] pub(crate) fn dispatch_or(&mut self, rd: usize, a: usize, b: usize) { let val = self.regs[a]; - if coercion::to_boolean(val, self.kernel.string_forge().as_ref()) { + if coercion::to_boolean(val, self.kernel_core.string_forge().as_ref()) { self.regs[rd] = val; } else { self.regs[rd] = self.regs[b]; @@ -25,7 +25,7 @@ impl Vm { #[inline(always)] pub(crate) fn dispatch_not(&mut self, rd: usize, a: usize) { - let b = !coercion::to_boolean(self.regs[a], self.kernel.string_forge().as_ref()); + let b = !coercion::to_boolean(self.regs[a], self.kernel_core.string_forge().as_ref()); self.regs[rd] = JsValue::bool(b); } } diff --git a/crates/oxide_vm/src/dispatch/member.rs b/crates/oxide_vm/src/dispatch/member.rs index de901ed..02d77ed 100644 --- a/crates/oxide_vm/src/dispatch/member.rs +++ b/crates/oxide_vm/src/dispatch/member.rs @@ -47,7 +47,7 @@ impl Vm { let receiver = self.regs[rd]; let obj = unsafe { &mut *obj_ptr }; let prop_val = self.read_member_prop(obj, prop_name_si, receiver)?; - let n = coercion::to_number(prop_val, self.kernel.string_forge().as_ref()); + let n = coercion::to_number(prop_val, self.kernel_core.string_forge().as_ref()); let new_val = JsValue::float(n + 1.0); self.set_member_prop(obj, prop_name_si, new_val, receiver)?; self.regs[a] = new_val; @@ -61,7 +61,7 @@ impl Vm { let receiver = self.regs[rd]; let obj = unsafe { &mut *obj_ptr }; let prop_val = self.read_member_prop(obj, prop_name_si, receiver)?; - let n = coercion::to_number(prop_val, self.kernel.string_forge().as_ref()); + let n = coercion::to_number(prop_val, self.kernel_core.string_forge().as_ref()); let new_val = JsValue::float(n - 1.0); self.set_member_prop(obj, prop_name_si, new_val, receiver)?; self.regs[a] = new_val; @@ -76,7 +76,7 @@ impl Vm { let obj = unsafe { &mut *obj_ptr }; let prop_name_si = self.property_key_si(self.regs[a]); let prop_val = self.ordinary_get(obj, prop_name_si, receiver)?; - let n = coercion::to_number(prop_val, self.kernel.string_forge().as_ref()); + let n = coercion::to_number(prop_val, self.kernel_core.string_forge().as_ref()); let new_val = JsValue::float(n + 1.0); self.ordinary_set(obj, prop_name_si, new_val, receiver)?; self.regs[b] = new_val; @@ -91,7 +91,7 @@ impl Vm { let obj = unsafe { &mut *obj_ptr }; let prop_name_si = self.property_key_si(self.regs[a]); let prop_val = self.ordinary_get(obj, prop_name_si, receiver)?; - let n = coercion::to_number(prop_val, self.kernel.string_forge().as_ref()); + let n = coercion::to_number(prop_val, self.kernel_core.string_forge().as_ref()); let new_val = JsValue::float(n - 1.0); self.ordinary_set(obj, prop_name_si, new_val, receiver)?; self.regs[b] = new_val; @@ -107,12 +107,12 @@ impl Vm { let prop_val = self.read_member_prop(obj, prop_name_si, receiver)?; let rhs = self.regs[a]; let new_val = if prop_val.is_string() || rhs.is_string() { - let ls = coercion::to_string(self.kernel.string_forge().as_ref(), prop_val); - let rs = coercion::to_string(self.kernel.string_forge().as_ref(), rhs); + let ls = coercion::to_string(self.kernel_core.string_forge().as_ref(), prop_val); + let rs = coercion::to_string(self.kernel_core.string_forge().as_ref(), rhs); self.intern(&format!("{ls}{rs}")) } else { - let ln = coercion::to_number(prop_val, self.kernel.string_forge().as_ref()); - let rn = coercion::to_number(rhs, self.kernel.string_forge().as_ref()); + let ln = coercion::to_number(prop_val, self.kernel_core.string_forge().as_ref()); + let rn = coercion::to_number(rhs, self.kernel_core.string_forge().as_ref()); JsValue::float(ln + rn) }; self.set_member_prop(obj, prop_name_si, new_val, receiver)?; @@ -132,8 +132,8 @@ impl Vm { let receiver = self.regs[rd]; let obj = unsafe { &mut *obj_ptr }; let prop_val = self.read_member_prop(obj, prop_name_si, receiver)?; - let ln = coercion::to_number(prop_val, self.kernel.string_forge().as_ref()); - let rn = coercion::to_number(self.regs[a], self.kernel.string_forge().as_ref()); + let ln = coercion::to_number(prop_val, self.kernel_core.string_forge().as_ref()); + let rn = coercion::to_number(self.regs[a], self.kernel_core.string_forge().as_ref()); let new_val = JsValue::float(op(ln, rn)); self.regs[a] = new_val; self.set_member_prop(obj, prop_name_si, new_val, receiver)?; diff --git a/crates/oxide_vm/src/dispatch/property.rs b/crates/oxide_vm/src/dispatch/property.rs index 1bb0aaa..79661b7 100644 --- a/crates/oxide_vm/src/dispatch/property.rs +++ b/crates/oxide_vm/src/dispatch/property.rs @@ -47,7 +47,7 @@ impl Vm { let obj_ptr = val.as_object_ptr() as *mut JsObject; if obj_ptr.is_null() { if val.is_string() { - let proto_ptr = self.kernel.builtin_world().string_proto.as_ptr() as *mut JsObject; + let proto_ptr = self.session.builtin_world().string_proto.as_ptr() as *mut JsObject; let proto = unsafe { &*proto_ptr }; let prop_name_si = self.property_key_si(self.regs[b]); let resolved = self.ordinary_get(proto, prop_name_si, val)?; @@ -58,7 +58,7 @@ impl Vm { } } if val.is_int() || val.is_double() { - let proto_ptr = self.kernel.builtin_world().number_proto.as_ptr() as *mut JsObject; + let proto_ptr = self.session.builtin_world().number_proto.as_ptr() as *mut JsObject; let proto = unsafe { &*proto_ptr }; let prop_name_si = self.property_key_si(self.regs[b]); let resolved = self.ordinary_get(proto, prop_name_si, val)?; @@ -96,7 +96,7 @@ impl Vm { if let Some(value) = ic_get_hit(obj, cached_shape_id, cached_slot) { self.regs[a] = value; ic_trace!("IC_GET hit shape={} slot={}", cached_shape_id, cached_slot); - } else if let Some(template) = self.kernel.prop_forge().get_template(obj.shape_id()) { + } else if let Some(template) = self.kernel_core.prop_forge().get_template(obj.shape_id()) { prop_cache_miss(); if template.prop_name == prop_name_si { if template.position < obj.prop_vec_len() as u32 { @@ -120,7 +120,7 @@ impl Vm { prop_cache_miss(); ic_debug!("IC_GET miss shape={} prop={}", obj.shape_id(), prop_name_si); let resolved = self.ordinary_get(obj, prop_name_si, val)?; - if let Some(pos) = self.kernel.shape_forge().lookup_position(obj.shape_id(), prop_name_si) { + if let Some(pos) = self.kernel_core.shape_forge().lookup_position(obj.shape_id(), prop_name_si) { self.write_ic_back(obj.shape_id(), pos); } self.regs[a] = resolved; @@ -135,7 +135,7 @@ impl Vm { }; let prop_name_si = self.property_key_si(self.regs[b]); - if self.kernel.string_forge().lookup(prop_name_si).as_deref() == Some("__proto__") { + if self.kernel_core.string_forge().lookup(prop_name_si).as_deref() == Some("__proto__") { let obj = unsafe { &mut *obj_ptr }; if self.is_object_prototype(obj_ptr) && !self.regs[a].is_null() { self.raise_type_error("Object.prototype.__proto__ is immutable")?; @@ -163,7 +163,7 @@ impl Vm { if ic_set_hit(obj, cached_shape_id, cached_slot, value) { ic_trace!("IC_SET hit shape={} slot={}", cached_shape_id, cached_slot); - } else if let Some(pos) = self.kernel.shape_forge().lookup_position(obj.shape_id(), prop_name_si) { + } else if let Some(pos) = self.kernel_core.shape_forge().lookup_position(obj.shape_id(), prop_name_si) { prop_cache_miss(); obj.set_prop_at(pos, value); self.write_ic_back(obj.shape_id(), pos); @@ -173,10 +173,10 @@ impl Vm { let old_shape = obj.shape_id(); self.ordinary_set_dispatch(obj, prop_name_si, value, receiver)?; if old_shape != obj.shape_id() { - if let Some(pos) = self.kernel.shape_forge().lookup_position(obj.shape_id(), prop_name_si) { + if let Some(pos) = self.kernel_core.shape_forge().lookup_position(obj.shape_id(), prop_name_si) { self.write_ic_back(obj.shape_id(), pos); ic_debug!("IC_SET write-back shape={} slot={}", obj.shape_id(), pos); - self.kernel.prop_forge().upsert( + self.kernel_core.prop_forge().upsert( obj.shape_id(), PropTemplate { shape_id: obj.shape_id(), @@ -211,7 +211,7 @@ impl Vm { }; let obj = unsafe { &mut *obj_ptr }; let prop_name_si = self.property_key_si(self.regs[b]); - if self.kernel.string_forge().lookup(prop_name_si).as_deref() == Some("__proto__") { + if self.kernel_core.string_forge().lookup(prop_name_si).as_deref() == Some("__proto__") { if self.is_object_prototype(obj_ptr) && !self.regs[a].is_null() { self.raise_type_error("Object.prototype.__proto__ is immutable")?; return Ok(()); @@ -242,7 +242,7 @@ impl Vm { }; let obj = unsafe { &mut *obj_ptr }; let prop_name_si = self.property_key_si(self.regs[a]); - if self.kernel.string_forge().lookup(prop_name_si).as_deref() == Some("__proto__") { + if self.kernel_core.string_forge().lookup(prop_name_si).as_deref() == Some("__proto__") { if self.is_object_prototype(obj_ptr) && !self.regs[b].is_null() { self.raise_type_error("Object.prototype.__proto__ is immutable")?; return Ok(()); diff --git a/crates/oxide_vm/src/vm.rs b/crates/oxide_vm/src/vm.rs index 2ac48ef..4122966 100644 --- a/crates/oxide_vm/src/vm.rs +++ b/crates/oxide_vm/src/vm.rs @@ -9,7 +9,7 @@ use smallvec::SmallVec; pub use crate::bindings::init_kernel_builtins; use crate::coercion; use crate::native::{NativeFn, NativeResult}; -use oxide_kernel::kernel::OxideKernel; +use oxide_kernel::kernel::{KernelCore, KernelSession}; use oxide_kernel::shape_forge::EMPTY_SHAPE_ID; use oxide_types::error::{JsError, JsErrorKind}; use oxide_types::mem::{Epoch, P}; @@ -62,16 +62,16 @@ macro_rules! throw_err { macro_rules! binary_arith { ($self:ident, $a:expr, $b:expr, $rd:expr, $op:tt) => {{ - let l = coercion::to_number($self.regs[$a], $self.kernel.string_forge().as_ref()); - let r = coercion::to_number($self.regs[$b], $self.kernel.string_forge().as_ref()); + let l = coercion::to_number($self.regs[$a], $self.kernel_core.string_forge().as_ref()); + let r = coercion::to_number($self.regs[$b], $self.kernel_core.string_forge().as_ref()); $self.regs[$rd] = JsValue::float(l $op r); }} } macro_rules! compound_arith { ($self:ident, $rd:expr, $a:expr, $op:tt) => {{ - let l = coercion::to_number($self.regs[$rd], $self.kernel.string_forge().as_ref()); - let r = coercion::to_number($self.regs[$a], $self.kernel.string_forge().as_ref()); + let l = coercion::to_number($self.regs[$rd], $self.kernel_core.string_forge().as_ref()); + let r = coercion::to_number($self.regs[$a], $self.kernel_core.string_forge().as_ref()); $self.regs[$rd] = JsValue::float(l $op r); }} } @@ -97,6 +97,8 @@ pub struct CallFrame { pub continuation: FrameContinuation, } + + pub struct ForInIter<'bump> { pub keys: bumpalo::collections::Vec<'bump, JsValue>, pub index: usize, @@ -135,7 +137,8 @@ pub struct Vm { pub(crate) constants: Vec, pub(crate) frames: SmallVec<[CallFrame; 16]>, pub for_in_iters: Vec<*mut ForInIter<'static>>, - pub(crate) kernel: Arc, + pub(crate) kernel_core: Arc, + pub(crate) session: KernelSession, pub(crate) interned_strings: Vec, pub epoch: Epoch, pub object_prototype: P, @@ -216,12 +219,16 @@ impl Vm { (self.math_rng_state >> 33) as f64 / (1u64 << 31) as f64 } - pub fn kernel(&self) -> &Arc { - &self.kernel + pub fn kernel_core(&self) -> &Arc { + &self.kernel_core + } + + pub fn session(&self) -> &KernelSession { + &self.session } pub(crate) fn is_object_prototype(&self, ptr: *const JsObject) -> bool { - let proto_ptr = self.kernel.builtin_world().object_proto.as_ptr(); + let proto_ptr = self.session.builtin_world().object_proto.as_ptr(); std::ptr::eq(ptr, proto_ptr) } @@ -249,14 +256,14 @@ impl Vm { if !val.is_string() { return None; } - self.kernel.string_forge().lookup(val.as_string_index()) + self.kernel_core.string_forge().lookup(val.as_string_index()) } pub(crate) fn thrown_error_kind(&self, val: JsValue) -> &'static str { if !val.is_object() { return "Error"; } - let name_si = self.kernel.string_forge().intern("name").0; + let name_si = self.kernel_core.string_forge().intern("name").0; let obj = unsafe { &*val.as_js_object_ptr() }; let Some(name_val) = self.resolve_property(obj, name_si) else { return "Error"; @@ -280,16 +287,16 @@ impl Vm { if val.is_string() { return val.as_string_index(); } - let key = coercion::to_string(self.kernel.string_forge().as_ref(), val); - self.kernel.string_forge().intern(&key).0 + let key = coercion::to_string(self.kernel_core.string_forge().as_ref(), val); + self.kernel_core.string_forge().intern(&key).0 } pub(crate) fn resolve_property(&self, obj: &JsObject, prop_name_si: u32) -> Option { - let length_si = self.kernel.string_forge().intern("length").0; + let length_si = self.kernel_core.string_forge().intern("length").0; if obj.is_array() && prop_name_si == length_si { return Some(JsValue::int(obj.prop_count() as i32)); } - if let Some(pos) = self.kernel.shape_forge().lookup_position(obj.shape_id(), prop_name_si) { + if let Some(pos) = self.kernel_core.shape_forge().lookup_position(obj.shape_id(), prop_name_si) { let val = obj.get_prop_at(pos); if !val.is_undefined() || obj.prop_vec_len() > pos as usize { return Some(val); @@ -298,7 +305,7 @@ impl Vm { let mut proto = obj.proto(); while proto.is_object() { let proto_obj = unsafe { &*proto.as_js_object_ptr() }; - if let Some(pos) = self.kernel.shape_forge().lookup_position(proto_obj.shape_id(), prop_name_si) { + if let Some(pos) = self.kernel_core.shape_forge().lookup_position(proto_obj.shape_id(), prop_name_si) { let val = proto_obj.get_prop_at(pos); if !val.is_undefined() || proto_obj.prop_vec_len() > pos as usize { return Some(val); @@ -310,11 +317,11 @@ impl Vm { } pub(crate) fn get_own_property_slot(&self, obj: &JsObject, prop_name_si: u32) -> Option { - let length_si = self.kernel.string_forge().intern("length").0; + let length_si = self.kernel_core.string_forge().intern("length").0; if obj.is_array() && prop_name_si == length_si { return None; } - self.kernel + self.kernel_core .shape_forge() .lookup_position(obj.shape_id(), prop_name_si) .and_then(|pos| { @@ -339,7 +346,7 @@ impl Vm { } if let Some(native_fn) = callee_obj.native_fn() { - if self.native_call_depth >= self.kernel.config.max_call_depth { + if self.native_call_depth >= self.kernel_core.config.max_call_depth { return Err("RangeError: Maximum call stack size exceeded".into()); } let saved_regs = self.regs; @@ -398,7 +405,7 @@ impl Vm { self.sub_modules.len() )); } - if self.frames.len() >= self.kernel.config.max_call_depth { + if self.frames.len() >= self.kernel_core.config.max_call_depth { return Err("RangeError: Maximum call stack size exceeded".into()); } @@ -426,7 +433,7 @@ impl Vm { let function_name = self.sub_modules[sub_idx] .function_name .as_deref() - .map(|name| self.kernel.string_forge().intern(name).0) + .map(|name| self.kernel_core.string_forge().intern(name).0) .unwrap_or(0); self.frames.push(CallFrame { @@ -446,9 +453,9 @@ impl Vm { self.bytecode = sub_bytecode; self.constants = converted_sub_constants; for (name, reg) in &self.sub_modules[sub_idx].builtin_reg_map.clone() { - let si = self.kernel.string_forge().intern(name.as_str()).0; - let global = self.kernel.global_object(); - if let Some(pos) = self.kernel.shape_forge().lookup_position(global.shape_id(), si) { + let si = self.kernel_core.string_forge().intern(name.as_str()).0; + let global = self.session.global_object(); + if let Some(pos) = self.kernel_core.shape_forge().lookup_position(global.shape_id(), si) { self.regs[*reg as usize] = global.get_prop_at(pos); } } @@ -462,7 +469,7 @@ impl Vm { let mut steps: u64 = 0; loop { steps += 1; - if let Some(max_steps) = self.kernel.config.max_steps { + if let Some(max_steps) = self.kernel_core.config.max_steps { if steps > max_steps { return Err(format!("VM step limit exceeded at pc={}", self.pc)); } @@ -508,7 +515,7 @@ impl Vm { } OpCode::NEG => { - let v = coercion::to_number(self.regs[a], self.kernel.string_forge().as_ref()); + let v = coercion::to_number(self.regs[a], self.kernel_core.string_forge().as_ref()); self.regs[rd] = JsValue::float(-v); } @@ -573,7 +580,7 @@ impl Vm { } OpCode::UNARY_PLUS => { - let v = coercion::to_number(self.regs[a], self.kernel.string_forge().as_ref()); + let v = coercion::to_number(self.regs[a], self.kernel_core.string_forge().as_ref()); self.regs[rd] = JsValue::float(v); } @@ -583,7 +590,7 @@ impl Vm { } OpCode::JMP_IF_FALSE => { - let cond = coercion::to_boolean(self.regs[rd], self.kernel.string_forge().as_ref()); + let cond = coercion::to_boolean(self.regs[rd], self.kernel_core.string_forge().as_ref()); if !cond { let offset = opcode::offset16(instr) as isize; self.pc = ((self.pc as isize) + offset - 1) as usize; @@ -591,7 +598,7 @@ impl Vm { } OpCode::JMP_IF_TRUE => { - let cond = coercion::to_boolean(self.regs[rd], self.kernel.string_forge().as_ref()); + let cond = coercion::to_boolean(self.regs[rd], self.kernel_core.string_forge().as_ref()); if cond { let offset = opcode::offset16(instr) as isize; self.pc = ((self.pc as isize) + offset - 1) as usize; @@ -708,7 +715,7 @@ impl Vm { self.sub_modules.len() )); } - if self.frames.len() >= self.kernel.config.max_call_depth { + if self.frames.len() >= self.kernel_core.config.max_call_depth { return Err("RangeError: Maximum call stack size exceeded".into()); } @@ -737,7 +744,7 @@ impl Vm { function_name: self.sub_modules[sub_idx] .function_name .as_deref() - .map(|name| self.kernel.string_forge().intern(name).0) + .map(|name| self.kernel_core.string_forge().intern(name).0) .unwrap_or(0), caller_reg_limit, saved_regs, @@ -753,9 +760,9 @@ impl Vm { self.bytecode = sub_bytecode; self.constants = converted_sub_constants; for (name, reg) in &self.sub_modules[sub_idx].builtin_reg_map { - let si = self.kernel.string_forge().intern(name.as_str()).0; - let global = self.kernel.global_object(); - if let Some(pos) = self.kernel.shape_forge().lookup_position(global.shape_id(), si) { + let si = self.kernel_core.string_forge().intern(name.as_str()).0; + let global = self.session.global_object(); + if let Some(pos) = self.kernel_core.shape_forge().lookup_position(global.shape_id(), si) { self.regs[*reg as usize] = global.get_prop_at(pos); } } @@ -836,7 +843,7 @@ impl Vm { } OpCode::NEW_ARRAY => { - let proto_ptr = self.kernel.builtin_world().array_proto.as_ptr() as *mut JsObject; + let proto_ptr = self.session.builtin_world().array_proto.as_ptr() as *mut JsObject; let n = opcode::imm16(instr) as usize; let bump = self.epoch.bump(); let obj = self.epoch.alloc(JsObject::new_array( @@ -852,13 +859,13 @@ impl Vm { let lhs = self.regs[rd]; let rhs = self.regs[a]; if lhs.is_string() || rhs.is_string() { - let ls = coercion::to_string(self.kernel.string_forge().as_ref(), lhs); - let rs = coercion::to_string(self.kernel.string_forge().as_ref(), rhs); + let ls = coercion::to_string(self.kernel_core.string_forge().as_ref(), lhs); + let rs = coercion::to_string(self.kernel_core.string_forge().as_ref(), rhs); let concat = format!("{ls}{rs}"); self.regs[rd] = self.intern(&concat); } else { - let ln = coercion::to_number(lhs, self.kernel.string_forge().as_ref()); - let rn = coercion::to_number(rhs, self.kernel.string_forge().as_ref()); + let ln = coercion::to_number(lhs, self.kernel_core.string_forge().as_ref()); + let rn = coercion::to_number(rhs, self.kernel_core.string_forge().as_ref()); self.regs[rd] = JsValue::float(ln + rn); } } @@ -880,8 +887,8 @@ impl Vm { } OpCode::COMPOUND_EXP => { - let l = coercion::to_number(self.regs[rd], self.kernel.string_forge().as_ref()); - let r = coercion::to_number(self.regs[a], self.kernel.string_forge().as_ref()); + let l = coercion::to_number(self.regs[rd], self.kernel_core.string_forge().as_ref()); + let r = coercion::to_number(self.regs[a], self.kernel_core.string_forge().as_ref()); self.regs[rd] = JsValue::float(l.powf(r)); } @@ -954,27 +961,27 @@ impl Vm { } OpCode::INC_PRE => { - let n = coercion::to_number(self.regs[rd], self.kernel.string_forge().as_ref()); + let n = coercion::to_number(self.regs[rd], self.kernel_core.string_forge().as_ref()); let result = JsValue::float(n + 1.0); self.regs[rd] = result; self.regs[a] = result; } OpCode::INC_POST => { - let n = coercion::to_number(self.regs[rd], self.kernel.string_forge().as_ref()); + let n = coercion::to_number(self.regs[rd], self.kernel_core.string_forge().as_ref()); self.regs[a] = JsValue::float(n); self.regs[rd] = JsValue::float(n + 1.0); } OpCode::DEC_PRE => { - let n = coercion::to_number(self.regs[rd], self.kernel.string_forge().as_ref()); + let n = coercion::to_number(self.regs[rd], self.kernel_core.string_forge().as_ref()); let result = JsValue::float(n - 1.0); self.regs[rd] = result; self.regs[a] = result; } OpCode::DEC_POST => { - let n = coercion::to_number(self.regs[rd], self.kernel.string_forge().as_ref()); + let n = coercion::to_number(self.regs[rd], self.kernel_core.string_forge().as_ref()); self.regs[a] = JsValue::float(n); self.regs[rd] = JsValue::float(n - 1.0); } @@ -1079,7 +1086,7 @@ mod tests { if !this_val.is_object() { return NativeResult::Ok(JsValue::undefined()); } - let marker_si = vm.kernel.string_forge().intern("marker").0; + let marker_si = vm.kernel_core.string_forge().intern("marker").0; let obj = unsafe { &*this_val.as_js_object_ptr() }; NativeResult::Ok(vm.resolve_property(obj, marker_si).unwrap_or(JsValue::undefined())) } @@ -1090,14 +1097,14 @@ mod tests { if !this_val.is_object() { return NativeResult::Ok(JsValue::undefined()); } - let marker_si = vm.kernel.string_forge().intern("marker").0; + let marker_si = vm.kernel_core.string_forge().intern("marker").0; let obj = unsafe { &mut *this_val.as_js_object_ptr() }; vm.set_or_create_prop_value(obj, marker_si, value); NativeResult::Ok(JsValue::undefined()) } fn native_function(vm: &mut Vm, f: crate::native::NativeFn) -> JsValue { - let proto = vm.kernel.builtin_world().function_proto.as_ptr() as *mut JsObject; + let proto = vm.session.builtin_world().function_proto.as_ptr() as *mut JsObject; let mut obj = JsObject::new_empty(oxide_kernel::shape_forge::EMPTY_SHAPE_ID, JsValue::from_js_object(proto)); obj.set_function(true); // SAFETY: f is a NativeFn fn-item; valid to store as NativeFnPtr. @@ -1106,15 +1113,15 @@ mod tests { } fn plain_object(vm: &mut Vm) -> JsValue { - let proto = vm.kernel.builtin_world().object_proto.as_ptr() as *mut JsObject; + let proto = vm.session.builtin_world().object_proto.as_ptr() as *mut JsObject; let obj = JsObject::new_empty(oxide_kernel::shape_forge::EMPTY_SHAPE_ID, JsValue::from_js_object(proto)); JsValue::object(vm.epoch.alloc(obj) as *mut u8) } fn add_accessor(vm: &mut Vm, obj_val: JsValue, name: &str, get: JsValue, set: JsValue) { - let si = vm.kernel.string_forge().intern(name).0; + let si = vm.kernel_core.string_forge().intern(name).0; let obj = unsafe { &mut *obj_val.as_js_object_ptr() }; - let shape_id = vm.kernel.shape_forge().make_shape(obj.shape_id(), si); + let shape_id = vm.kernel_core.shape_forge().make_shape(obj.shape_id(), si); obj.set_shape_id(shape_id); let pos = obj.push_prop(JsValue::undefined()); obj.set_accessor_meta(pos, get, set, PropAttributes::DEFAULT_DATA); @@ -1122,7 +1129,7 @@ mod tests { } fn set_data(vm: &mut Vm, obj_val: JsValue, name: &str, val: JsValue) { - let si = vm.kernel.string_forge().intern(name).0; + let si = vm.kernel_core.string_forge().intern(name).0; let obj = unsafe { &mut *obj_val.as_js_object_ptr() }; vm.set_or_create_prop_value(obj, si, val); } @@ -1268,7 +1275,7 @@ mod tests { let getter = native_function(&mut vm, native_return_7); add_accessor(&mut vm, obj_val, "x", getter, JsValue::undefined()); - let x_si = vm.kernel.string_forge().intern("x").0; + let x_si = vm.kernel_core.string_forge().intern("x").0; let obj = unsafe { &*obj_val.as_js_object_ptr() }; let value = vm.ordinary_get(obj, x_si, obj_val).expect("getter"); assert_eq!(value, JsValue::int(7)); @@ -1281,11 +1288,11 @@ mod tests { let setter = native_function(&mut vm, native_set_marker); add_accessor(&mut vm, obj_val, "x", JsValue::undefined(), setter); - let x_si = vm.kernel.string_forge().intern("x").0; + let x_si = vm.kernel_core.string_forge().intern("x").0; let obj = unsafe { &mut *obj_val.as_js_object_ptr() }; vm.ordinary_set(obj, x_si, JsValue::int(9), obj_val).expect("setter"); - let marker_si = vm.kernel.string_forge().intern("marker").0; + let marker_si = vm.kernel_core.string_forge().intern("marker").0; let obj = unsafe { &*obj_val.as_js_object_ptr() }; assert_eq!(vm.resolve_property(obj, marker_si), Some(JsValue::int(9))); } @@ -1302,7 +1309,7 @@ mod tests { (*child_val.as_js_object_ptr()).set_proto(proto_val).expect("proto"); } - let x_si = vm.kernel.string_forge().intern("x").0; + let x_si = vm.kernel_core.string_forge().intern("x").0; let child = unsafe { &*child_val.as_js_object_ptr() }; let value = vm.ordinary_get(child, x_si, child_val).expect("getter"); assert_eq!(value, JsValue::int(42)); @@ -1319,11 +1326,11 @@ mod tests { (*child_val.as_js_object_ptr()).set_proto(proto_val).expect("proto"); } - let x_si = vm.kernel.string_forge().intern("x").0; + let x_si = vm.kernel_core.string_forge().intern("x").0; let child = unsafe { &mut *child_val.as_js_object_ptr() }; vm.ordinary_set(child, x_si, JsValue::int(12), child_val).expect("setter"); - let marker_si = vm.kernel.string_forge().intern("marker").0; + let marker_si = vm.kernel_core.string_forge().intern("marker").0; let child = unsafe { &*child_val.as_js_object_ptr() }; let proto = unsafe { &*proto_val.as_js_object_ptr() }; assert_eq!(vm.resolve_property(child, marker_si), Some(JsValue::int(12))); @@ -1343,11 +1350,11 @@ mod tests { (*child_val.as_js_object_ptr()).set_proto(proto_val).expect("proto"); } - let x_si = vm.kernel.string_forge().intern("x").0; + let x_si = vm.kernel_core.string_forge().intern("x").0; let child = unsafe { &mut *child_val.as_js_object_ptr() }; vm.ordinary_set(child, x_si, JsValue::int(15), child_val).expect("setter"); - let marker_si = vm.kernel.string_forge().intern("marker").0; + let marker_si = vm.kernel_core.string_forge().intern("marker").0; let child = unsafe { &*child_val.as_js_object_ptr() }; assert_eq!(vm.resolve_property(child, marker_si), Some(JsValue::int(15))); } @@ -1358,7 +1365,7 @@ mod tests { let obj_val = plain_object(&mut vm); set_data(&mut vm, obj_val, "x", JsValue::int(1)); - let x_si = vm.kernel.string_forge().intern("x").0; + let x_si = vm.kernel_core.string_forge().intern("x").0; let obj = unsafe { &mut *obj_val.as_js_object_ptr() }; assert!(!obj.has_prop_meta()); assert_eq!(vm.ordinary_get(obj, x_si, obj_val).expect("get"), JsValue::int(1)); diff --git a/crates/oxide_vm/src/vm_dispatch_misc.rs b/crates/oxide_vm/src/vm_dispatch_misc.rs index cf61967..9da4894 100644 --- a/crates/oxide_vm/src/vm_dispatch_misc.rs +++ b/crates/oxide_vm/src/vm_dispatch_misc.rs @@ -41,7 +41,7 @@ impl Vm { JsValue::from_js_object(proto_ptr), )); - let proto_si = self.kernel.string_forge().intern("prototype").0; + let proto_si = self.kernel_core.string_forge().intern("prototype").0; if let Some(proto_val) = self.resolve_property(ctor_obj, proto_si) { if proto_val.is_object() { let new_obj_mut = unsafe { &mut *new_obj }; @@ -87,7 +87,7 @@ impl Vm { )); } - if self.frames.len() >= self.kernel.config.max_call_depth { + if self.frames.len() >= self.kernel_core.config.max_call_depth { return Err("RangeError: Maximum call stack size exceeded".into()); } @@ -122,7 +122,7 @@ impl Vm { function_name: self.sub_modules[sub_idx] .function_name .as_deref() - .map(|name| self.kernel.string_forge().intern(name).0) + .map(|name| self.kernel_core.string_forge().intern(name).0) .unwrap_or(0), caller_reg_limit, saved_regs, @@ -139,9 +139,9 @@ impl Vm { self.constants = converted_sub_constants; for (name, reg) in &self.sub_modules[sub_idx].builtin_reg_map { - let si = self.kernel.string_forge().intern(name.as_str()).0; - let global = self.kernel.global_object(); - if let Some(pos) = self.kernel.shape_forge().lookup_position(global.shape_id(), si) { + let si = self.kernel_core.string_forge().intern(name.as_str()).0; + let global = self.session.global_object(); + if let Some(pos) = self.kernel_core.shape_forge().lookup_position(global.shape_id(), si) { self.regs[*reg as usize] = global.get_prop_at(pos); } } @@ -172,7 +172,7 @@ impl Vm { let reg = (seg & 0x7F) as u8; let val = self.regs[reg as usize]; let s = if val.is_string() { - self.kernel().string_forge().lookup(val.as_string_index()).unwrap_or_default() + self.kernel_core.string_forge().lookup(val.as_string_index()).unwrap_or_default() } else { format!("{}", val) }; @@ -182,13 +182,13 @@ impl Vm { if const_idx < self.constants.len() { let val = self.constants[const_idx]; if val.is_string() { - let s = self.kernel().string_forge().lookup(val.as_string_index()).unwrap_or_default(); + let s = self.kernel_core.string_forge().lookup(val.as_string_index()).unwrap_or_default(); result.push_str(&s); } } } } - let si = self.kernel.string_forge().intern(&result).0; + let si = self.kernel_core.string_forge().intern(&result).0; self.regs[rd] = JsValue::string(si, 0); } @@ -205,7 +205,7 @@ impl Vm { } let rhs_obj = unsafe { &*rhs_val.as_js_object_ptr() }; - let proto_si = self.kernel.string_forge().intern("prototype").0; + let proto_si = self.kernel_core.string_forge().intern("prototype").0; let ctor_proto = self.resolve_property(rhs_obj, proto_si); let ctor_proto_ptr = match ctor_proto { @@ -265,17 +265,17 @@ impl Vm { if id == oxide_kernel::shape_forge::EMPTY_SHAPE_ID { break; } - if let Some(shape) = self.kernel.shape_forge().get_shape(id) { + if let Some(shape) = self.kernel_core.shape_forge().get_shape(id) { if shape.property_name != u32::MAX && seen.insert(shape.property_name) { let enumerable = self - .kernel + .kernel_core .shape_forge() .lookup_position(cur.shape_id(), shape.property_name) .and_then(|pos| cur.prop_meta_at(pos)) .map(|meta| meta.attributes.enumerable()) .unwrap_or(PropAttributes::DEFAULT_DATA.enumerable()); if enumerable { - let hash = self.kernel.string_forge().get_hash(shape.property_name).unwrap_or(0); + let hash = self.kernel_core.string_forge().get_hash(shape.property_name).unwrap_or(0); keys_vec.push(JsValue::string(shape.property_name, hash)); } } diff --git a/crates/oxide_vm/src/vm_pool.rs b/crates/oxide_vm/src/vm_pool.rs index 2a533b9..2aa01ed 100644 --- a/crates/oxide_vm/src/vm_pool.rs +++ b/crates/oxide_vm/src/vm_pool.rs @@ -3,7 +3,7 @@ use std::sync::{Arc, Condvar, Mutex}; use crate::vm::Vm; -use oxide_kernel::kernel::OxideKernel; +use oxide_kernel::kernel::KernelCore; struct VmPoolInner { available: Vec, @@ -11,7 +11,7 @@ struct VmPoolInner { } pub struct VmPool { - kernel: Arc, + kernel_core: Arc, inner: Mutex, condvar: Condvar, #[allow(dead_code)] @@ -27,9 +27,11 @@ pub struct VmGuard { } impl VmPool { - pub fn new(kernel: Arc, #[allow(dead_code)] min_size: usize, max_size: Option) -> Arc { + pub fn new( + kernel_core: Arc, #[allow(dead_code)] min_size: usize, max_size: Option, + ) -> Arc { let pool = Arc::new(Self { - kernel, + kernel_core, inner: Mutex::new(VmPoolInner { available: Vec::with_capacity(min_size), total_count: 0, @@ -42,7 +44,7 @@ impl VmPool { { let mut inner = pool.inner.lock().unwrap(); for _ in 0..min_size { - let vm = Self::new_vm(&pool.kernel); + let vm = Self::new_vm(&pool.kernel_core); inner.available.push(vm); inner.total_count += 1; } @@ -51,12 +53,12 @@ impl VmPool { pool } - fn new_vm(kernel: &Arc) -> Vm { - Vm::with_kernel(Arc::clone(kernel)) + fn new_vm(core: &Arc) -> Vm { + Vm::with_kernel_core(Arc::clone(core)) } fn replace_vm(&self) -> Vm { - Self::new_vm(&self.kernel) + Self::new_vm(&self.kernel_core) } pub fn spawn(self: &Arc) -> VmGuard { @@ -80,7 +82,7 @@ impl VmPool { if can_grow { inner.total_count += 1; drop(inner); - let vm = Self::new_vm(&self.kernel); + let vm = Self::new_vm(&self.kernel_core); return VmGuard { vm: Some(vm), pool: Arc::clone(self), @@ -110,7 +112,7 @@ impl VmGuard { impl Drop for VmGuard { fn drop(&mut self) { - let Some(vm) = self.vm.take() else { + let Some(mut vm) = self.vm.take() else { return; }; @@ -121,12 +123,11 @@ impl Drop for VmGuard { inner.available.push(new_vm); } else { for &idx in &self.interned_strings { - self.pool.kernel.string_forge().decref(idx); + self.pool.kernel_core.string_forge().decref(idx); } - let mut returned_vm = vm; - returned_vm.reset(); - inner.available.push(returned_vm); + vm.full_reset(); + inner.available.push(vm); } self.pool.condvar.notify_one(); @@ -138,8 +139,8 @@ mod tests { use super::*; use oxide_kernel::kernel::KernelConfig; - fn test_kernel() -> Arc { - Arc::new(OxideKernel::new(KernelConfig::minimal())) + fn test_kernel() -> Arc { + KernelCore::new(KernelConfig::minimal()) } #[test] diff --git a/crates/oxide_vm/src/vm_props.rs b/crates/oxide_vm/src/vm_props.rs index bcefca2..78270ac 100644 --- a/crates/oxide_vm/src/vm_props.rs +++ b/crates/oxide_vm/src/vm_props.rs @@ -19,7 +19,7 @@ impl Vm { fn ordinary_get_inner( &mut self, obj: &JsObject, prop_name_si: u32, receiver: JsValue, target_reg: Option, ) -> Result { - let length_si = self.kernel.string_forge().intern("length").0; + let length_si = self.kernel_core.string_forge().intern("length").0; if obj.is_array() && prop_name_si == length_si { return Ok(JsValue::int(obj.prop_count() as i32)); } @@ -185,7 +185,7 @@ impl Vm { let val = if cached_shape_id != 0 && cached_shape_id == obj.shape_id() && cached_slot < obj.prop_vec_len() as u32 { obj.get_prop_at(cached_slot) - } else if let Some(template) = self.kernel.prop_forge().get_template(obj.shape_id()) { + } else if let Some(template) = self.kernel_core.prop_forge().get_template(obj.shape_id()) { if template.prop_name != prop_name_si { self.ordinary_get(obj, prop_name_si, receiver)? } else if template.position < obj.prop_vec_len() as u32 { @@ -196,7 +196,7 @@ impl Vm { } } else { let resolved = self.ordinary_get(obj, prop_name_si, receiver)?; - if let Some(pos) = self.kernel.shape_forge().lookup_position(obj.shape_id(), prop_name_si) { + if let Some(pos) = self.kernel_core.shape_forge().lookup_position(obj.shape_id(), prop_name_si) { if !obj.is_accessor_meta(pos) { self.write_ic_back(obj.shape_id(), pos); } @@ -209,7 +209,7 @@ impl Vm { pub(crate) fn set_member_prop( &mut self, obj: &mut JsObject, prop_name_si: u32, val: JsValue, receiver: JsValue, ) -> Result<(), String> { - if let Some(pos) = self.kernel.shape_forge().lookup_position(obj.shape_id(), prop_name_si) { + if let Some(pos) = self.kernel_core.shape_forge().lookup_position(obj.shape_id(), prop_name_si) { if obj.has_prop_meta() { self.ordinary_set(obj, prop_name_si, val, receiver)?; return Ok(()); @@ -223,10 +223,10 @@ impl Vm { } pub(crate) fn set_or_create_prop_value(&mut self, obj: &mut JsObject, prop_name_si: u32, val: JsValue) { - if let Some(pos) = self.kernel.shape_forge().lookup_position(obj.shape_id(), prop_name_si) { + if let Some(pos) = self.kernel_core.shape_forge().lookup_position(obj.shape_id(), prop_name_si) { obj.set_prop_at(pos, val); } else { - let new_shape_id = self.kernel.shape_forge().make_shape(obj.shape_id(), prop_name_si); + let new_shape_id = self.kernel_core.shape_forge().make_shape(obj.shape_id(), prop_name_si); obj.set_shape_id(new_shape_id); obj.push_prop(val); obj.bump_generation(); @@ -236,10 +236,10 @@ impl Vm { pub(crate) fn define_data_property( &mut self, obj: &mut JsObject, prop_name_si: u32, val: JsValue, attributes: PropAttributes, ) -> Result<(), String> { - let pos = if let Some(pos) = self.kernel.shape_forge().lookup_position(obj.shape_id(), prop_name_si) { + let pos = if let Some(pos) = self.kernel_core.shape_forge().lookup_position(obj.shape_id(), prop_name_si) { pos } else { - let new_shape_id = self.kernel.shape_forge().make_shape(obj.shape_id(), prop_name_si); + let new_shape_id = self.kernel_core.shape_forge().make_shape(obj.shape_id(), prop_name_si); obj.set_shape_id(new_shape_id); obj.push_prop(JsValue::undefined()) }; @@ -270,10 +270,10 @@ impl Vm { pub(crate) fn define_accessor_property( &mut self, obj: &mut JsObject, prop_name_si: u32, get: JsValue, set: JsValue, attributes: PropAttributes, ) -> Result<(), String> { - let pos = if let Some(pos) = self.kernel.shape_forge().lookup_position(obj.shape_id(), prop_name_si) { + let pos = if let Some(pos) = self.kernel_core.shape_forge().lookup_position(obj.shape_id(), prop_name_si) { pos } else { - let new_shape_id = self.kernel.shape_forge().make_shape(obj.shape_id(), prop_name_si); + let new_shape_id = self.kernel_core.shape_forge().make_shape(obj.shape_id(), prop_name_si); obj.set_shape_id(new_shape_id); obj.push_prop(JsValue::undefined()) }; diff --git a/crates/oxide_vm/src/vm_runtime.rs b/crates/oxide_vm/src/vm_runtime.rs index c6722b9..514b56f 100644 --- a/crates/oxide_vm/src/vm_runtime.rs +++ b/crates/oxide_vm/src/vm_runtime.rs @@ -20,7 +20,7 @@ impl Vm { self.sub_modules.len() )); } - if self.frames.len() >= self.kernel.config.max_call_depth { + if self.frames.len() >= self.kernel_core.config.max_call_depth { return Err("RangeError: Maximum call stack size exceeded".into()); } @@ -56,9 +56,9 @@ impl Vm { self.regs[254] = if sub.is_arrow { callee_obj.captured_this() } else { receiver }; self.regs[255] = JsValue::undefined(); for (name, reg) in &sub.builtin_reg_map { - let si = self.kernel.string_forge().intern(name.as_str()).0; - let global = self.kernel.global_object(); - if let Some(pos) = self.kernel.shape_forge().lookup_position(global.shape_id(), si) { + let si = self.kernel_core.string_forge().intern(name.as_str()).0; + let global = self.session.global_object(); + if let Some(pos) = self.kernel_core.shape_forge().lookup_position(global.shape_id(), si) { self.regs[*reg as usize] = global.get_prop_at(pos); } } @@ -133,14 +133,14 @@ impl Vm { self.active_reg_limit = self.root_reg_limit; for (name, reg) in &module.builtin_reg_map { - let si = self.kernel.string_forge().intern(name.as_str()).0; - let global = self.kernel.global_object(); - if let Some(pos) = self.kernel.shape_forge().lookup_position(global.shape_id(), si) { + let si = self.kernel_core.string_forge().intern(name.as_str()).0; + let global = self.session.global_object(); + if let Some(pos) = self.kernel_core.shape_forge().lookup_position(global.shape_id(), si) { self.regs[*reg as usize] = global.get_prop_at(pos); } } - let global_ptr = self.kernel.global_object().as_ptr() as *mut JsObject; + let global_ptr = self.session.global_object().as_ptr() as *mut JsObject; self.regs[254] = JsValue::from_js_object(global_ptr); self.dispatch() diff --git a/crates/oxide_vm/src/vm_support.rs b/crates/oxide_vm/src/vm_support.rs index dc97782..62e3ba7 100644 --- a/crates/oxide_vm/src/vm_support.rs +++ b/crates/oxide_vm/src/vm_support.rs @@ -6,7 +6,7 @@ use oxide_compiler::compiler::Constant; use crate::bindings; use crate::vm::{native_fn_ptr_to_fn, Vm}; -use oxide_kernel::kernel::{KernelConfig, OxideKernel}; +use oxide_kernel::kernel::{KernelConfig, KernelCore, KernelSession}; use oxide_kernel::shape_forge::EMPTY_SHAPE_ID; use oxide_types::error::JsError; use oxide_types::mem::{Epoch, P}; @@ -15,9 +15,10 @@ use oxide_types::value::JsValue; impl Vm { pub fn new() -> Self { - let kernel = Arc::new(OxideKernel::new(KernelConfig::minimal())); - bindings::init_kernel_builtins(&kernel); - let obj_proto = P::clone(&kernel.builtin_world().object_proto); + let core = KernelCore::new(KernelConfig::minimal()); + let session = KernelSession::new(&core); + bindings::init_kernel_builtins(&core, &session); + let obj_proto = P::clone(&session.builtin_world().object_proto); Self { regs: [JsValue::undefined(); 256], pc: 0, @@ -25,7 +26,8 @@ impl Vm { constants: Vec::new(), frames: smallvec::SmallVec::new(), for_in_iters: Vec::new(), - kernel, + kernel_core: core, + session, interned_strings: Vec::new(), epoch: Epoch::new(), object_prototype: obj_proto, @@ -48,8 +50,10 @@ impl Vm { } } - pub fn with_kernel(kernel: Arc) -> Self { - let obj_proto = P::clone(&kernel.builtin_world().object_proto); + pub fn with_kernel_core(core: Arc) -> Self { + let session = KernelSession::new(&core); + bindings::init_kernel_builtins(&core, &session); + let obj_proto = P::clone(&session.builtin_world().object_proto); Self { regs: [JsValue::undefined(); 256], pc: 0, @@ -57,7 +61,8 @@ impl Vm { constants: Vec::new(), frames: smallvec::SmallVec::new(), for_in_iters: Vec::new(), - kernel, + kernel_core: core, + session, interned_strings: Vec::new(), epoch: Epoch::new(), object_prototype: obj_proto, @@ -80,6 +85,20 @@ impl Vm { } } + pub fn full_reset(&mut self) { + let new_session = KernelSession::new(&self.kernel_core); + bindings::init_kernel_builtins(&self.kernel_core, &new_session); + self.object_prototype = P::clone(&new_session.builtin_world().object_proto); + self.session = new_session; + self.clear_execution_state(); + self.bytecode.clear(); + self.constants.clear(); + self.epoch.reset(); + self.interned_strings.clear(); + self.root_reg_limit = 0; + self.active_reg_limit = 0; + } + pub(crate) fn clear_execution_state(&mut self) { // Reset contract: // - Clears register file, pc, frame/iterator stacks, saved execution stacks, @@ -111,7 +130,7 @@ impl Vm { } pub fn intern(&mut self, s: &str) -> JsValue { - let (idx, hash) = self.kernel.string_forge().intern(s); + let (idx, hash) = self.kernel_core.string_forge().intern(s); self.interned_strings.push(idx); JsValue::string(idx, hash) } @@ -123,7 +142,7 @@ impl Vm { &mut self, sub_idx: u32, is_arrow: bool, is_class_constructor: bool, is_derived_constructor: bool, needs_home_object: bool, ) -> JsValue { - let func_proto_ptr = self.kernel.builtin_world().function_proto.as_ptr() as *mut JsObject; + let func_proto_ptr = self.session.builtin_world().function_proto.as_ptr() as *mut JsObject; let proto_val = JsValue::from_js_object(func_proto_ptr); let mut obj = JsObject::new_empty(EMPTY_SHAPE_ID, proto_val); obj.set_function(true); @@ -139,23 +158,23 @@ impl Vm { let func_val = JsValue::object(obj_ptr as *mut u8); if !is_arrow { - let object_proto_ptr = self.kernel.builtin_world().object_proto.as_ptr() as *mut JsObject; + let object_proto_ptr = self.session.builtin_world().object_proto.as_ptr() as *mut JsObject; let prototype_obj = self .epoch .alloc(JsObject::new_empty(EMPTY_SHAPE_ID, JsValue::from_js_object(object_proto_ptr))); let prototype_val = JsValue::from_js_object(prototype_obj); - let constructor_si = self.kernel.string_forge().intern("constructor").0; - let constructor_shape = self.kernel.shape_forge().make_shape(EMPTY_SHAPE_ID, constructor_si); + let constructor_si = self.kernel_core.string_forge().intern("constructor").0; + let constructor_shape = self.kernel_core.shape_forge().make_shape(EMPTY_SHAPE_ID, constructor_si); let prototype = unsafe { &mut *prototype_obj }; prototype.set_shape_id(constructor_shape); let constructor_pos = prototype.push_prop(func_val); prototype.set_data_meta(constructor_pos, PropAttributes::new(true, false, true)); prototype.bump_generation(); - let prototype_si = self.kernel.string_forge().intern("prototype").0; + let prototype_si = self.kernel_core.string_forge().intern("prototype").0; let func = unsafe { &mut *obj_ptr }; - let prototype_shape = self.kernel.shape_forge().make_shape(func.shape_id(), prototype_si); + let prototype_shape = self.kernel_core.shape_forge().make_shape(func.shape_id(), prototype_si); func.set_shape_id(prototype_shape); func.ensure_hash_props().push(prototype_val); func.bump_generation(); @@ -170,8 +189,8 @@ impl Vm { } if val.is_object() { let obj = unsafe { &*val.as_js_object_ptr() }; - let name_si = self.kernel.string_forge().intern("name").0; - let message_si = self.kernel.string_forge().intern("message").0; + let name_si = self.kernel_core.string_forge().intern("name").0; + let message_si = self.kernel_core.string_forge().intern("message").0; let name = self .resolve_property(obj, name_si) .and_then(|v| self.lookup_str(v)) @@ -216,12 +235,12 @@ impl Vm { )) } Constant::RegExp(pattern, flags) => { - let pat_si = self.kernel.string_forge().intern(pattern).0; - let flags_si = self.kernel.string_forge().intern(flags).0; + let pat_si = self.kernel_core.string_forge().intern(pattern).0; + let flags_si = self.kernel_core.string_forge().intern(flags).0; let pat_val = JsValue::string(pat_si, 0); let flags_val = JsValue::string(flags_si, 0); - let ctor_ptr = self.kernel.builtin_world().regexp_constructor.as_ptr() as *mut JsObject; + let ctor_ptr = self.session.builtin_world().regexp_constructor.as_ptr() as *mut JsObject; let ctor = unsafe { &*ctor_ptr }; let Some(native_fn) = ctor.native_fn() else { return Err(JsError::syntax_error("RegExp constructor unavailable")); diff --git a/crates/oxide_vm/tests/arrow_tests.rs b/crates/oxide_vm/tests/arrow_tests.rs index 999d969..085a205 100644 --- a/crates/oxide_vm/tests/arrow_tests.rs +++ b/crates/oxide_vm/tests/arrow_tests.rs @@ -37,7 +37,7 @@ fn eval_val(source: &str) -> (Vm, Result) { fn to_str(vm: &Vm, val: JsValue) -> String { if val.is_string() { - vm.kernel().string_forge().lookup(val.as_string_index()).unwrap_or_default() + vm.kernel_core().string_forge().lookup(val.as_string_index()).unwrap_or_default() } else { format!("{}", val) } diff --git a/crates/oxide_vm/tests/builtins_boolean_tests.rs b/crates/oxide_vm/tests/builtins_boolean_tests.rs index ba12993..d30ed6d 100644 --- a/crates/oxide_vm/tests/builtins_boolean_tests.rs +++ b/crates/oxide_vm/tests/builtins_boolean_tests.rs @@ -14,7 +14,7 @@ fn eval(vm: &mut Vm, source: &str) -> Result { } fn str_val(vm: &Vm, val: JsValue) -> String { - vm.kernel().string_forge().lookup(val.as_string_index()).unwrap_or_default() + vm.kernel_core().string_forge().lookup(val.as_string_index()).unwrap_or_default() } // -- direct native fn tests -- @@ -25,7 +25,7 @@ fn bool_ctor_call(vm: &mut Vm, arg: JsValue) -> JsValue { } fn bool_ctor_new(vm: &mut Vm, arg: JsValue) -> JsValue { - let proto_ptr = vm.kernel().builtin_world().boolean_proto.as_ptr() as *mut JsObject; + let proto_ptr = vm.session().builtin_world().boolean_proto.as_ptr() as *mut JsObject; let wrapper = JsObject::new_empty(EMPTY_SHAPE_ID, JsValue::from_js_object(proto_ptr)); let ptr = vm.epoch().alloc(wrapper); let val = JsValue::from_js_object(ptr); diff --git a/crates/oxide_vm/tests/builtins_date_tests.rs b/crates/oxide_vm/tests/builtins_date_tests.rs index 6813e04..844fd79 100644 --- a/crates/oxide_vm/tests/builtins_date_tests.rs +++ b/crates/oxide_vm/tests/builtins_date_tests.rs @@ -9,7 +9,7 @@ fn eval(vm: &mut Vm, source: &str) -> Result String { - vm.kernel().string_forge().lookup(val.as_string_index()).unwrap_or_default() + vm.kernel_core().string_forge().lookup(val.as_string_index()).unwrap_or_default() } // -- static methods -- diff --git a/crates/oxide_vm/tests/builtins_function_tests.rs b/crates/oxide_vm/tests/builtins_function_tests.rs index 72b6794..947ae73 100644 --- a/crates/oxide_vm/tests/builtins_function_tests.rs +++ b/crates/oxide_vm/tests/builtins_function_tests.rs @@ -34,7 +34,7 @@ fn function_bind_creates_wrapper() { fn function_constructor_is_global() { let mut vm = Vm::new(); let result = eval(&mut vm, "typeof Function").unwrap(); - let rendered = vm.kernel().string_forge().lookup(result.as_string_index()).unwrap_or_default(); + let rendered = vm.kernel_core().string_forge().lookup(result.as_string_index()).unwrap_or_default(); assert_eq!(rendered, "function"); } @@ -82,7 +82,7 @@ fn function_to_string_includes_function() { let mut vm = Vm::new(); let result = eval(&mut vm, "Math.max.toString()").unwrap(); assert!(result.is_string()); - let rendered = vm.kernel().string_forge().lookup(result.as_string_index()).unwrap_or_default(); + let rendered = vm.kernel_core().string_forge().lookup(result.as_string_index()).unwrap_or_default(); assert_eq!(rendered, "function max() { [native code] }"); } diff --git a/crates/oxide_vm/tests/builtins_map_tests.rs b/crates/oxide_vm/tests/builtins_map_tests.rs index d06181a..e3f3ce3 100644 --- a/crates/oxide_vm/tests/builtins_map_tests.rs +++ b/crates/oxide_vm/tests/builtins_map_tests.rs @@ -11,7 +11,7 @@ fn eval(vm: &mut Vm, source: &str) -> Result { } fn str_val(vm: &Vm, val: JsValue) -> String { - vm.kernel().string_forge().lookup(val.as_string_index()).unwrap_or_default() + vm.kernel_core().string_forge().lookup(val.as_string_index()).unwrap_or_default() } // -- direct native fn tests -- diff --git a/crates/oxide_vm/tests/builtins_number_tests.rs b/crates/oxide_vm/tests/builtins_number_tests.rs index b4110aa..4a09e65 100644 --- a/crates/oxide_vm/tests/builtins_number_tests.rs +++ b/crates/oxide_vm/tests/builtins_number_tests.rs @@ -76,7 +76,7 @@ fn number_constructor() { fn to_string_of_number() { let mut vm = Vm::new(); let result = eval(&mut vm, "var n = 42; n.toString()").unwrap(); - let s = vm.kernel().string_forge().lookup(result.as_string_index()).unwrap_or_default(); + let s = vm.kernel_core().string_forge().lookup(result.as_string_index()).unwrap_or_default(); assert_eq!(s, "42"); } @@ -84,7 +84,7 @@ fn to_string_of_number() { fn to_fixed_of_number() { let mut vm = Vm::new(); let result = eval(&mut vm, "var n = 3.14159; n.toFixed(2)").unwrap(); - let s = vm.kernel().string_forge().lookup(result.as_string_index()).unwrap_or_default(); + let s = vm.kernel_core().string_forge().lookup(result.as_string_index()).unwrap_or_default(); assert_eq!(s, "3.14"); } @@ -113,7 +113,7 @@ fn number_epsilon_is_positive() { fn number_to_exponential() { let mut vm = Vm::new(); let result = eval(&mut vm, "var n = 123.456; n.toExponential(2)").unwrap(); - let s = vm.kernel().string_forge().lookup(result.as_string_index()).unwrap_or_default(); + let s = vm.kernel_core().string_forge().lookup(result.as_string_index()).unwrap_or_default(); assert_eq!(s, "1.23e2"); } diff --git a/crates/oxide_vm/tests/builtins_object_tests.rs b/crates/oxide_vm/tests/builtins_object_tests.rs index cada4ed..88f6bb3 100644 --- a/crates/oxide_vm/tests/builtins_object_tests.rs +++ b/crates/oxide_vm/tests/builtins_object_tests.rs @@ -41,7 +41,7 @@ fn object_assign_copies() { fn object_assign_boxes_primitive_target() { let (_vm, result) = eval("var result = Object.assign('a'); result.valueOf()").unwrap(); assert!(result.is_string()); - let rendered = _vm.kernel().string_forge().lookup(result.as_string_index()).unwrap_or_default(); + let rendered = _vm.kernel_core().string_forge().lookup(result.as_string_index()).unwrap_or_default(); assert_eq!(rendered, "a"); } diff --git a/crates/oxide_vm/tests/builtins_regexp_tests.rs b/crates/oxide_vm/tests/builtins_regexp_tests.rs index 169d94e..0c122c5 100644 --- a/crates/oxide_vm/tests/builtins_regexp_tests.rs +++ b/crates/oxide_vm/tests/builtins_regexp_tests.rs @@ -10,7 +10,7 @@ fn eval(vm: &mut Vm, source: &str) -> Result { } fn to_str(vm: &Vm, val: JsValue) -> String { - vm.kernel().string_forge().lookup(val.as_string_index()).unwrap_or_default() + vm.kernel_core().string_forge().lookup(val.as_string_index()).unwrap_or_default() } // --- RegExp constructor --- diff --git a/crates/oxide_vm/tests/builtins_string_tests.rs b/crates/oxide_vm/tests/builtins_string_tests.rs index 8b3aa42..d547a5b 100644 --- a/crates/oxide_vm/tests/builtins_string_tests.rs +++ b/crates/oxide_vm/tests/builtins_string_tests.rs @@ -10,7 +10,7 @@ fn eval(vm: &mut Vm, source: &str) -> Result { } fn to_str(vm: &Vm, val: JsValue) -> String { - vm.kernel().string_forge().lookup(val.as_string_index()).unwrap_or_default() + vm.kernel_core().string_forge().lookup(val.as_string_index()).unwrap_or_default() } #[test] diff --git a/crates/oxide_vm/tests/builtins_symbol_tests.rs b/crates/oxide_vm/tests/builtins_symbol_tests.rs index 48ecba3..f68c9fd 100644 --- a/crates/oxide_vm/tests/builtins_symbol_tests.rs +++ b/crates/oxide_vm/tests/builtins_symbol_tests.rs @@ -10,7 +10,7 @@ fn eval(vm: &mut Vm, source: &str) -> Result { } fn to_str(vm: &Vm, val: JsValue) -> String { - vm.kernel().string_forge().lookup(val.as_string_index()).unwrap_or_default() + vm.kernel_core().string_forge().lookup(val.as_string_index()).unwrap_or_default() } // --- Symbol constructor --- diff --git a/crates/oxide_vm/tests/coercion_tests.rs b/crates/oxide_vm/tests/coercion_tests.rs index 0232a2c..10ee803 100644 --- a/crates/oxide_vm/tests/coercion_tests.rs +++ b/crates/oxide_vm/tests/coercion_tests.rs @@ -86,13 +86,13 @@ fn test_strict_equality_null_undefined() { #[test] fn test_to_int32_and_to_uint32() { let vm = Vm::new(); - let sf = vm.kernel().string_forge().as_ref(); + let sf = vm.kernel_core().string_forge().as_ref(); let string_three = { - let (idx, hash) = vm.kernel().string_forge().intern("3"); + let (idx, hash) = vm.kernel_core().string_forge().intern("3"); JsValue::string(idx, hash) }; let string_bad = { - let (idx, hash) = vm.kernel().string_forge().intern("x"); + let (idx, hash) = vm.kernel_core().string_forge().intern("x"); JsValue::string(idx, hash) }; diff --git a/crates/oxide_vm/tests/function_tests.rs b/crates/oxide_vm/tests/function_tests.rs index 8f6f696..ab94ad1 100644 --- a/crates/oxide_vm/tests/function_tests.rs +++ b/crates/oxide_vm/tests/function_tests.rs @@ -204,6 +204,6 @@ fn function_default_prototype_accepts_member_assignment() { "function Test262Error(message) { this.message = message || ''; } Test262Error.prototype.toString = function () { return this.message; }; new Test262Error('ok').toString()", ) .unwrap(); - let rendered = vm.kernel().string_forge().lookup(result.as_string_index()).unwrap_or_default(); + let rendered = vm.kernel_core().string_forge().lookup(result.as_string_index()).unwrap_or_default(); assert_eq!(rendered, "ok"); } diff --git a/crates/oxide_vm/tests/json_tests.rs b/crates/oxide_vm/tests/json_tests.rs index d07beab..b49c666 100644 --- a/crates/oxide_vm/tests/json_tests.rs +++ b/crates/oxide_vm/tests/json_tests.rs @@ -10,7 +10,7 @@ fn eval(vm: &mut Vm, source: &str) -> Result { } fn string_value(vm: &Vm, val: JsValue) -> String { - vm.kernel().string_forge().lookup(val.as_string_index()).unwrap_or_default() + vm.kernel_core().string_forge().lookup(val.as_string_index()).unwrap_or_default() } // -- JSON.parse -- diff --git a/crates/oxide_vm/tests/regression_tests.rs b/crates/oxide_vm/tests/regression_tests.rs index 26a3df1..9b37318 100644 --- a/crates/oxide_vm/tests/regression_tests.rs +++ b/crates/oxide_vm/tests/regression_tests.rs @@ -1,7 +1,7 @@ use std::sync::Arc; use oxide_compiler::compiler::Compiler; -use oxide_kernel::kernel::{KernelConfig, OxideKernel}; +use oxide_kernel::kernel::{KernelConfig, KernelCore}; use oxide_parser::Allocator; use oxide_vm::vm::Vm; @@ -22,7 +22,7 @@ fn eval(source: &str) -> String { } } -fn eval_with_kernel(source: &str, kernel: Arc) -> String { +fn eval_with_kernel(source: &str, kernel: Arc) -> String { let allocator = Allocator::default(); let program = match oxide_parser::parse(&allocator, source) { Ok(p) => p, @@ -32,7 +32,7 @@ fn eval_with_kernel(source: &str, kernel: Arc) -> String { Ok(m) => m, Err(e) => return format!("compile error: {e}"), }; - let mut vm = Vm::with_kernel(kernel); + let mut vm = Vm::with_kernel_core(kernel); match vm.run(&module) { Ok(result) => format!("{result}"), Err(e) => format!("vm error: {e}"), @@ -108,7 +108,7 @@ fn regression_for_in_prototype_chain() { fn regression_vm_step_limit_is_configurable() { let mut config = KernelConfig::minimal(); config.max_steps = Some(5); - let kernel = Arc::new(OxideKernel::new(config)); + let kernel = KernelCore::new(config); let result = eval_with_kernel("while (true) {}", kernel); assert!( result.contains("VM step limit exceeded"), diff --git a/crates/oxide_vm/tests/template_tests.rs b/crates/oxide_vm/tests/template_tests.rs index f83e8e3..c6d5747 100644 --- a/crates/oxide_vm/tests/template_tests.rs +++ b/crates/oxide_vm/tests/template_tests.rs @@ -37,7 +37,7 @@ fn eval_val(source: &str) -> (Vm, Result) { fn to_str(vm: &Vm, val: JsValue) -> String { if val.is_string() { - vm.kernel().string_forge().lookup(val.as_string_index()).unwrap_or_default() + vm.kernel_core().string_forge().lookup(val.as_string_index()).unwrap_or_default() } else { format!("{}", val) }