Struct NativeCx 

pub struct NativeCx<'a> { /* private fields */ }

The embedder’s view of a running engine: the heap, the realm, the services and the code store, owned (Runtime::native_cx) or borrowed (inside a host function).

Implementations

impl<'a> NativeCx<'a>

pub fn reborrow(&mut self) -> NativeCx<'_>

The same view for a shorter borrow.

pub fn compiler(&mut self, transient: bool) -> Compiler<'_>

The heap, the code store and the realm for a compilation. Its units go in the code store when the store is owned and transient is false, else in the heap: inside a host function the running loop borrows the store, so code compiled there is transient whatever transient says.

pub fn owns_code(&self) -> bool

Whether the code store is the runtime’s own (between entries), not the running loop’s (inside a host function).

pub fn heap(&self) -> &Heap

pub fn heap_mut(&mut self) -> &mut Heap

pub fn realm(&self) -> &'a Realm

pub fn interrupt_flag(&self) -> Arc<AtomicBool>

The flag another thread sets to interrupt the running script.

pub fn is_interrupted(&self) -> bool

Whether an interrupt is unwinding (the last throw was one).

pub fn clear_interrupted(&mut self)

Ends an interrupt’s unwinding, at the outermost entry: the runtime runs scripts again.

pub fn install_std(&mut self) -> Result<(), HeapError>

Runtime::install_std.

pub fn install_qjs_helpers( &mut self, script_args: Option<&[String]>, ) -> Result<(), HeapError>

Runtime::install_qjs_helpers.

pub fn set_native_stack_budget(&mut self, bytes: usize)

The bytes of host stack nested re-entries into the loop may use.

impl NativeCx<'_>

pub fn call( &mut self, function: Value, this: Value, args: &[Value], ) -> Result<Value, Throw>

Calls function; the result or the thrown value is unrooted. The caller keeps function alive (a handle or a rooted object).

pub fn run_script(&mut self, script: ObjectId) -> Result<Value, Throw>

Runs a script function with the global object as this.

pub fn hold(&mut self, value: Value) -> Handle

Holds value for the embedder until NativeCx::release.

pub fn held(&self, handle: Handle) -> Value

pub fn release(&mut self, handle: Handle)

pub fn global_object(&self) -> ObjectId

pub fn intrinsic(&self, intrinsic: Intrinsic) -> ObjectId

pub fn new_object(&mut self) -> Result<ObjectId, HeapError>

An ordinary object inheriting from %Object.prototype%.

pub fn new_host_function( &mut self, name: &str, length: u32, constructor: bool, data: &[Value], body: Rc<HostFn>, ) -> Result<ObjectId, HeapError>

A host function named name with length, whose body is body and whose captured values are data (read through NativeCall::data). A constructor may be called by new; it gets no prototype property (the embedder defines one). data must be rooted by the caller.

pub fn new_host_object( &mut self, prototype: Option<ObjectId>, data: Rc<dyn Any>, ) -> Result<ObjectId, HeapError>

An object inheriting from prototype (None for null) that holds the embedder’s data, read back by NativeCx::host_data. The datum drops when the object is collected.

pub fn host_data(&self, object: ObjectId) -> Option<Rc<dyn Any>>

The datum of a host object, whatever its type; None for any other object.

pub fn key_from_units( &mut self, units: &[u16], ) -> Result<PropertyKey, HeapError>

The property key of the string units (an array index when it is one’s canonical form).

pub fn key_from_symbol(&self, symbol: Value) -> Option<PropertyKey>

The key of a symbol value; None for any other value.

pub fn to_property_key(&mut self, value: Value) -> Result<PropertyKey, Throw>

ToPropertyKey(value).

pub fn key_name(&self, key: PropertyKey) -> KeyName

pub fn get( &mut self, object: ObjectId, key: PropertyKey, receiver: Value, ) -> Result<Value, Throw>

object.[[Get]](key, receiver).

pub fn set( &mut self, object: ObjectId, key: PropertyKey, value: Value, receiver: Value, ) -> Result<bool, Throw>

object.[[Set]](key, value, receiver).

pub fn get_own_property( &mut self, object: ObjectId, key: PropertyKey, ) -> Result<Option<PropertyDescriptor>, Throw>

object.[[GetOwnProperty]](key).

pub fn define_own_property( &mut self, object: ObjectId, key: PropertyKey, descriptor: &PropertyDescriptor, ) -> Result<bool, Throw>

object.[[DefineOwnProperty]](key, descriptor).

pub fn delete_property( &mut self, object: ObjectId, key: PropertyKey, ) -> Result<bool, Throw>

object.[[Delete]](key).

pub fn has_property( &mut self, object: ObjectId, key: PropertyKey, ) -> Result<bool, Throw>

HasProperty(object, key).

pub fn has_own_property( &mut self, object: ObjectId, key: PropertyKey, ) -> Result<bool, Throw>

HasOwnProperty(object, key).

pub fn own_property_keys( &mut self, object: ObjectId, ) -> Result<Vec<PropertyKey>, Throw>

object.[[OwnPropertyKeys]]().

pub fn get_prototype_of( &mut self, object: ObjectId, ) -> Result<Option<ObjectId>, Throw>

object.[[GetPrototypeOf]]().

pub fn set_prototype_of( &mut self, object: ObjectId, prototype: Option<ObjectId>, ) -> Result<bool, Throw>

object.[[SetPrototypeOf]](prototype).

pub fn prevent_extensions(&mut self, object: ObjectId) -> Result<bool, Throw>

object.[[PreventExtensions]]().

pub fn construct( &mut self, function: Value, args: &[Value], new_target: Value, ) -> Result<Value, Throw>

Construct(function, args, new_target); new_target is function itself for a plain new.

pub fn is_callable(&self, value: Value) -> bool

IsCallable(value).

pub fn is_constructor(&self, value: Value) -> bool

IsConstructor(value).

pub fn is_array(&mut self, value: Value) -> Result<bool, Throw>

IsArray(value): throws for a revoked proxy.

pub fn is_error(&self, value: Value) -> bool

Whether value is an Error instance (has [[ErrorData]]).

pub fn is_promise(&mut self, value: Value) -> bool

Whether value is a promise.

pub fn object_kind(&self, object: ObjectId) -> ObjectKind

pub fn new_object_with_prototype( &mut self, prototype: Option<ObjectId>, ) -> Result<ObjectId, HeapError>

An ordinary object inheriting from prototype (None for null).

pub fn new_array_from(&mut self, values: &[Value]) -> Result<ObjectId, Throw>

CreateArrayFromList(values).

pub fn new_error( &mut self, kind: ErrorKind, message: &str, ) -> Result<Value, HeapError>

A new error object of kind with message, a stack from the running frames.

pub fn new_located_error( &mut self, kind: ErrorKind, message: &str, file: &str, line: u32, column: u32, ) -> Result<Value, HeapError>

A new error object located at file:line:column (a compile error): fileName, lineNumber and columnNumber, and a stack that starts there, the running frames after it.

pub fn new_promise_capability( &mut self, ) -> Result<(ObjectId, ObjectId, ObjectId), Throw>

NewPromiseCapability(%Promise%): the promise and its resolving functions, unrooted.

pub fn new_promise(&mut self) -> Result<ObjectId, Throw>

A pending promise of %Promise.prototype%.

pub fn new_array_buffer(&mut self, len: usize) -> Result<ObjectId, Throw>

A new ArrayBuffer of len zero bytes; a RangeError past MAX_BUFFER_LENGTH.

pub fn array_buffer_len(&self, object: ObjectId) -> Option<usize>

A buffer’s length in bytes; None when object is not a buffer or is detached.

pub fn array_buffer_read( &mut self, object: ObjectId, offset: usize, out: &mut [u8], ) -> Result<(), Throw>

Copies out.len() bytes of the buffer from offset (a shared buffer’s byte by byte through its atomics).

pub fn array_buffer_write( &mut self, object: ObjectId, offset: usize, data: &[u8], ) -> Result<(), Throw>

Writes data into the buffer at offset.

pub fn array_buffer_bytes(&self, object: ObjectId) -> Option<&[u8]>

The bytes of an attached ArrayBuffer; None for anything else, a SharedArrayBuffer included (its bytes are atomics).

pub fn typed_array_view( &self, object: ObjectId, ) -> Option<(ElementKind, ObjectId, usize, Option<usize>)>

A typed array’s element kind, buffer, byte offset and current length (None when it is out of bounds of its buffer or the buffer is detached); None for anything but a typed array.

pub fn detach_array_buffer(&mut self, value: Value) -> Result<(), Throw>

QuickJS’s JS_DetachArrayBuffer: detaches an ArrayBuffer; anything else is ignored.

pub fn new_string(&mut self, text: &str) -> Result<Value, HeapError>

pub fn new_string_units(&mut self, units: &[u16]) -> Result<Value, HeapError>

pub fn new_string_repr(&mut self, repr: StringRepr) -> Result<Value, HeapError>

A string of repr, which the caller made canonical (OneByte whenever every unit fits in a byte).

pub fn string_repr(&self, value: Value) -> Option<&StringRepr>

A string value’s code units, flattened; None for any other value.

pub fn string_lossy(&self, value: Value) -> Option<String>

A string value as Rust text (lone surrogates replaced).

pub fn new_bigint(&mut self, decimal: &str) -> Option<Result<Value, HeapError>>

The BigInt of the decimal text decimal (an optional -, then digits); None when it does not parse.

pub fn bigint_decimal(&self, value: Value) -> Option<String>

A BigInt value in decimal; None for any other value.

pub fn new_symbol( &mut self, description: Option<&[u16]>, ) -> Result<Value, HeapError>

A new symbol with description (Symbol(description)).

pub fn symbol_description(&self, value: Value) -> Option<Vec<u16>>

A symbol’s [[Description]]; None when it is undefined or value is not a symbol.

pub fn well_known_symbol(&self, name: &str) -> Option<Value>

The well-known symbol Symbol.<name> ("iterator", …).

pub fn well_known_symbol_key(&self, name: &str) -> Option<PropertyKey>

pub fn to_string(&mut self, value: Value) -> Result<Value, Throw>

ToString(value).

pub fn to_number(&mut self, value: Value) -> Result<f64, Throw>

ToNumber(value).

pub fn to_boolean(&self, value: Value) -> bool

ToBoolean(value).

pub fn to_object(&mut self, value: Value) -> Result<ObjectId, Throw>

ToObject(value).

pub fn strict_equals(&self, x: Value, y: Value) -> bool

IsStrictlyEqual(x, y).

pub fn loose_equals(&mut self, x: Value, y: Value) -> Result<bool, Throw>

IsLooselyEqual(x, y).

pub fn same_value(&mut self, x: Value, y: Value) -> bool

SameValue(x, y).

pub fn same_value_zero(&self, x: Value, y: Value) -> bool

SameValueZero(x, y).

pub fn type_of(&mut self, value: Value) -> String

typeof value.

pub fn kind_of(&self, value: Value) -> Kind

The kind of a value without running JavaScript.

pub fn run_gc(&mut self)

Runs a full collection. Only between entries: the embedder’s handles and the fixed roots are the roots.

impl NativeCx<'_>

pub fn forget_module(&mut self, name: &str)

Runtime::forget_module.

pub fn run_module(&mut self, name: &str) -> Result<Value, Throw>

Runtime::run_module.

pub fn promise_state(&mut self, promise: Value) -> Option<(i32, Value)>

Runtime::promise_state.

impl NativeCx<'_>

pub fn print_value(&mut self, value: Value) -> String

Runtime::print_value.

pub fn print_value_bytes(&mut self, value: Value) -> Vec<u8>

Runtime::print_value_bytes.