pub interp: Interpreter,

pub scope: Scope,

/// you can put a Rc in here, keep it as a Weak, and it'll be held only for

/// as long as the StoredVM is alive

held_objects: RefCell<Vec<PyObjectRef>>,

future_features: RefCell<CodeFlags>,

match err {

VmCompileError::Compile(err) => convert::syntax_err(err).into(),

err => convert::py_err_to_js_err(vm, &err.into_pyexception(vm, None)),

}

let parser_options = compiler::parser::ParseOptions::from(compiler::parser::Mode::Module);

let prepared = compiler::prepare_barry_as_flufl_source(

source,

parser_options.clone(),

future_features.contains(CodeFlags::FUTURE_BARRY_AS_BDFL),

);

let module = compiler::parser::parse(prepared.source(), parser_options)

.ok()?

.into_syntax()

.expect_module();

module

.body

.iter()

.map(|stmt| {

let range = stmt.range();

source.get(range.start().to_usize()..range.end().to_usize())

})

.collect()

use super::{js_module, wasm_builtins};

use rustpython_vm::{Py, PyPayload, PyResult, VirtualMachine, builtins::PyModule};

#[expect(clippy::unnecessary_wraps, reason = "Needs to comply with a signature")]

pub(crate) fn module_exec(vm: &VirtualMachine, module: &Py<PyModule>) -> PyResult<()> {

__module_exec(vm, module);

extend_module!(vm, module, {

"window" => js_module::PyJsValue::new(wasm_builtins::window()).into_ref(&vm.ctx),

});

Ok(())

}

fn new(id: String, inject_browser_module: bool) -> Self {

let mut settings = Settings::default();

settings.allow_external_library = false;

let mut builder = Interpreter::builder(settings);

#[cfg(feature = "freeze-stdlib")]

{

let defs = rustpython_stdlib::stdlib_module_defs(&builder.ctx);

builder = builder

.add_native_modules(&defs)

.add_frozen_modules(rustpython_pylib::FROZEN_STDLIB);

}

// Add wasm-specific modules. Browser `_ssl` / `_socket` live here

// rather than rustpython-stdlib: there are no BSD sockets, and rustls

// is driven through MemoryBIO / wrap_bio.

let js_def = js_module::module_def(&builder.ctx);

builder = builder.add_native_module(js_def);

#[cfg(all(target_arch = "wasm32", not(target_os = "wasi")))]

{

install_browser_tls_provider();

let ssl_def = crate::ssl::module_def(&builder.ctx);

let socket_def = crate::socket::module_def(&builder.ctx);

builder = builder.add_native_modules(&[ssl_def, socket_def]);

}

if inject_browser_module {

let window_def = _window::module_def(&builder.ctx);

let browser_def = browser_module::module_def(&builder.ctx);

builder = builder

.add_native_modules(&[window_def, browser_def])

.add_frozen_modules(rustpython_vm::py_freeze!(dir = "../Lib"));

}

let interp = builder

.init_hook(move |vm| {

vm.wasm_id = Some(id);

})

.build();

let scope = interp.enter(|vm| vm.new_scope_with_builtins());

Self {

interp,

scope,

held_objects: RefCell::new(Vec::new()),

future_features: RefCell::new(CodeFlags::empty()),

}

}

use rustls::Error;

use rustpython_host_env::ssl::providers::CryptoExt;

use std::sync::Arc;

fn no_ticketer() -> Result<Arc<dyn rustls::server::ProducesTickets>, Error> {

Err(Error::General("TLS session tickets are unavailable".into()))

}

let ext = CryptoExt {

all_cipher_suites: None,

default_cipher_suites: None,

all_kx_groups: None,

any_supported_key: Some(rustls_rustcrypto::sign::any_supported_type),

ticketer: no_ticketer,

};

let _ = CryptoExt::set_provider(rustls_rustcrypto::provider(), ext);

vm.wasm_id

.as_ref()

.expect("VirtualMachine inside of WASM crate should have wasm_id set")

STORED_VMS.with_borrow(|vms| {

vms.get(&wasm_vm.id)

.expect("VirtualMachine is not valid")

.clone()

})

#[must_use]

pub fn init(id: String, inject_browser_module: Option<bool>) -> WASMVirtualMachine {

STORED_VMS.with_borrow_mut(|vms| {

if !vms.contains_key(&id) {

let stored_vm =

StoredVirtualMachine::new(id.clone(), inject_browser_module.unwrap_or(true));

vms.insert(id.clone(), Rc::new(stored_vm));

}

});

WASMVirtualMachine { id }

}

pub(crate) fn _get(id: String) -> Option<WASMVirtualMachine> {

STORED_VMS.with_borrow(|vms| vms.contains_key(&id).then_some(WASMVirtualMachine { id }))

}

#[must_use]

pub fn get(id: String) -> JsValue {

match Self::_get(id) {

Some(wasm_vm) => wasm_vm.into(),

None => JsValue::UNDEFINED,

}

}

pub fn destroy(id: String) {

STORED_VMS.with_borrow_mut(|vms| {

if let Some(stored_vm) = vms.remove(&id) {

// for f in stored_vm.drop_handlers.iter() {

// f();

// }

// deallocate the VM

drop(stored_vm);

}

});

}

#[must_use]

pub fn ids() -> Vec<JsValue> {

STORED_VMS.with_borrow(|vms| vms.keys().map(|k| k.into()).collect())

}

pub(crate) fn with_unchecked<F, R>(&self, f: F) -> R

where

F: FnOnce(&StoredVirtualMachine) -> R,

{

let stored_vm = STORED_VMS.with_borrow_mut(|vms| vms.get_mut(&self.id).unwrap().clone());

f(&stored_vm)

}

pub(crate) fn with<F, R>(&self, f: F) -> Result<R, JsValue>

where

F: FnOnce(&StoredVirtualMachine) -> R,

{

self.assert_valid()?;

Ok(self.with_unchecked(f))

}

pub(crate) fn with_vm<F, R>(&self, f: F) -> Result<R, JsValue>

where

F: FnOnce(&VirtualMachine, &StoredVirtualMachine) -> R,

{

self.with(|stored| stored.interp.enter(|vm| f(vm, stored)))

}

#[must_use]

pub fn valid(&self) -> bool {

STORED_VMS.with_borrow(|vms| vms.contains_key(&self.id))

}

pub(crate) fn push_held_rc(

&self,

obj: PyObjectRef,

) -> Result<PyResult<PyRef<PyWeak>>, JsValue> {

self.with_vm(|vm, stored_vm| {

let weak = obj.downgrade(None, vm)?;

stored_vm.held_objects.borrow_mut().push(obj);

Ok(weak)

})

}

pub fn assert_valid(&self) -> Result<(), JsValue> {

if self.valid() {

Ok(())

} else {

Err(TypeError::new(

"Invalid VirtualMachine, this VM was destroyed while this reference was still held",

)

.into())

}

}

pub fn destroy(&self) -> Result<(), JsValue> {

self.assert_valid()?;

VMStore::destroy(self.id.clone());

Ok(())

}

#[wasm_bindgen(js_name = addToScope)]

pub fn add_to_scope(&self, name: String, value: JsValue) -> Result<(), JsValue> {

self.with_vm(move |vm, StoredVirtualMachine { scope, .. }| {

let value = convert::js_to_py(vm, value);

scope.globals.set_item(&name, value, vm).into_js(vm)

})?

}

#[wasm_bindgen(js_name = setStdout)]

pub fn set_stdout(&self, stdout: JsValue) -> Result<(), JsValue> {

self.set_stdstream(

"stdout",

"JSStdout",

stdout,

wasm_builtins::sys_stdout_write_console,

)

}

#[wasm_bindgen(js_name = setStderr)]

pub fn set_stderr(&self, stderr: JsValue) -> Result<(), JsValue> {

self.set_stdstream(

"stderr",

"JSStderr",

stderr,

wasm_builtins::sys_stderr_write_console,

)

}

fn set_stdstream(

&self,

attr: &'static str,

class_name: &'static str,

stream: JsValue,

console_write: fn(&str, &VirtualMachine) -> PyResult<()>,

) -> Result<(), JsValue> {

self.with_vm(|vm, _| {

fn error(attr: &str) -> JsValue {

TypeError::new(&format!(

"Unknown {attr} option, please pass a function or 'console'"

))

.into()

}

use wasm_builtins::make_stdstream_object;

let stream: PyObjectRef = if let Some(s) = stream.as_string() {

match s.as_str() {

"console" => make_stdstream_object(vm, class_name, console_write),

_ => return Err(error(attr)),

}

} else if stream.is_function() {

let func = js_sys::Function::from(stream);

make_stdstream_object(vm, class_name, move |data, vm| {

func.call1(&JsValue::UNDEFINED, &data.into())

.map_err(|err| convert::js_py_typeerror(vm, err))?;

Ok(())

})

} else if stream.is_null() {

make_stdstream_object(vm, class_name, |_, _| Ok(()))

} else if stream.is_undefined() {

make_stdstream_object(vm, class_name, console_write)

} else {

return Err(error(attr));

};

vm.sys_module.set_attr(attr, stream, vm).unwrap();

Ok(())

})?

}

#[wasm_bindgen(js_name = injectModule)]

pub fn inject_module(

&self,

name: String,

source: &str,

imports: Option<Object>,

) -> Result<(), JsValue> {

self.with_vm(|vm, _| {

let code = vm

.compile(source, Mode::Exec, name.as_str())

.map_err(|err| compile_err_to_js(vm, err))?;

let attrs = vm.ctx.new_dict();

attrs

.set_item("__name__", vm.new_pyobj(name.as_str()), vm)

.into_js(vm)?;

if let Some(imports) = imports {

for entry in convert::object_entries(&imports) {

let (key, value) = entry?;

attrs

.set_item(

&*convert::js_string_to_wtf8(&key.into()),

convert::js_to_py(vm, value),

vm,

)

.into_js(vm)?;

}

}

vm.run_code_obj(

code,

Scope::new(

Some(ArgMapping::from_dict_exact(attrs.clone())),

attrs.clone(),

),

)

.into_js(vm)?;

let module = vm.new_module(&name, attrs, None);

let sys_modules = vm.sys_module.get_attr("modules", vm).into_js(vm)?;

sys_modules.set_item(&name, module.into(), vm).into_js(vm)?;

Ok(())

})?

}

#[wasm_bindgen(js_name = injectJSModule)]

pub fn inject_js_module(&self, name: String, module: Object) -> Result<(), JsValue> {

self.with_vm(|vm, _| {

let py_module = vm.new_module(&name, vm.ctx.new_dict(), None);

for entry in convert::object_entries(&module) {

let (key, value) = entry?;

let key = vm.ctx.new_str(convert::js_string_to_wtf8(&key.into()));

py_module

.set_attr(&key, convert::js_to_py(vm, value), vm)

.into_js(vm)?;

}

let sys_modules = vm.sys_module.get_attr("modules", vm).into_js(vm)?;

sys_modules

.set_item(&name, py_module.into(), vm)

.into_js(vm)?;

Ok(())

})?

}

pub(crate) fn run(

&self,

source: &str,

mode: Mode,

source_path: Option<String>,

) -> Result<JsValue, JsValue> {

self.with_vm(|vm, StoredVirtualMachine { scope, .. }| {

let source_path = source_path.unwrap_or_else(|| "<wasm>".to_owned());

let code = vm.compile(source, mode, source_path.as_str());

let code = code.map_err(|err| compile_err_to_js(vm, err))?;

let result = vm.run_code_obj(code, scope.clone());

convert::pyresult_to_js_result(vm, result)

})?

}

pub(crate) fn run_single(

&self,

source: &str,

source_path: Option<String>,

) -> Result<JsValue, JsValue> {

self.with_vm(|vm, stored| {

let scope = &stored.scope;

let source_path = source_path.unwrap_or_else(|| "<wasm>".to_owned());

let compile = |source: &str, mode: Mode| -> Result<_, JsValue> {

let future_features = *stored.future_features.borrow();

let opts = compiler::CompileOpts {

future_features,

..vm.compile_opts()

};

let code = vm

.compile_with_opts(source, mode, source_path.as_str(), opts)

.map_err(|err| compile_err_to_js(vm, err))?;

*stored.future_features.borrow_mut() |= code.code.flags & CodeFlags::FUTURE_MASK;

Ok(code)

};

let future_features = *stored.future_features.borrow();

let Some(chunks) = statement_chunks(source, future_features) else {

let code = compile(source, Mode::Single)?;

let result = vm.run_code_obj(code, scope.clone());

return convert::pyresult_to_js_result(vm, result);

};

if chunks.is_empty() {

return Ok(convert::py_to_js(vm, vm.ctx.none()));

}

let displayhook = vm

.sys_module

.get_attr("displayhook", vm)

.map_err(|_| TypeError::new("lost sys.displayhook"))?;

let mut result = vm.ctx.none();

for chunk in chunks {

let code = compile(chunk, Mode::BlockExpr)?;

result = vm.run_code_obj(code, scope.clone()).into_js(vm)?;

displayhook.call((result.clone(),), vm).into_js(vm)?;

}

Ok(convert::py_to_js(vm, result))

})?

}

pub fn exec(&self, source: &str, source_path: Option<String>) -> Result<JsValue, JsValue> {

self.run(source, Mode::Exec, source_path)

}

pub fn eval(&self, source: &str, source_path: Option<String>) -> Result<JsValue, JsValue> {

self.run(source, Mode::Eval, source_path)

}

#[wasm_bindgen(js_name = execSingle)]

pub fn exec_single(

&self,

source: &str,

source_path: Option<String>,

) -> Result<JsValue, JsValue> {

self.run_single(source, source_path)

}