From 26a362804f87abd704ca9d76e3cc9b7926396d79 Mon Sep 17 00:00:00 2001 From: Michael Wu Date: Tue, 21 Apr 2015 13:01:52 -0400 Subject: [PATCH 1/2] Upgrade to SM 39 --- Cargo.toml | 1 + makefile.cargo | 2 +- src/glue.rs | 337 +- src/jsapi.rs | 13801 +++++++++++++++++++++++++++++++++++++++---- src/jsfriendapi.rs | 68 - src/jsglue.cpp | 606 +- src/jsval.rs | 222 +- src/lib.rs | 133 +- src/linkhack.rs | 2 + src/rust.rs | 612 +- 10 files changed, 13899 insertions(+), 1885 deletions(-) delete mode 100644 src/jsfriendapi.rs diff --git a/Cargo.toml b/Cargo.toml index 0f4920f9f..b03fb0fc8 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -16,3 +16,4 @@ git = "https://github.com/servo/mozjs" libc = "*" rustc-serialize = "*" log = "*" +num = "*" diff --git a/makefile.cargo b/makefile.cargo index 3d3ea09dd..4da948548 100644 --- a/makefile.cargo +++ b/makefile.cargo @@ -10,7 +10,7 @@ AR ?= ar endif -CFLAGS += -fPIC -DJS_NO_JSVAL_JSID_STRUCT_TYPES +CFLAGS += -fPIC -std=c++11 -DJS_NO_JSVAL_JSID_STRUCT_TYPES ifeq ($(shell $(CXX) -v 2>&1 | grep -c 'clang version\|Apple.*clang'),1) CFLAGS += -Wno-c++0x-extensions -Wno-return-type-c-linkage -Wno-invalid-offsetof diff --git a/src/glue.rs b/src/glue.rs index 730531655..f5ed57ded 100644 --- a/src/glue.rs +++ b/src/glue.rs @@ -1,118 +1,231 @@ -/* This Source Code Form is subject to the terms of the Mozilla Public - * License, v. 2.0. If a copy of the MPL was not distributed with this file, - * You can obtain one at http://mozilla.org/MPL/2.0/. */ - -/* automatically generated by rust-bindgen */ - -use libc; use jsapi::*; -use jsfriendapi::JSJitInfo; -use jsval::JSVal; - -pub const JS_STRUCTURED_CLONE_VERSION: u32 = 1; -pub struct ProxyTraps { - pub getPropertyDescriptor: Option bool>, - pub getOwnPropertyDescriptor: Option bool>, - pub defineProperty: Option bool>, - pub getOwnPropertyNames: Option bool>, - pub delete_: Option bool>, - pub enumerate: Option bool>, +pub const JS_STRUCTURED_CLONE_VERSION: u32 = 5; - pub has: Option bool>, - pub hasOwn: Option bool>, - pub get: Option bool>, - pub set: Option bool>, - pub keys: Option bool>, - pub iterate: Option bool>, +pub enum Action { } +unsafe impl Sync for ProxyTraps { } +/* automatically generated by rust-bindgen */ - pub call: Option bool>, - pub construct: Option bool>, - pub nativeCall: *const u8, //XXX need a representation for IsAcceptableThis, NativeImpl, and CallArgs - pub hasInstance: Option bool>, - pub typeOf: Option usize>, //XXX JSType enum - pub objectClassIs: Option bool>, //XXX ESClassValue enum - pub obj_toString: Option *mut JSString>, - pub fun_toString: Option *mut JSString>, - //regexp_toShared: *u8, - pub defaultValue: Option bool>, //XXX JSType enum - pub iteratorNext: Option bool>, - pub finalize: Option, - pub getElementIfPresent: Option bool>, - pub getPrototypeOf: Option bool>, - pub trace: Option, +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ProxyTraps { + pub enter: ::std::option::Option u8>, + pub getOwnPropertyDescriptor: ::std::option::Option) + -> u8>, + pub defineProperty: ::std::option::Option, + result: + *mut ObjectOpResult) + -> u8>, + pub ownPropertyKeys: ::std::option::Option u8>, + pub delete_: ::std::option::Option u8>, + pub enumerate: ::std::option::Option u8>, + pub preventExtensions: ::std::option::Option u8>, + pub isExtensible: ::std::option::Option u8>, + pub has: ::std::option::Option u8>, + pub get: ::std::option::Option u8>, + pub set: ::std::option::Option u8>, + pub call: ::std::option::Option u8>, + pub construct: ::std::option::Option u8>, + pub getPropertyDescriptor: ::std::option::Option) + -> u8>, + pub hasOwn: ::std::option::Option u8>, + pub getOwnEnumerablePropertyKeys: ::std::option::Option u8>, + pub nativeCall: ::std::option::Option u8>, + pub hasInstance: ::std::option::Option u8>, + pub objectClassIs: ::std::option::Option u8>, + pub className: ::std::option::Option *const i8>, + pub fun_toString: ::std::option::Option *mut JSString>, + pub boxedValue_unbox: ::std::option::Option u8>, + pub defaultValue: ::std::option::Option u8>, + pub trace: ::std::option::Option, + pub finalize: ::std::option::Option, + pub objectMoved: ::std::option::Option, + pub isCallable: ::std::option::Option u8>, + pub isConstructor: ::std::option::Option u8>, } -unsafe impl Sync for ProxyTraps {} - -pub enum AutoIdVector {} - -#[link(name = "jsglue")] -extern { } - -#[cfg(target_os = "android")] -#[link(name = "stdc++")] -extern { } - -#[cfg(target_os = "android")] -#[link(name = "gcc")] -extern { } - -extern { - -//#[rust_stack] -pub fn RUST_JS_NumberValue(d: f64) -> JSVal; - -//#[rust_stack] -pub fn CallJitPropertyOp(info: *const JSJitInfo, cx: *mut JSContext, thisObj: *mut JSObject, specializedThis: *mut libc::c_void, vp: *mut JSVal) -> JSBool; - -//#[rust_stack] -pub fn CallJitMethodOp(info: *const JSJitInfo, cx: *mut JSContext, thisObj: *mut JSObject, specializedThis: *mut libc::c_void, argc: libc::c_uint, vp: *mut JSVal) -> JSBool; - -//#[rust_stack] -pub fn RUST_FUNCTION_VALUE_TO_JITINFO(v: JSVal) -> *const JSJitInfo; - -pub fn SetFunctionNativeReserved(fun: *mut JSObject, which: libc::size_t, val: *mut JSVal); -pub fn GetFunctionNativeReserved(fun: *mut JSObject, which: libc::size_t) -> *mut JSVal; - -pub fn CreateProxyHandler(traps: *const ProxyTraps, extra: *const libc::c_void) -> *const libc::c_void; -pub fn CreateWrapperProxyHandler(traps: *const ProxyTraps) -> *const libc::c_void; -pub fn NewProxyObject(cx: *mut JSContext, handler: *const libc::c_void, priv_: *const JSVal, - proto: *mut JSObject, parent: *mut JSObject, call: *mut JSObject, - construct: *mut JSObject) -> *mut JSObject; -pub fn WrapperNew(cx: *mut JSContext, parent: *mut JSObject, handler: *const libc::c_void) -> *mut JSObject; - -pub fn GetProxyExtra(obj: *mut JSObject, slot: libc::c_uint) -> JSVal; -pub fn GetProxyPrivate(obj: *mut JSObject) -> JSVal; -pub fn SetProxyExtra(obj: *mut JSObject, slot: libc::c_uint, val: JSVal); - -pub fn GetObjectProto(obj: *mut JSObject) -> *mut JSObject; -pub fn GetObjectParent(obj: *mut JSObject) -> *mut JSObject; - -pub fn RUST_JSID_IS_INT(id: jsid) -> JSBool; -pub fn RUST_JSID_TO_INT(id: jsid) -> libc::c_int; -pub fn RUST_JSID_IS_STRING(id: jsid) -> JSBool; -pub fn RUST_JSID_TO_STRING(id: jsid) -> *mut JSString; - -pub fn RUST_SET_JITINFO(func: *mut JSFunction, info: *const JSJitInfo); - -pub fn RUST_INTERNED_STRING_TO_JSID(cx: *mut JSContext, str: *mut JSString) -> jsid; - -pub fn DefineFunctionWithReserved(cx: *mut JSContext, obj: *mut JSObject, - name: *const libc::c_char, call: JSNative, nargs: libc::c_uint, - attrs: libc::c_uint) -> *mut JSObject; -pub fn GetObjectJSClass(obj: *mut JSObject) -> *mut JSClass; -pub fn RUST_js_GetErrorMessage(userRef: *mut libc::c_void, locale: *const libc::c_char, - errorNumber: libc::c_uint) -> *const JSErrorFormatString; -pub fn js_IsObjectProxyClass(obj: *mut JSObject) -> bool; -pub fn js_IsFunctionProxyClass(obj: *mut JSObject) -> bool; -pub fn IsProxyHandlerFamily(obj: *mut JSObject) -> bool; -pub fn GetProxyHandlerExtra(obj: *mut JSObject) -> *const libc::c_void; -pub fn GetProxyHandler(obj: *mut JSObject) -> *mut libc::c_void; -pub fn InvokeGetOwnPropertyDescriptor(handler: *mut libc::c_void, cx: *mut JSContext, proxy: *mut JSObject, id: jsid, set: bool, desc: *mut JSPropertyDescriptor) -> bool; -pub fn GetGlobalForObjectCrossCompartment(obj: *mut JSObject) -> *mut JSObject; -pub fn ReportError(cx: *mut JSContext, error: *const libc::c_char); -pub fn IsWrapper(obj: *mut JSObject) -> JSBool; -pub fn UnwrapObject(obj: *mut JSObject, stopAtOuter: JSBool, flags: *mut libc::c_uint) -> *mut JSObject; - -pub fn AppendToAutoIdVector(v: *mut AutoIdVector, id: jsid) -> bool; +impl ::std::default::Default for ProxyTraps { + fn default() -> ProxyTraps { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct WrapperProxyHandler { + pub mTraps: ProxyTraps, +} +impl ::std::default::Default for WrapperProxyHandler { + fn default() -> WrapperProxyHandler { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ForwardingProxyHandler { + pub mTraps: ProxyTraps, + pub mExtra: *const ::libc::c_void, +} +impl ::std::default::Default for ForwardingProxyHandler { + fn default() -> ForwardingProxyHandler { unsafe { ::std::mem::zeroed() } } +} +extern "C" { + pub fn InvokeGetOwnPropertyDescriptor(handler: *const ::libc::c_void, + cx: *mut JSContext, + proxy: HandleObject, id: HandleId, + desc: + MutableHandle) + -> u8; + pub fn RUST_JS_NumberValue(d: f64) -> Value; + pub fn RUST_FUNCTION_VALUE_TO_JITINFO(v: Value) -> *const JSJitInfo; + pub fn CallJitGetterOp(info: *const JSJitInfo, cx: *mut JSContext, + thisObj: HandleObject, + specializedThis: *mut ::libc::c_void, argc: u32, + vp: *mut Value) -> u8; + pub fn CallJitSetterOp(info: *const JSJitInfo, cx: *mut JSContext, + thisObj: HandleObject, + specializedThis: *mut ::libc::c_void, argc: u32, + vp: *mut Value) -> u8; + pub fn CallJitMethodOp(info: *const JSJitInfo, cx: *mut JSContext, + thisObj: HandleObject, + specializedThis: *mut ::libc::c_void, argc: u32, + vp: *mut Value) -> u8; + pub fn CreateProxyHandler(aTraps: *const ProxyTraps, + aExtra: *const ::libc::c_void) + -> *const ::libc::c_void; + pub fn CreateWrapperProxyHandler(aTraps: *const ProxyTraps) + -> *const ::libc::c_void; + pub fn NewCompileOptions(aCx: *mut JSContext, aFile: *const i8, + aLine: u32) -> *mut ReadOnlyCompileOptions; + pub fn DeleteCompileOptions(aOpts: *mut ReadOnlyCompileOptions); + pub fn NewProxyObject(aCx: *mut JSContext, + aHandler: *const ::libc::c_void, aPriv: HandleValue, + proto: *mut JSObject, parent: *mut JSObject, + call: *mut JSObject, construct: *mut JSObject) + -> *mut JSObject; + pub fn WrapperNew(aCx: *mut JSContext, aObj: HandleObject, + aHandler: *const ::libc::c_void) + -> *mut JSObject; + pub fn GetProxyExtra(obj: *mut JSObject, slot: u32) -> Value; + pub fn GetProxyPrivate(obj: *mut JSObject) -> Value; + pub fn SetProxyExtra(obj: *mut JSObject, slot: u32, val: Value); + pub fn RUST_JSID_IS_INT(id: HandleId) -> u8; + pub fn RUST_JSID_TO_INT(id: HandleId) -> i32; + pub fn RUST_JSID_IS_STRING(id: HandleId) -> u8; + pub fn RUST_JSID_TO_STRING(id: HandleId) -> *mut JSString; + pub fn RUST_SET_JITINFO(func: *mut JSFunction, info: *const JSJitInfo); + pub fn RUST_INTERNED_STRING_TO_JSID(cx: *mut JSContext, + str: *mut JSString) -> jsid; + pub fn RUST_js_GetErrorMessage(userRef: *mut ::libc::c_void, + errorNumber: u32) + -> *const JSErrorFormatString; + pub fn IsProxyHandlerFamily(obj: *mut JSObject) -> u8; + pub fn GetProxyHandlerExtra(obj: *mut JSObject) -> *const ::libc::c_void; + pub fn GetProxyHandler(obj: *mut JSObject) -> *const ::libc::c_void; + pub fn ReportError(aCx: *mut JSContext, aError: *const i8); + pub fn IsWrapper(obj: *mut JSObject) -> u8; + pub fn UnwrapObject(obj: *mut JSObject, stopAtOuter: u8) -> *mut JSObject; + pub fn AppendToAutoIdVector(v: *mut AutoIdVector, id: jsid) -> u8; + pub fn CreateAutoObjectVector(aCx: *mut JSContext) + -> *mut AutoObjectVector; + pub fn AppendToAutoObjectVector(v: *mut AutoObjectVector, + obj: *mut JSObject) -> u8; + pub fn DeleteAutoObjectVector(v: *mut AutoObjectVector); } diff --git a/src/jsapi.rs b/src/jsapi.rs index 254974995..782075bcf 100644 --- a/src/jsapi.rs +++ b/src/jsapi.rs @@ -1,1261 +1,12696 @@ -/* automatically generated by rust-bindgen */ +use libc::types::common::c95::FILE; + +pub type JSConstDoubleSpec = JSConstScalarSpec; +pub type JSConstIntegerSpec = JSConstScalarSpec; + +#[derive(Copy, Clone)] +pub enum Impl { } +pub enum Cell { } +pub enum Entry { } +pub enum va_list { } +#[derive(Copy, Clone)] +pub enum VectorImpl { } +#[derive(Copy, Clone)] +pub enum HashMapImpl { } +#[derive(Copy, Clone)] +pub enum HashSetImpl { } +#[repr(i32)] +#[derive(Copy, Clone)] +pub enum Override { + Default = 0, + ForceTrue = 1, + ForceFalse = 2, +} +#[derive(Copy, Clone)] +pub enum State { } +pub enum ArgType { } +pub enum Range { } -use libc::*; -use jsfriendapi::JSJitInfo; -use jsval::JSVal; +pub const JSREPORT_ERROR: u32 = 0x0; /* pseudo-flag for default case */ +pub const JSREPORT_WARNING: u32 = 0x1; /* reported via JS_ReportWarning */ +pub const JSREPORT_EXCEPTION: u32 = 0x2; /* exception was thrown */ +pub const JSREPORT_STRICT: u32 = 0x4; /* error or warning due to strict option */ -pub enum JSString {} -pub enum JSFlatString {} -pub enum JSObject {} -pub enum JSScript {} -pub enum JSFunction {} -pub enum JSContext {} -pub enum JSRuntime {} -pub enum JSIdArray {} -pub enum JSExceptionState {} -pub enum JSStructuredCloneReader {} -pub enum JSStructuredCloneWriter {} -pub enum JSCompartment {} -pub enum JSCrossCompartmentCall {} -pub type JSBool = c_int; -pub type jschar = uint16_t; -pub type jsid = ptrdiff_t; -pub type JSCallOnceType = JSBool; -pub type JSInitCallback = *mut u8; +pub const JSREPORT_STRICT_MODE_ERROR: u32 = 0x8; -pub type JSProtoKey = c_uint; -pub const JSProto_LIMIT: JSProtoKey = 41; +unsafe impl Sync for JSClass { } + +/* automatically generated by rust-bindgen */ -#[repr(u32)] +pub type MallocSizeOf = + ::std::option::Option u32>; +pub type MozMallocSizeOf = + ::std::option::Option u32>; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct UniquePtr { + pub mTuple: usize, +} +pub enum JSContext { } +pub enum JSFunction { } +pub enum JSObject { } +pub enum JSScript { } +pub enum JSString { } +pub enum JSAddonId { } +pub type Latin1Char = u8; +pub enum Symbol { } +pub type HandleFunction = Handle<*mut JSFunction>; +pub type HandleId = Handle; +pub type HandleObject = Handle<*mut JSObject>; +pub type HandleScript = Handle<*mut JSScript>; +pub type HandleString = Handle<*mut JSString>; +pub type HandleSymbol = Handle<*mut Symbol>; +pub type HandleValue = Handle; +pub type MutableHandleFunction = MutableHandle<*mut JSFunction>; +pub type MutableHandleId = MutableHandle; +pub type MutableHandleObject = MutableHandle<*mut JSObject>; +pub type MutableHandleScript = MutableHandle<*mut JSScript>; +pub type MutableHandleString = MutableHandle<*mut JSString>; +pub type MutableHandleSymbol = MutableHandle<*mut Symbol>; +pub type MutableHandleValue = MutableHandle; +pub type RootedObject = Rooted<*mut JSObject>; +pub type RootedFunction = Rooted<*mut JSFunction>; +pub type RootedScript = Rooted<*mut JSScript>; +pub type RootedString = Rooted<*mut JSString>; +pub type RootedSymbol = Rooted<*mut Symbol>; +pub type RootedId = Rooted; +pub type RootedValue = Rooted; +pub type PersistentRootedFunction = PersistentRooted<*mut JSFunction>; +pub type PersistentRootedId = PersistentRooted; +pub type PersistentRootedObject = PersistentRooted<*mut JSObject>; +pub type PersistentRootedScript = PersistentRooted<*mut JSScript>; +pub type PersistentRootedString = PersistentRooted<*mut JSString>; +pub type PersistentRootedSymbol = PersistentRooted<*mut Symbol>; +pub type PersistentRootedValue = PersistentRooted; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct FreePolicy; +impl ::std::default::Default for FreePolicy { + fn default() -> FreePolicy { unsafe { ::std::mem::zeroed() } } +} +pub type HashNumber = u32; +pub type UniqueChars = UniquePtr; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct SystemAllocPolicy; +impl ::std::default::Default for SystemAllocPolicy { + fn default() -> SystemAllocPolicy { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct TempAllocPolicy { + pub cx_: *mut ContextFriendFields, +} +impl ::std::default::Default for TempAllocPolicy { + fn default() -> TempAllocPolicy { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct LinkedListElement { + pub mNext: *mut LinkedListElement, + pub mPrev: *mut LinkedListElement, + pub mIsSentinel: u8, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct LinkedList { + pub sentinel: LinkedListElement, +} +#[repr(i32)] +#[derive(Copy, Clone)] pub enum JSVersion { + JSVERSION_ECMA_3 = 148, + JSVERSION_1_6 = 160, + JSVERSION_1_7 = 170, + JSVERSION_1_8 = 180, JSVERSION_DEFAULT = 0, - JSVERSION_LATEST = 185 -} - -#[repr(u32)] -pub enum JSIterateOp { - JSENUMERATE_INIT = 0, - JSENUMERATE_INIT_ALL = 1, - JSENUMERATE_NEXT = 2, - JSENUMERATE_DESTROY = 3, + JSVERSION_UNKNOWN = -1, + JSVERSION_LATEST = 185, } - -#[repr(u32)] +#[repr(i32)] +#[derive(Copy, Clone)] pub enum JSType { - JSTYPE_VOID, /* undefined */ - JSTYPE_OBJECT, /* object */ - JSTYPE_FUNCTION, /* function */ - JSTYPE_STRING, /* string */ - JSTYPE_NUMBER, /* number */ - JSTYPE_BOOLEAN, /* boolean */ - JSTYPE_NULL, /* null */ - JSTYPE_XML, /* xml object */ - JSTYPE_LIMIT + JSTYPE_VOID = 0, + JSTYPE_OBJECT = 1, + JSTYPE_FUNCTION = 2, + JSTYPE_STRING = 3, + JSTYPE_NUMBER = 4, + JSTYPE_BOOLEAN = 5, + JSTYPE_NULL = 6, + JSTYPE_SYMBOL = 7, + JSTYPE_LIMIT = 8, } - -#[repr(u32)] -pub enum JSAccessMode { - JSACC_PROTO = 0, - JSACC_WATCH = 3, - JSACC_READ = 4, - JSACC_WRITE = 8, - JSACC_LIMIT +#[repr(i32)] +#[derive(Copy, Clone)] +pub enum JSProtoKey { + JSProto_Null = 0, + JSProto_Object = 1, + JSProto_Function = 2, + JSProto_Array = 3, + JSProto_Boolean = 4, + JSProto_JSON = 5, + JSProto_Date = 6, + JSProto_Math = 7, + JSProto_Number = 8, + JSProto_String = 9, + JSProto_RegExp = 10, + JSProto_Error = 11, + JSProto_InternalError = 12, + JSProto_EvalError = 13, + JSProto_RangeError = 14, + JSProto_ReferenceError = 15, + JSProto_SyntaxError = 16, + JSProto_TypeError = 17, + JSProto_URIError = 18, + JSProto_Iterator = 19, + JSProto_StopIteration = 20, + JSProto_ArrayBuffer = 21, + JSProto_Int8Array = 22, + JSProto_Uint8Array = 23, + JSProto_Int16Array = 24, + JSProto_Uint16Array = 25, + JSProto_Int32Array = 26, + JSProto_Uint32Array = 27, + JSProto_Float32Array = 28, + JSProto_Float64Array = 29, + JSProto_Uint8ClampedArray = 30, + JSProto_Proxy = 31, + JSProto_WeakMap = 32, + JSProto_Map = 33, + JSProto_Set = 34, + JSProto_DataView = 35, + JSProto_Symbol = 36, + JSProto_SharedArrayBuffer = 37, + JSProto_Intl = 38, + JSProto_TypedObject = 39, + JSProto_GeneratorFunction = 40, + JSProto_SIMD = 41, + JSProto_WeakSet = 42, + JSProto_SharedInt8Array = 43, + JSProto_SharedUint8Array = 44, + JSProto_SharedInt16Array = 45, + JSProto_SharedUint16Array = 46, + JSProto_SharedInt32Array = 47, + JSProto_SharedUint32Array = 48, + JSProto_SharedFloat32Array = 49, + JSProto_SharedFloat64Array = 50, + JSProto_SharedUint8ClampedArray = 51, + JSProto_TypedArray = 52, + JSProto_Atomics = 53, + JSProto_SavedFrame = 54, + JSProto_LIMIT = 55, } - -#[repr(u32)] +pub enum JSCompartment { } +pub enum JSCrossCompartmentCall { } +pub enum JSExceptionState { } +pub enum JSIdArray { } +pub enum JSObjectMap { } +pub enum JSPropertyName { } +pub enum JSRuntime { } +pub enum JSStructuredCloneReader { } +pub enum JSStructuredCloneWriter { } +pub enum JSFlatString { } +pub enum PRCallOnceType { } +pub type JSCallOnceType = PRCallOnceType; +pub type JSInitCallback = ::std::option::Option u8>; +pub type JSTraceDataOp = + ::std::option::Option; +pub enum StoreBuffer { } +pub type OffThreadCompileCallback = + ::std::option::Option; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Runtime { + pub needsIncrementalBarrier_: u8, + pub gcStoreBufferPtr_: *mut StoreBuffer, + pub functionPersistentRooteds: LinkedList>, + pub idPersistentRooteds: LinkedList>, + pub objectPersistentRooteds: LinkedList>, + pub scriptPersistentRooteds: LinkedList>, + pub stringPersistentRooteds: LinkedList>, + pub valuePersistentRooteds: LinkedList>, +} +impl ::std::default::Default for Runtime { + fn default() -> Runtime { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct AutoGCRooter { + pub down: *mut AutoGCRooter, + pub tag_: i32, + pub stackTop: *mut *mut AutoGCRooter, +} +impl ::std::default::Default for AutoGCRooter { + fn default() -> AutoGCRooter { unsafe { ::std::mem::zeroed() } } +} +pub enum ExclusiveContext { } +#[repr(i32)] +#[derive(Copy, Clone)] +pub enum ThingRootKind { + THING_ROOT_OBJECT = 0, + THING_ROOT_SHAPE = 1, + THING_ROOT_BASE_SHAPE = 2, + THING_ROOT_OBJECT_GROUP = 3, + THING_ROOT_STRING = 4, + THING_ROOT_SYMBOL = 5, + THING_ROOT_JIT_CODE = 6, + THING_ROOT_SCRIPT = 7, + THING_ROOT_LAZY_SCRIPT = 8, + THING_ROOT_ID = 9, + THING_ROOT_VALUE = 10, + THING_ROOT_TYPE = 11, + THING_ROOT_BINDINGS = 12, + THING_ROOT_PROPERTY_DESCRIPTOR = 13, + THING_ROOT_PROP_DESC = 14, + THING_ROOT_LIMIT = 15, +} +#[repr(i32)] +#[derive(Copy, Clone)] +pub enum StackKind { + StackForSystemCode = 0, + StackForTrustedScript = 1, + StackForUntrustedScript = 2, + StackKindCount = 3, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ContextFriendFields { + pub runtime_: *mut JSRuntime, + pub compartment_: *mut JSCompartment, + pub zone_: *mut Zone, + pub thingGCRooters: [*mut Rooted<*mut ::libc::c_void>; 15usize], + pub autoGCRooters: *mut AutoGCRooter, +} +impl ::std::default::Default for ContextFriendFields { + fn default() -> ContextFriendFields { unsafe { ::std::mem::zeroed() } } +} +pub enum PerThreadData { } +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PerThreadDataFriendFields { + pub thingGCRooters: [*mut Rooted<*mut ::libc::c_void>; 15usize], + pub nativeStackLimit: [u32; 3usize], +} +impl ::std::default::Default for PerThreadDataFriendFields { + fn default() -> PerThreadDataFriendFields { + unsafe { ::std::mem::zeroed() } + } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct RuntimeDummy { + pub mainThread: PerThreadDummy, +} +impl ::std::default::Default for RuntimeDummy { + fn default() -> RuntimeDummy { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PerThreadDummy { + pub field1: *mut ::libc::c_void, + pub field2: u32, +} +impl ::std::default::Default for PerThreadDummy { + fn default() -> PerThreadDummy { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct MapHashPolicy; +impl ::std::default::Default for MapHashPolicy { + fn default() -> MapHashPolicy { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct HashSet { + pub _impl: Impl, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct SetOps; +impl ::std::default::Default for SetOps { + fn default() -> SetOps { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct HashMapEntry { + pub key_: Key, + pub value_: Value, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct HashTable { + pub table: *mut Entry, + pub _bindgen_bitfield_1_: u32, + pub entryCount: u32, + pub removedCount: u32, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct DoubleHash { + pub h2: u32, + pub sizeMask: u32, +} +impl ::std::default::Default for DoubleHash { + fn default() -> DoubleHash { unsafe { ::std::mem::zeroed() } } +} +impl HashTable { + pub fn set_gen(&mut self, val: u32) { + self._bindgen_bitfield_1_ &= !(((1 << 24usize) - 1) << 0usize); + self._bindgen_bitfield_1_ |= (val as u32) << 0usize; + } + pub fn set_hashShift(&mut self, val: u8) { + self._bindgen_bitfield_1_ &= !(((1 << 8usize) - 1) << 24usize); + self._bindgen_bitfield_1_ |= (val as u32) << 24usize; + } +} +#[repr(i32)] +#[derive(Copy, Clone)] pub enum JSGCTraceKind { JSTRACE_OBJECT = 0, JSTRACE_STRING = 1, - JSTRACE_SCRIPT = 2, + JSTRACE_SYMBOL = 2, + JSTRACE_SCRIPT = 3, + JSTRACE_SHAPE = 4, + JSTRACE_NULL = 6, + JSTRACE_OUTOFLINE = 7, + JSTRACE_BASE_SHAPE = 15, + JSTRACE_JITCODE = 31, + JSTRACE_LAZY_SCRIPT = 47, + JSTRACE_OBJECT_GROUP = 63, } - -pub const JS_DEFAULT_ZEAL_FREQ: u32 = 100; - -pub type moz_static_assert6 = [c_int; 1]; -pub struct JSHandleObject { - pub unnamed_field1: *mut *mut JSObject, +pub type JSTraceCallback = + ::std::option::Option; +pub type JSTraceNamePrinter = + ::std::option::Option; +#[repr(i32)] +#[derive(Copy, Clone)] +pub enum WeakMapTraceKind { + DoNotTraceWeakMaps = 0, + TraceWeakMapValues = 1, + TraceWeakMapKeysValues = 2, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct JSTracer { + pub callback: JSTraceCallback, + pub runtime_: *mut JSRuntime, + pub debugPrinter_: JSTraceNamePrinter, + pub debugPrintArg_: *const ::libc::c_void, + pub debugPrintIndex_: u32, + pub eagerlyTraceWeakMaps_: WeakMapTraceKind, + pub realLocation_: *mut ::libc::c_void, +} +impl ::std::default::Default for JSTracer { + fn default() -> JSTracer { unsafe { ::std::mem::zeroed() } } +} +pub type ZoneSet = HashSet; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Zone { + pub runtime_: *mut JSRuntime, + pub barrierTracer_: *mut JSTracer, + pub needsIncrementalBarrier_: u8, +} +impl ::std::default::Default for Zone { + fn default() -> Zone { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct GCCellPtr { + pub ptr: u32, +} +impl ::std::default::Default for GCCellPtr { + fn default() -> GCCellPtr { unsafe { ::std::mem::zeroed() } } +} +pub enum GCRuntime { } +#[repr(i32)] +#[derive(Copy, Clone)] +pub enum JSGCMode { + JSGC_MODE_GLOBAL = 0, + JSGC_MODE_COMPARTMENT = 1, + JSGC_MODE_INCREMENTAL = 2, +} +#[repr(i32)] +#[derive(Copy, Clone)] +pub enum JSGCInvocationKind { GC_NORMAL = 0, GC_SHRINK = 1, } +#[repr(i32)] +#[derive(Copy, Clone)] +pub enum Reason { + API = 0, + EAGER_ALLOC_TRIGGER = 1, + DESTROY_RUNTIME = 2, + DESTROY_CONTEXT = 3, + LAST_DITCH = 4, + TOO_MUCH_MALLOC = 5, + ALLOC_TRIGGER = 6, + DEBUG_GC = 7, + COMPARTMENT_REVIVED = 8, + RESET = 9, + OUT_OF_NURSERY = 10, + EVICT_NURSERY = 11, + FULL_STORE_BUFFER = 12, + SHARED_MEMORY_LIMIT = 13, + PERIODIC_FULL_GC = 14, + INCREMENTAL_TOO_SLOW = 15, + RESERVED0 = 16, + RESERVED1 = 17, + RESERVED2 = 18, + RESERVED3 = 19, + RESERVED4 = 20, + RESERVED5 = 21, + RESERVED6 = 22, + RESERVED7 = 23, + RESERVED8 = 24, + RESERVED9 = 25, + RESERVED10 = 26, + RESERVED11 = 27, + RESERVED12 = 28, + RESERVED13 = 29, + RESERVED14 = 30, + RESERVED15 = 31, + RESERVED16 = 32, + DOM_WINDOW_UTILS = 33, + COMPONENT_UTILS = 34, + MEM_PRESSURE = 35, + CC_WAITING = 36, + CC_FORCED = 37, + LOAD_END = 38, + POST_COMPARTMENT = 39, + PAGE_HIDE = 40, + NSJSCONTEXT_DESTROY = 41, + SET_NEW_DOCUMENT = 42, + SET_DOC_SHELL = 43, + DOM_UTILS = 44, + DOM_IPC = 45, + DOM_WORKER = 46, + INTER_SLICE_GC = 47, + REFRESH_FRAME = 48, + FULL_GC_TIMER = 49, + SHUTDOWN_CC = 50, + FINISH_LARGE_EVALUATE = 51, + USER_INACTIVE = 52, + NO_REASON = 53, + NUM_REASONS = 54, + NUM_TELEMETRY_REASONS = 100, +} +#[repr(i32)] +#[derive(Copy, Clone)] +pub enum GCProgress { + GC_CYCLE_BEGIN = 0, + GC_SLICE_BEGIN = 1, + GC_SLICE_END = 2, + GC_CYCLE_END = 3, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct GCDescription { + pub isCompartment_: u8, + pub invocationKind_: JSGCInvocationKind, +} +impl ::std::default::Default for GCDescription { + fn default() -> GCDescription { unsafe { ::std::mem::zeroed() } } +} +pub type GCSliceCallback = + ::std::option::Option; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct AutoDisableGenerationalGC { + pub gc: *mut GCRuntime, + pub restartVerifier: u8, +} +impl ::std::default::Default for AutoDisableGenerationalGC { + fn default() -> AutoDisableGenerationalGC { + unsafe { ::std::mem::zeroed() } + } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct AutoAssertOnGC; +impl ::std::default::Default for AutoAssertOnGC { + fn default() -> AutoAssertOnGC { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct AutoAssertNoAlloc; +impl ::std::default::Default for AutoAssertNoAlloc { + fn default() -> AutoAssertNoAlloc { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct AutoSuppressGCAnalysis; +impl ::std::default::Default for AutoSuppressGCAnalysis { + fn default() -> AutoSuppressGCAnalysis { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct AutoAssertGCCallback; +impl ::std::default::Default for AutoAssertGCCallback { + fn default() -> AutoAssertGCCallback { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct AutoCheckCannotGC; +impl ::std::default::Default for AutoCheckCannotGC { + fn default() -> AutoCheckCannotGC { unsafe { ::std::mem::zeroed() } } +} +pub enum PersistentRootedMarker { } +use rust::GCMethods; +#[repr(C)] +#[derive(Clone, PartialEq)] +pub struct Heap + Copy> { + pub ptr: T, } -pub struct JSHandleValue { - pub unnamed_field1: JSVal, +#[repr(C)] +#[derive(Copy, Clone)] +pub struct TenuredHeap { + pub bits: T, } -pub struct JSHandleString { - pub unnamed_field1: *mut *mut JSString, +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Handle { + pub ptr: *const T, } -pub struct JSMutableHandleObject { - pub unnamed_field1: *mut *mut JSObject, +#[repr(C)] +#[derive(Copy, Clone)] +pub struct MutableHandle { + pub ptr: *mut T, } -pub struct JSHandleId { - pub unnamed_field1: *mut jsid, +#[repr(C)] +pub struct Rooted { + pub stack: *mut *mut Rooted<*mut ::libc::c_void>, + pub prev: *mut Rooted<*mut ::libc::c_void>, + pub ptr: T, } -pub struct JSMutableHandleValue { - pub unnamed_field1: *mut JSVal, +#[repr(C)] +#[derive(Copy, Clone)] +pub struct FakeRooted { + pub ptr: T, } -pub type JSRawObject = *mut JSObject; -pub type JSPropertyOp = - Option JSBool>; -pub type JSStrictPropertyOp = - Option JSBool>; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct FakeMutableHandle { + pub ptr: *mut T, +} +#[repr(i32)] +#[derive(Copy, Clone)] +pub enum AllowGC { NoGC = 0, CanGC = 1, } +#[repr(C)] +#[derive(Copy, Clone)] +pub struct PersistentRooted { + pub ptr: T, +} +#[repr(C)] +pub struct ObjectPtr { + pub value: Heap<*mut JSObject>, +} +impl ::std::default::Default for ObjectPtr { + fn default() -> ObjectPtr { unsafe { ::std::mem::zeroed() } } +} +#[repr(i32)] +#[derive(Copy, Clone)] +pub enum JSValueType { + JSVAL_TYPE_DOUBLE = 0, + JSVAL_TYPE_INT32 = 1, + JSVAL_TYPE_UNDEFINED = 2, + JSVAL_TYPE_BOOLEAN = 3, + JSVAL_TYPE_MAGIC = 4, + JSVAL_TYPE_STRING = 5, + JSVAL_TYPE_SYMBOL = 6, + JSVAL_TYPE_NULL = 7, + JSVAL_TYPE_OBJECT = 8, + JSVAL_TYPE_UNKNOWN = 32, + JSVAL_TYPE_MISSING = 33, +} +#[repr(i32)] +#[derive(Copy, Clone)] +pub enum JSValueTag { + JSVAL_TAG_CLEAR = -128, + JSVAL_TAG_INT32 = -127, + JSVAL_TAG_UNDEFINED = -126, + JSVAL_TAG_STRING = -123, + JSVAL_TAG_SYMBOL = -122, + JSVAL_TAG_BOOLEAN = -125, + JSVAL_TAG_MAGIC = -124, + JSVAL_TAG_NULL = -121, + JSVAL_TAG_OBJECT = -120, +} +#[repr(i32)] +#[derive(Copy, Clone)] +pub enum JSWhyMagic { + JS_ELEMENTS_HOLE = 0, + JS_NO_ITER_VALUE = 1, + JS_GENERATOR_CLOSING = 2, + JS_NO_CONSTANT = 3, + JS_THIS_POISON = 4, + JS_ARG_POISON = 5, + JS_SERIALIZE_NO_NODE = 6, + JS_LAZY_ARGUMENTS = 7, + JS_OPTIMIZED_ARGUMENTS = 8, + JS_IS_CONSTRUCTING = 9, + JS_OVERWRITTEN_CALLEE = 10, + JS_BLOCK_NEEDS_CLONE = 11, + JS_HASH_KEY_EMPTY = 12, + JS_ION_ERROR = 13, + JS_ION_BAILOUT = 14, + JS_OPTIMIZED_OUT = 15, + JS_UNINITIALIZED_LEXICAL = 16, + JS_GENERIC_MAGIC = 17, + JS_WHY_MAGIC_COUNT = 18, +} +#[repr(C)] +#[derive(Clone, Copy)] +pub struct jsval_layout { + pub _bindgen_data_: [u64; 1usize], +} +impl jsval_layout { + pub unsafe fn asBits(&mut self) -> *mut u64 { + ::std::mem::transmute(&self._bindgen_data_) + } + pub unsafe fn s(&mut self) -> *mut Value_h_unnamed_1 { + ::std::mem::transmute(&self._bindgen_data_) + } + pub unsafe fn asDouble(&mut self) -> *mut f64 { + ::std::mem::transmute(&self._bindgen_data_) + } + pub unsafe fn asPtr(&mut self) -> *mut *mut ::libc::c_void { + ::std::mem::transmute(&self._bindgen_data_) + } +} +impl ::std::default::Default for jsval_layout { + fn default() -> jsval_layout { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Value_h_unnamed_1 { + pub payload: Value_h_unnamed_2, + pub tag: JSValueTag, +} +impl ::std::default::Default for Value_h_unnamed_1 { + fn default() -> Value_h_unnamed_1 { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Value_h_unnamed_2 { + pub _bindgen_data_: [u32; 1usize], +} +impl Value_h_unnamed_2 { + pub unsafe fn i32(&mut self) -> *mut i32 { + ::std::mem::transmute(&self._bindgen_data_) + } + pub unsafe fn u32(&mut self) -> *mut u32 { + ::std::mem::transmute(&self._bindgen_data_) + } + pub unsafe fn boo(&mut self) -> *mut u32 { + ::std::mem::transmute(&self._bindgen_data_) + } + pub unsafe fn str(&mut self) -> *mut *mut JSString { + ::std::mem::transmute(&self._bindgen_data_) + } + pub unsafe fn sym(&mut self) -> *mut *mut Symbol { + ::std::mem::transmute(&self._bindgen_data_) + } + pub unsafe fn obj(&mut self) -> *mut *mut JSObject { + ::std::mem::transmute(&self._bindgen_data_) + } + pub unsafe fn cell(&mut self) -> *mut *mut Cell { + ::std::mem::transmute(&self._bindgen_data_) + } + pub unsafe fn ptr(&mut self) -> *mut *mut ::libc::c_void { + ::std::mem::transmute(&self._bindgen_data_) + } + pub unsafe fn why(&mut self) -> *mut JSWhyMagic { + ::std::mem::transmute(&self._bindgen_data_) + } + pub unsafe fn word(&mut self) -> *mut u32 { + ::std::mem::transmute(&self._bindgen_data_) + } + pub unsafe fn uintptr(&mut self) -> *mut u32 { + ::std::mem::transmute(&self._bindgen_data_) + } +} +impl ::std::default::Default for Value_h_unnamed_2 { + fn default() -> Value_h_unnamed_2 { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Clone, Copy)] +pub struct Value { + pub data: jsval_layout, +} +pub type JSNative = + ::std::option::Option u8>; +#[repr(i32)] +#[derive(Copy, Clone)] +pub enum UsedRval { IncludeUsedRval = 0, NoUsedRval = 1, } +#[repr(C)] +#[derive(Copy, Clone)] +pub struct CallReceiverBase { + pub argv_: *mut Value, +} +impl ::std::default::Default for CallReceiverBase { + fn default() -> CallReceiverBase { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct CallReceiver; +impl ::std::default::Default for CallReceiver { + fn default() -> CallReceiver { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct CallArgsBase { + pub argc_: u32, +} +impl ::std::default::Default for CallArgsBase { + fn default() -> CallArgsBase { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct CallArgs { + pub argv_: *mut Value, + pub argc_: u32, +} +impl ::std::default::Default for CallArgs { + fn default() -> CallArgs { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct jsid { + pub asBits: u32, +} +pub enum FreeOp { } +pub enum PropertyName { } +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ObjectOpResult { + pub code_: u32, +} +impl ::std::default::Default for ObjectOpResult { + fn default() -> ObjectOpResult { unsafe { ::std::mem::zeroed() } } +} +pub type JSGetterOp = + ::std::option::Option u8>; +pub type JSAddPropertyOp = JSGetterOp; +pub type JSSetterOp = + ::std::option::Option u8>; +pub type JSDeletePropertyOp = + ::std::option::Option u8>; pub type JSNewEnumerateOp = - Option JSBool>; + ::std::option::Option u8>; pub type JSEnumerateOp = - Option JSBool>; + ::std::option::Option u8>; pub type JSResolveOp = - Option JSBool>; -pub type JSNewResolveOp = - Option JSBool>; + ::std::option::Option u8>; pub type JSConvertOp = - Option JSBool>; -pub type JSTypeOfOp = - Option JSType>; -pub struct JSFreeOp { - pub runtime: *mut JSRuntime, -} + ::std::option::Option u8>; pub type JSFinalizeOp = - Option; + ::std::option::Option; +#[repr(C)] +#[derive(Copy, Clone)] pub struct JSStringFinalizer { - pub finalize: Option, + pub finalize: ::std::option::Option, +} +impl ::std::default::Default for JSStringFinalizer { + fn default() -> JSStringFinalizer { unsafe { ::std::mem::zeroed() } } } -pub type JSCheckAccessOp = - Option JSBool>; pub type JSHasInstanceOp = - Option JSBool>; + ::std::option::Option u8>; pub type JSTraceOp = - Option; -pub type JSTraceNamePrinter = - Option; -pub type JSEqualityOp = - Option JSBool>; -pub type JSNative = - Option JSBool>; -pub type Enum_JSContextOp = c_uint; -pub const JSCONTEXT_NEW: c_uint = 0; -pub const JSCONTEXT_DESTROY: c_uint = 1; -pub type JSContextOp = Enum_JSContextOp; + ::std::option::Option; +pub type JSWeakmapKeyDelegateOp = + ::std::option::Option *mut JSObject>; +pub type JSObjectMovedOp = + ::std::option::Option; +pub type LookupPropertyOp = + ::std::option::Option) -> u8>; +pub type DefinePropertyOp = + ::std::option::Option u8>; +pub type HasPropertyOp = + ::std::option::Option u8>; +pub type GetPropertyOp = + ::std::option::Option u8>; +pub type SetPropertyOp = + ::std::option::Option u8>; +pub type GetOwnPropertyOp = + ::std::option::Option) + -> u8>; +pub type DeletePropertyOp = + ::std::option::Option u8>; +pub type WatchOp = + ::std::option::Option u8>; +pub type UnwatchOp = + ::std::option::Option u8>; +#[repr(C)] +pub struct ElementAdder { + pub resObj_: RootedObject, + pub vp_: *mut Value, + pub index_: u32, +} +impl ::std::default::Default for ElementAdder { + fn default() -> ElementAdder { unsafe { ::std::mem::zeroed() } } +} +pub type GetElementsOp = + ::std::option::Option u8>; +pub type ObjectOp = + ::std::option::Option *mut JSObject>; +pub type InnerObjectOp = + ::std::option::Option *mut JSObject>; +pub type FinalizeOp = + ::std::option::Option; +pub type ClassObjectCreationOp = + ::std::option::Option *mut JSObject>; +pub type FinishClassInitOp = + ::std::option::Option u8>; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ClassSpec { + pub createConstructor: ClassObjectCreationOp, + pub createPrototype: ClassObjectCreationOp, + pub constructorFunctions: *const JSFunctionSpec, + pub constructorProperties: *const JSPropertySpec, + pub prototypeFunctions: *const JSFunctionSpec, + pub prototypeProperties: *const JSPropertySpec, + pub finishInit: FinishClassInitOp, + pub flags: u32, +} +impl ::std::default::Default for ClassSpec { + fn default() -> ClassSpec { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ClassExtension { + pub outerObject: ObjectOp, + pub innerObject: InnerObjectOp, + pub isWrappedNative: u8, + pub weakmapKeyDelegateOp: JSWeakmapKeyDelegateOp, + pub objectMovedOp: JSObjectMovedOp, +} +impl ::std::default::Default for ClassExtension { + fn default() -> ClassExtension { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ObjectOps { + pub lookupProperty: LookupPropertyOp, + pub defineProperty: DefinePropertyOp, + pub hasProperty: HasPropertyOp, + pub getProperty: GetPropertyOp, + pub setProperty: SetPropertyOp, + pub getOwnPropertyDescriptor: GetOwnPropertyOp, + pub deleteProperty: DeletePropertyOp, + pub watch: WatchOp, + pub unwatch: UnwatchOp, + pub getElements: GetElementsOp, + pub enumerate: JSNewEnumerateOp, + pub thisObject: ObjectOp, +} +impl ::std::default::Default for ObjectOps { + fn default() -> ObjectOps { unsafe { ::std::mem::zeroed() } } +} +pub type JSClassInternal = ::std::option::Option; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct JSClass { + pub name: *const i8, + pub flags: u32, + pub addProperty: JSAddPropertyOp, + pub delProperty: JSDeletePropertyOp, + pub getProperty: JSGetterOp, + pub setProperty: JSSetterOp, + pub enumerate: JSEnumerateOp, + pub resolve: JSResolveOp, + pub convert: JSConvertOp, + pub finalize: JSFinalizeOp, + pub call: JSNative, + pub hasInstance: JSHasInstanceOp, + pub construct: JSNative, + pub trace: JSTraceOp, + pub reserved: [*mut ::libc::c_void; 25usize], +} +impl ::std::default::Default for JSClass { + fn default() -> JSClass { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Class { + pub name: *const i8, + pub flags: u32, + pub addProperty: JSAddPropertyOp, + pub delProperty: JSDeletePropertyOp, + pub getProperty: JSGetterOp, + pub setProperty: JSSetterOp, + pub enumerate: JSEnumerateOp, + pub resolve: JSResolveOp, + pub convert: JSConvertOp, + pub finalize: FinalizeOp, + pub call: JSNative, + pub hasInstance: JSHasInstanceOp, + pub construct: JSNative, + pub trace: JSTraceOp, + pub spec: ClassSpec, + pub ext: ClassExtension, + pub ops: ObjectOps, +} +impl ::std::default::Default for Class { + fn default() -> Class { unsafe { ::std::mem::zeroed() } } +} +#[repr(i32)] +#[derive(Copy, Clone)] +pub enum ESClassValue { + ESClass_Object = 0, + ESClass_Array = 1, + ESClass_Number = 2, + ESClass_String = 3, + ESClass_Boolean = 4, + ESClass_RegExp = 5, + ESClass_ArrayBuffer = 6, + ESClass_SharedArrayBuffer = 7, + ESClass_Date = 8, + ESClass_Set = 9, + ESClass_Map = 10, + ESClass_IsArray = 11, +} +#[repr(i32)] +#[derive(Copy, Clone)] +pub enum MemoryOrdering { + Relaxed = 0, + ReleaseAcquire = 1, + SequentiallyConsistent = 2, +} +#[derive(Copy, Clone)] +pub enum Atomic { } +#[repr(C)] +#[derive(Copy, Clone)] +pub struct JSPrincipals { + pub refcount: Atomic, +} +impl ::std::default::Default for JSPrincipals { + fn default() -> JSPrincipals { unsafe { ::std::mem::zeroed() } } +} +pub type JSSubsumesOp = + ::std::option::Option u8>; +pub type JSCSPEvalChecker = + ::std::option::Option u8>; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct JSSecurityCallbacks { + pub contentSecurityPolicyAllows: JSCSPEvalChecker, + pub subsumes: JSSubsumesOp, +} +impl ::std::default::Default for JSSecurityCallbacks { + fn default() -> JSSecurityCallbacks { unsafe { ::std::mem::zeroed() } } +} +pub type JSDestroyPrincipalsOp = + ::std::option::Option; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Vector; +pub enum Latin1CharsZ { } +pub enum TwoByteChars { } +#[repr(C)] +#[derive(Copy, Clone)] +pub struct AutoValueArray { + pub length_: u32, + pub elements_: *mut Value, +} +impl ::std::default::Default for AutoValueArray { + fn default() -> AutoValueArray { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct AutoValueVector; +impl ::std::default::Default for AutoValueVector { + fn default() -> AutoValueVector { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct AutoIdVector; +impl ::std::default::Default for AutoIdVector { + fn default() -> AutoIdVector { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct AutoObjectVector; +impl ::std::default::Default for AutoObjectVector { + fn default() -> AutoObjectVector { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct AutoFunctionVector; +impl ::std::default::Default for AutoFunctionVector { + fn default() -> AutoFunctionVector { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct AutoScriptVector; +impl ::std::default::Default for AutoScriptVector { + fn default() -> AutoScriptVector { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct CustomAutoRooter; +impl ::std::default::Default for CustomAutoRooter { + fn default() -> CustomAutoRooter { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct RootedGeneric { + pub value: T, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct HandleValueArray { + pub length_: ::libc::size_t, + pub elements_: *const Value, +} +impl ::std::default::Default for HandleValueArray { + fn default() -> HandleValueArray { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct JSFreeOp { + pub runtime_: *mut JSRuntime, +} +impl ::std::default::Default for JSFreeOp { + fn default() -> JSFreeOp { unsafe { ::std::mem::zeroed() } } +} +#[repr(i32)] +#[derive(Copy, Clone)] +pub enum JSContextOp { JSCONTEXT_NEW = 0, JSCONTEXT_DESTROY = 1, } pub type JSContextCallback = - Option JSBool>; -pub type Enum_JSGCStatus = c_uint; -pub const JSGC_BEGIN: c_uint = 0; -pub const JSGC_END: c_uint = 1; -pub type JSGCStatus = Enum_JSGCStatus; + ::std::option::Option u8>; +#[repr(i32)] +#[derive(Copy, Clone)] +pub enum JSGCStatus { JSGC_BEGIN = 0, JSGC_END = 1, } pub type JSGCCallback = - Option; -pub type Enum_JSFinalizeStatus = c_uint; -pub const JSFINALIZE_START: c_uint = 0; -pub const JSFINALIZE_END: c_uint = 1; -pub type JSFinalizeStatus = Enum_JSFinalizeStatus; + ::std::option::Option; +#[repr(i32)] +#[derive(Copy, Clone)] +pub enum JSFinalizeStatus { + JSFINALIZE_GROUP_START = 0, + JSFINALIZE_GROUP_END = 1, + JSFINALIZE_COLLECTION_END = 2, +} pub type JSFinalizeCallback = - Option; -pub type JSTraceDataOp = - Option; -pub type JSOperationCallback = - Option JSBool>; + ::std::option::Option; +pub type JSWeakPointerCallback = + ::std::option::Option; +pub type JSInterruptCallback = + ::std::option::Option u8>; pub type JSErrorReporter = - Option; -pub type Enum_JSExnType = c_int; -pub const JSEXN_NONE: c_int = -1; -pub const JSEXN_ERR: c_int = 0; -pub const JSEXN_INTERNALERR: c_int = 1; -pub const JSEXN_EVALERR: c_int = 2; -pub const JSEXN_RANGEERR: c_int = 3; -pub const JSEXN_REFERENCEERR: c_int = 4; -pub const JSEXN_SYNTAXERR: c_int = 5; -pub const JSEXN_TYPEERR: c_int = 6; -pub const JSEXN_URIERR: c_int = 7; -pub const JSEXN_LIMIT: c_int = 8; -pub type JSExnType = Enum_JSExnType; + ::std::option::Option; +#[repr(i32)] +#[derive(Copy, Clone)] +pub enum JSExnType { + JSEXN_NONE = -1, + JSEXN_ERR = 0, + JSEXN_INTERNALERR = 1, + JSEXN_EVALERR = 2, + JSEXN_RANGEERR = 3, + JSEXN_REFERENCEERR = 4, + JSEXN_SYNTAXERR = 5, + JSEXN_TYPEERR = 6, + JSEXN_URIERR = 7, + JSEXN_LIMIT = 8, +} +#[repr(C)] +#[derive(Copy, Clone)] pub struct JSErrorFormatString { - pub format: *const c_char, - pub argCount: uint16_t, - pub exnType: int16_t, + pub format: *const i8, + pub argCount: u16, + pub exnType: i16, +} +impl ::std::default::Default for JSErrorFormatString { + fn default() -> JSErrorFormatString { unsafe { ::std::mem::zeroed() } } } pub type JSErrorCallback = - Option *const JSErrorFormatString>; pub type JSLocaleToUpperCase = - Option JSBool>; + ::std::option::Option u8>; pub type JSLocaleToLowerCase = - Option JSBool>; + ::std::option::Option u8>; pub type JSLocaleCompare = - Option JSBool>; + ::std::option::Option u8>; pub type JSLocaleToUnicode = - Option JSBool>; -pub type JSDestroyPrincipalsOp = - Option; -pub type JSSubsumePrincipalsOp = - Option JSBool>; -pub type JSObjectPrincipalsFinder = - Option *mut JSPrincipals>; -pub type JSCSPEvalChecker = - Option JSBool>; + ::std::option::Option u8>; pub type JSWrapObjectCallback = - Option *mut JSObject>; + ::std::option::Option *mut JSObject>; pub type JSPreWrapCallback = - Option *mut JSObject>; -pub type JSSameCompartmentWrapObjectCallback = - Option *mut JSObject>; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct JSWrapObjectCallbacks { + pub wrap: JSWrapObjectCallback, + pub preWrap: JSPreWrapCallback, +} +impl ::std::default::Default for JSWrapObjectCallbacks { + fn default() -> JSWrapObjectCallbacks { unsafe { ::std::mem::zeroed() } } +} pub type JSDestroyCompartmentCallback = - Option; + ::std::option::Option; +pub type JSZoneCallback = + ::std::option::Option; pub type JSCompartmentNameCallback = - Option; -pub type ReadStructuredCloneOp = - Option *mut JSObject>; -pub type WriteStructuredCloneOp = - Option JSBool>; -pub type StructuredCloneErrorOp = - Option; + ::std::option::Option; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct SourceBufferHolder { + pub data_: *const i16, + pub length_: u32, + pub ownsChars_: u8, +} +impl ::std::default::Default for SourceBufferHolder { + fn default() -> SourceBufferHolder { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +pub struct CompartmentTimeStats { + pub compartmentName: [i8; 1024], + pub addonId: *mut JSAddonId, + pub compartment: *mut JSCompartment, + pub time: u64, + pub cpowTime: u64, +} +impl ::std::default::Default for CompartmentTimeStats { + fn default() -> CompartmentTimeStats { unsafe { ::std::mem::zeroed() } } +} +pub type CompartmentStatsVector = + Vector; +pub type JS_ICUAllocFn = + ::std::option::Option *mut ::libc::c_void>; +pub type JS_ICUReallocFn = + ::std::option::Option *mut ::libc::c_void>; +pub type JS_ICUFreeFn = + ::std::option::Option; +#[repr(C)] +pub struct JSAutoRequest { + pub mContext: *mut JSContext, +} +impl ::std::default::Default for JSAutoRequest { + fn default() -> JSAutoRequest { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct RuntimeOptions { + pub _bindgen_bitfield_1_: u8, + pub _bindgen_bitfield_2_: u8, +} +impl ::std::default::Default for RuntimeOptions { + fn default() -> RuntimeOptions { unsafe { ::std::mem::zeroed() } } +} +impl RuntimeOptions { + pub fn set_baseline_(&mut self, val: bool) { + self._bindgen_bitfield_1_ &= !(((1 << 1usize) - 1) << 0usize); + self._bindgen_bitfield_1_ |= (val as u8) << 0usize; + } + pub fn set_ion_(&mut self, val: bool) { + self._bindgen_bitfield_1_ &= !(((1 << 1usize) - 1) << 1usize); + self._bindgen_bitfield_1_ |= (val as u8) << 1usize; + } + pub fn set_asmJS_(&mut self, val: bool) { + self._bindgen_bitfield_1_ &= !(((1 << 1usize) - 1) << 2usize); + self._bindgen_bitfield_1_ |= (val as u8) << 2usize; + } + pub fn set_nativeRegExp_(&mut self, val: bool) { + self._bindgen_bitfield_1_ &= !(((1 << 1usize) - 1) << 3usize); + self._bindgen_bitfield_1_ |= (val as u8) << 3usize; + } + pub fn set_unboxedObjects_(&mut self, val: bool) { + self._bindgen_bitfield_1_ &= !(((1 << 1usize) - 1) << 4usize); + self._bindgen_bitfield_1_ |= (val as u8) << 4usize; + } + pub fn set_werror_(&mut self, val: bool) { + self._bindgen_bitfield_1_ &= !(((1 << 1usize) - 1) << 5usize); + self._bindgen_bitfield_1_ |= (val as u8) << 5usize; + } + pub fn set_strictMode_(&mut self, val: bool) { + self._bindgen_bitfield_1_ &= !(((1 << 1usize) - 1) << 6usize); + self._bindgen_bitfield_1_ |= (val as u8) << 6usize; + } + pub fn set_extraWarnings_(&mut self, val: bool) { + self._bindgen_bitfield_1_ &= !(((1 << 1usize) - 1) << 7usize); + self._bindgen_bitfield_1_ |= (val as u8) << 7usize; + } + pub fn set_varObjFix_(&mut self, val: bool) { + self._bindgen_bitfield_2_ &= !(((1 << 1usize) - 1) << 0usize); + self._bindgen_bitfield_2_ |= (val as u8) << 0usize; + } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ContextOptions { + pub _bindgen_bitfield_1_: u8, +} +impl ::std::default::Default for ContextOptions { + fn default() -> ContextOptions { unsafe { ::std::mem::zeroed() } } +} +impl ContextOptions { + pub fn set_privateIsNSISupports_(&mut self, val: bool) { + self._bindgen_bitfield_1_ &= !(((1 << 1usize) - 1) << 0usize); + self._bindgen_bitfield_1_ |= (val as u8) << 0usize; + } + pub fn set_dontReportUncaught_(&mut self, val: bool) { + self._bindgen_bitfield_1_ &= !(((1 << 1usize) - 1) << 1usize); + self._bindgen_bitfield_1_ |= (val as u8) << 1usize; + } + pub fn set_autoJSAPIOwnsErrorReporting_(&mut self, val: bool) { + self._bindgen_bitfield_1_ &= !(((1 << 1usize) - 1) << 2usize); + self._bindgen_bitfield_1_ |= (val as u8) << 2usize; + } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct AutoSaveContextOptions { + pub cx_: *mut JSContext, + pub oldOptions_: ContextOptions, +} +impl ::std::default::Default for AutoSaveContextOptions { + fn default() -> AutoSaveContextOptions { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +pub struct JSAutoCompartment { + pub cx_: *mut JSContext, + pub oldCompartment_: *mut JSCompartment, +} +impl ::std::default::Default for JSAutoCompartment { + fn default() -> JSAutoCompartment { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct JSAutoNullableCompartment { + pub cx_: *mut JSContext, + pub oldCompartment_: *mut JSCompartment, +} +impl ::std::default::Default for JSAutoNullableCompartment { + fn default() -> JSAutoNullableCompartment { + unsafe { ::std::mem::zeroed() } + } +} pub type JSIterateCompartmentCallback = - Option; -pub type JSEnumerateDiagnosticMemoryCallback = - Option JSBool>; -pub type Enum_JSGCRootType = c_uint; -pub const JS_GC_ROOT_VALUE_PTR: c_uint = 0; -pub const JS_GC_ROOT_GCTHING_PTR: c_uint = 1; -pub type JSGCRootType = Enum_JSGCRootType; -pub type JSGCRootMapFun = - Option c_int>; -pub type JSTraceCallback = - Option; -pub struct JSTracer { - pub runtime: *mut JSRuntime, - pub callback: JSTraceCallback, - pub debugPrinter: JSTraceNamePrinter, - pub debugPrintArg: *const c_void, - pub debugPrintIndex: size_t, - pub eagerlyTraceWeakMaps: JSBool, - pub realLocation: *mut c_void, -} -pub type Enum_JSGCParamKey = c_uint; -pub const JSGC_MAX_BYTES: c_uint = 0; -pub const JSGC_MAX_MALLOC_BYTES: c_uint = 1; -pub const JSGC_BYTES: c_uint = 3; -pub const JSGC_NUMBER: c_uint = 4; -pub const JSGC_MAX_CODE_CACHE_BYTES: c_uint = 5; -pub const JSGC_MODE: c_uint = 6; -pub const JSGC_UNUSED_CHUNKS: c_uint = 7; -pub const JSGC_TOTAL_CHUNKS: c_uint = 8; -pub const JSGC_SLICE_TIME_BUDGET: c_uint = 9; -pub const JSGC_MARK_STACK_LIMIT: c_uint = 10; -pub const JSGC_HIGH_FREQUENCY_TIME_LIMIT: c_uint = 11; -pub const JSGC_HIGH_FREQUENCY_LOW_LIMIT: c_uint = 12; -pub const JSGC_HIGH_FREQUENCY_HIGH_LIMIT: c_uint = 13; -pub const JSGC_HIGH_FREQUENCY_HEAP_GROWTH_MAX: c_uint = 14; -pub const JSGC_HIGH_FREQUENCY_HEAP_GROWTH_MIN: c_uint = 15; -pub const JSGC_LOW_FREQUENCY_HEAP_GROWTH: c_uint = 16; -pub const JSGC_DYNAMIC_HEAP_GROWTH: c_uint = 17; -pub const JSGC_DYNAMIC_MARK_SLICE: c_uint = 18; -pub const JSGC_ANALYSIS_PURGE_TRIGGER: c_uint = 19; -pub type JSGCParamKey = Enum_JSGCParamKey; -pub type Enum_JSGCMode = c_uint; -pub const JSGC_MODE_GLOBAL: c_uint = 0; -pub const JSGC_MODE_COMPARTMENT: c_uint = 1; -pub const JSGC_MODE_INCREMENTAL: c_uint = 2; -pub type JSGCMode = Enum_JSGCMode; -pub type JSClassInternal = Option; -pub struct JSClass { - pub name: *const c_char, - pub flags: uint32_t, - pub addProperty: JSPropertyOp, - pub delProperty: JSPropertyOp, - pub getProperty: JSPropertyOp, - pub setProperty: JSStrictPropertyOp, - pub enumerate: JSEnumerateOp, - pub resolve: JSResolveOp, - pub convert: JSConvertOp, - pub finalize: JSFinalizeOp, - pub checkAccess: JSCheckAccessOp, - pub call: JSNative, - pub hasInstance: JSHasInstanceOp, - pub construct: JSNative, - pub trace: JSTraceOp, - pub reserved: [*mut c_void; 40], + ::std::option::Option; +pub type JSCTypesUnicodeToNativeFun = + ::std::option::Option *mut i8>; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct JSCTypesCallbacks { + pub unicodeToNative: JSCTypesUnicodeToNativeFun, } -unsafe impl Sync for JSClass {} -pub struct JSConstDoubleSpec { - pub dval: c_double, - pub name: *const c_char, - pub flags: uint8_t, - pub spare: [uint8_t; 3], +impl ::std::default::Default for JSCTypesCallbacks { + fn default() -> JSCTypesCallbacks { unsafe { ::std::mem::zeroed() } } } -pub struct JSStrictPropertyOpWrapper { - pub op: JSNative, - pub info: *const JSJitInfo, +#[repr(i32)] +#[derive(Copy, Clone)] +pub enum JSGCParamKey { + JSGC_MAX_BYTES = 0, + JSGC_MAX_MALLOC_BYTES = 1, + JSGC_BYTES = 3, + JSGC_NUMBER = 4, + JSGC_MAX_CODE_CACHE_BYTES = 5, + JSGC_MODE = 6, + JSGC_UNUSED_CHUNKS = 7, + JSGC_TOTAL_CHUNKS = 8, + JSGC_SLICE_TIME_BUDGET = 9, + JSGC_MARK_STACK_LIMIT = 10, + JSGC_HIGH_FREQUENCY_TIME_LIMIT = 11, + JSGC_HIGH_FREQUENCY_LOW_LIMIT = 12, + JSGC_HIGH_FREQUENCY_HIGH_LIMIT = 13, + JSGC_HIGH_FREQUENCY_HEAP_GROWTH_MAX = 14, + JSGC_HIGH_FREQUENCY_HEAP_GROWTH_MIN = 15, + JSGC_LOW_FREQUENCY_HEAP_GROWTH = 16, + JSGC_DYNAMIC_HEAP_GROWTH = 17, + JSGC_DYNAMIC_MARK_SLICE = 18, + JSGC_ALLOCATION_THRESHOLD = 19, + JSGC_DECOMMIT_THRESHOLD = 20, + JSGC_MIN_EMPTY_CHUNK_COUNT = 21, + JSGC_MAX_EMPTY_CHUNK_COUNT = 22, + JSGC_COMPACTING_ENABLED = 23, } -pub struct JSPropertyOpWrapper { - pub op: JSNative, - pub info: *const JSJitInfo, +#[repr(C)] +#[derive(Copy, Clone)] +pub struct AutoIdArray { + pub context: *mut JSContext, + pub idArray: *mut JSIdArray, +} +impl ::std::default::Default for AutoIdArray { + fn default() -> AutoIdArray { unsafe { ::std::mem::zeroed() } } } +#[repr(C)] +#[derive(Copy, Clone)] +pub struct JSConstScalarSpec { + pub name: *const i8, + pub val: T, +} +#[repr(C)] +#[derive(Copy, Clone)] pub struct JSNativeWrapper { pub op: JSNative, pub info: *const JSJitInfo, } +impl ::std::default::Default for JSNativeWrapper { + fn default() -> JSNativeWrapper { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy, Clone)] pub struct JSPropertySpec { - pub name: *const c_char, - pub tinyid: int8_t, - pub flags: uint8_t, - pub getter: JSPropertyOpWrapper, - pub setter: JSStrictPropertyOpWrapper, + pub name: *const i8, + pub flags: u8, + pub getter: JSNativeWrapper, + pub setter: JSNativeWrapper, +} +impl ::std::default::Default for JSPropertySpec { + fn default() -> JSPropertySpec { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct SelfHostedWrapper { + pub unused: *mut ::libc::c_void, + pub funname: *const i8, +} +impl ::std::default::Default for SelfHostedWrapper { + fn default() -> SelfHostedWrapper { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct jsapi_h_unnamed_3 { + pub _bindgen_data_: [u32; 2usize], } +impl jsapi_h_unnamed_3 { + pub unsafe fn native(&mut self) -> *mut JSNativeWrapper { + ::std::mem::transmute(&self._bindgen_data_) + } + pub unsafe fn selfHosted(&mut self) -> *mut SelfHostedWrapper { + ::std::mem::transmute(&self._bindgen_data_) + } +} +impl ::std::default::Default for jsapi_h_unnamed_3 { + fn default() -> jsapi_h_unnamed_3 { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct jsapi_h_unnamed_4 { + pub _bindgen_data_: [u32; 2usize], +} +impl jsapi_h_unnamed_4 { + pub unsafe fn native(&mut self) -> *mut JSNativeWrapper { + ::std::mem::transmute(&self._bindgen_data_) + } + pub unsafe fn selfHosted(&mut self) -> *mut SelfHostedWrapper { + ::std::mem::transmute(&self._bindgen_data_) + } +} +impl ::std::default::Default for jsapi_h_unnamed_4 { + fn default() -> jsapi_h_unnamed_4 { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy, Clone)] pub struct JSFunctionSpec { - pub name: *const c_char, + pub name: *const i8, pub call: JSNativeWrapper, - pub nargs: uint16_t, - pub flags: uint16_t, - pub selfHostedName: *const c_char, + pub nargs: u16, + pub flags: u16, + pub selfHostedName: *const i8, +} +impl ::std::default::Default for JSFunctionSpec { + fn default() -> JSFunctionSpec { unsafe { ::std::mem::zeroed() } } +} +#[repr(i32)] +#[derive(Copy, Clone)] +pub enum ZoneSpecifier { FreshZone = 0, SystemZone = 1, } +#[repr(C)] +#[derive(Copy, Clone)] +pub struct CompartmentOptions { + pub version_: JSVersion, + pub invisibleToDebugger_: u8, + pub mergeable_: u8, + pub discardSource_: u8, + pub cloneSingletons_: u8, + pub extraWarningsOverride_: Override, + pub zone_: jsapi_h_unnamed_5, + pub traceGlobal_: JSTraceOp, + pub singletonsAsTemplates_: u8, + pub addonId_: *mut JSAddonId, + pub preserveJitCode_: u8, +} +impl ::std::default::Default for CompartmentOptions { + fn default() -> CompartmentOptions { unsafe { ::std::mem::zeroed() } } } +#[repr(C)] +#[derive(Copy, Clone)] +pub struct jsapi_h_unnamed_5 { + pub _bindgen_data_: [usize; 1usize], +} +impl jsapi_h_unnamed_5 { + pub unsafe fn spec(&mut self) -> *mut ZoneSpecifier { + ::std::mem::transmute(&self._bindgen_data_) + } + pub unsafe fn pointer(&mut self) -> *mut *mut ::libc::c_void { + ::std::mem::transmute(&self._bindgen_data_) + } +} +impl ::std::default::Default for jsapi_h_unnamed_5 { + fn default() -> jsapi_h_unnamed_5 { unsafe { ::std::mem::zeroed() } } +} +#[repr(i32)] +#[derive(Copy, Clone)] +pub enum OnNewGlobalHookOption { + FireOnNewGlobalHook = 0, + DontFireOnNewGlobalHook = 1, +} +#[repr(C)] +#[derive(Copy, Clone)] pub struct JSPropertyDescriptor { pub obj: *mut JSObject, - pub attrs: c_uint, - pub shortid: c_uint, - pub getter: JSPropertyOp, - pub setter: JSStrictPropertyOp, - pub value: JSVal, + pub attrs: u32, + pub getter: JSGetterOp, + pub setter: JSSetterOp, + pub value: Value, } -pub struct JSPrincipals { - pub refcount: c_int, +impl ::std::default::Default for JSPropertyDescriptor { + fn default() -> JSPropertyDescriptor { unsafe { ::std::mem::zeroed() } } } -pub struct JSSecurityCallbacks { - pub checkObjectAccess: JSCheckAccessOp, - pub subsumePrincipals: JSSubsumePrincipalsOp, - pub findObjectPrincipals: JSObjectPrincipalsFinder, - pub contentSecurityPolicyAllows: JSCSPEvalChecker, +#[repr(i32)] +#[derive(Copy, Clone)] +pub enum PropertyDefinitionBehavior { + DefineAllProperties = 0, + OnlyDefineLateProperties = 1, + DontDefineLateProperties = 2, } -pub type Enum_JSExecPart = c_uint; -pub const JSEXEC_PROLOG: c_uint = 0; -pub const JSEXEC_MAIN: c_uint = 1; -pub type JSExecPart = Enum_JSExecPart; -pub type JSONWriteCallback = - Option JSBool>; -pub struct JSStructuredCloneCallbacks { - pub read: ReadStructuredCloneOp, - pub write: WriteStructuredCloneOp, - pub reportError: StructuredCloneErrorOp, +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ReadOnlyCompileOptions { + pub _vptr: *const ::libc::c_void, + pub mutedErrors_: u8, + pub filename_: *const i8, + pub introducerFilename_: *const i8, + pub sourceMapURL_: *const i16, + pub version: JSVersion, + pub versionSet: u8, + pub utf8: u8, + pub lineno: u32, + pub column: u32, + pub compileAndGo: u8, + pub hasPollutedGlobalScope: u8, + pub forEval: u8, + pub noScriptRval: u8, + pub selfHostingMode: u8, + pub canLazilyParse: u8, + pub strictOption: u8, + pub extraWarningsOption: u8, + pub werrorOption: u8, + pub asmJSOption: u8, + pub forceAsync: u8, + pub installedFile: u8, + pub sourceIsLazy: u8, + pub introductionType: *const i8, + pub introductionLineno: u32, + pub introductionOffset: u32, + pub hasIntroductionInfo: u8, +} +impl ::std::default::Default for ReadOnlyCompileOptions { + fn default() -> ReadOnlyCompileOptions { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct OwningCompileOptions { + pub runtime: *mut JSRuntime, + pub elementRoot: PersistentRootedObject, + pub elementAttributeNameRoot: PersistentRootedString, + pub introductionScriptRoot: PersistentRootedScript, +} +impl ::std::default::Default for OwningCompileOptions { + fn default() -> OwningCompileOptions { unsafe { ::std::mem::zeroed() } } } +#[repr(C)] +pub struct CompileOptions { + pub elementRoot: RootedObject, + pub elementAttributeNameRoot: RootedString, + pub introductionScriptRoot: RootedScript, +} +impl ::std::default::Default for CompileOptions { + fn default() -> CompileOptions { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +pub struct AutoSetAsyncStackForNewCalls { + pub cx: *mut JSContext, + pub oldAsyncStack: RootedObject, + pub oldAsyncCause: RootedString, +} +impl ::std::default::Default for AutoSetAsyncStackForNewCalls { + fn default() -> AutoSetAsyncStackForNewCalls { + unsafe { ::std::mem::zeroed() } + } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct JSAutoByteString { + pub mBytes: *mut i8, +} +impl ::std::default::Default for JSAutoByteString { + fn default() -> JSAutoByteString { unsafe { ::std::mem::zeroed() } } +} +#[repr(i32)] +#[derive(Copy, Clone)] +pub enum SymbolCode { + iterator = 0, + InSymbolRegistry = -2, + UniqueSymbol = -1, +} +pub type JSONWriteCallback = + ::std::option::Option u8>; +#[repr(C)] +#[derive(Copy, Clone)] pub struct JSLocaleCallbacks { pub localeToUpperCase: JSLocaleToUpperCase, pub localeToLowerCase: JSLocaleToLowerCase, pub localeCompare: JSLocaleCompare, pub localeToUnicode: JSLocaleToUnicode, - pub localeGetErrorMessage: JSErrorCallback, } +impl ::std::default::Default for JSLocaleCallbacks { + fn default() -> JSLocaleCallbacks { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy, Clone)] pub struct JSErrorReport { - pub filename: *const c_char, - pub originPrincipals: *mut JSPrincipals, - pub lineno: c_uint, - pub linebuf: *const c_char, - pub tokenptr: *const c_char, - pub uclinebuf: *const jschar, - pub uctokenptr: *const jschar, - pub flags: c_uint, - pub errorNumber: c_uint, - pub ucmessage: *const jschar, - pub messageArgs: *mut *const jschar, - pub exnType: int16_t, - pub column: c_uint, + pub filename: *const i8, + pub lineno: u32, + pub column: u32, + pub isMuted: u8, + pub linebuf: *const i8, + pub tokenptr: *const i8, + pub uclinebuf: *const i16, + pub uctokenptr: *const i16, + pub flags: u32, + pub errorNumber: u32, + pub ucmessage: *const i16, + pub messageArgs: *mut *const i16, + pub exnType: i16, +} +impl ::std::default::Default for JSErrorReport { + fn default() -> JSErrorReport { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +pub struct AutoSaveExceptionState { + pub context: *mut JSContext, + pub wasPropagatingForcedReturn: u8, + pub wasOverRecursed: u8, + pub wasThrowing: u8, + pub exceptionValue: RootedValue, +} +impl ::std::default::Default for AutoSaveExceptionState { + fn default() -> AutoSaveExceptionState { unsafe { ::std::mem::zeroed() } } +} +#[repr(i32)] +#[derive(Copy, Clone)] +pub enum JSJitCompilerOption { + JSJITCOMPILER_BASELINE_WARMUP_TRIGGER = 0, + JSJITCOMPILER_ION_WARMUP_TRIGGER = 1, + JSJITCOMPILER_ION_GVN_ENABLE = 2, + JSJITCOMPILER_ION_ENABLE = 3, + JSJITCOMPILER_BASELINE_ENABLE = 4, + JSJITCOMPILER_OFFTHREAD_COMPILATION_ENABLE = 5, + JSJITCOMPILER_SIGNALS_ENABLE = 6, + JSJITCOMPILER_NOT_AN_OPTION = 7, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct AutoFilename { + pub scriptSource_: *mut ::libc::c_void, +} +impl ::std::default::Default for AutoFilename { + fn default() -> AutoFilename { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct AutoHideScriptedCaller { + pub mContext: *mut JSContext, +} +impl ::std::default::Default for AutoHideScriptedCaller { + fn default() -> AutoHideScriptedCaller { unsafe { ::std::mem::zeroed() } } +} +pub type OpenAsmJSCacheEntryForReadOp = + ::std::option::Option u8>; +pub type CloseAsmJSCacheEntryForReadOp = + ::std::option::Option; +#[repr(i32)] +#[derive(Copy, Clone)] +pub enum AsmJSCacheResult { + AsmJSCache_Success = 0, + AsmJSCache_ModuleTooSmall = 1, + AsmJSCache_SynchronousScript = 2, + AsmJSCache_QuotaExceeded = 3, + AsmJSCache_Disabled_Internal = 4, + AsmJSCache_Disabled_ShellFlags = 5, + AsmJSCache_Disabled_JitInspector = 6, + AsmJSCache_InternalError = 7, + AsmJSCache_LIMIT = 8, +} +pub type OpenAsmJSCacheEntryForWriteOp = + ::std::option::Option AsmJSCacheResult>; +pub type CloseAsmJSCacheEntryForWriteOp = + ::std::option::Option; +pub type BuildIdCharVector = Vector; +pub type BuildIdOp = + ::std::option::Option u8>; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct AsmJSCacheOps { + pub openEntryForRead: OpenAsmJSCacheEntryForReadOp, + pub closeEntryForRead: CloseAsmJSCacheEntryForReadOp, + pub openEntryForWrite: OpenAsmJSCacheEntryForWriteOp, + pub closeEntryForWrite: CloseAsmJSCacheEntryForWriteOp, + pub buildId: BuildIdOp, +} +impl ::std::default::Default for AsmJSCacheOps { + fn default() -> AsmJSCacheOps { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +pub struct ForOfIterator { + pub cx_: *mut JSContext, + pub iterator: RootedObject, + pub index: u32, +} +impl ::std::default::Default for ForOfIterator { + fn default() -> ForOfIterator { unsafe { ::std::mem::zeroed() } } +} +pub type LargeAllocationFailureCallback = + ::std::option::Option; +pub type OutOfMemoryCallback = + ::std::option::Option; +#[repr(i32)] +#[derive(Copy, Clone)] +pub enum SavedFrameResult { Ok = 0, AccessDenied = 1, } +pub type jsbytecode = u8; +pub type IsAcceptableThis = + ::std::option::Option u8>; +pub type NativeImpl = + ::std::option::Option u8>; +pub enum JSAtom { } +pub enum JSLinearString { } +pub enum BaseProxyHandler { } +pub enum InterpreterFrame { } +#[repr(i32)] +#[derive(Copy, Clone)] +pub enum jsfriendapi_hpp_unnamed_6 { + JS_TELEMETRY_GC_REASON = 0, + JS_TELEMETRY_GC_IS_COMPARTMENTAL = 1, + JS_TELEMETRY_GC_MS = 2, + JS_TELEMETRY_GC_MAX_PAUSE_MS = 3, + JS_TELEMETRY_GC_MARK_MS = 4, + JS_TELEMETRY_GC_SWEEP_MS = 5, + JS_TELEMETRY_GC_MARK_ROOTS_MS = 6, + JS_TELEMETRY_GC_MARK_GRAY_MS = 7, + JS_TELEMETRY_GC_SLICE_MS = 8, + JS_TELEMETRY_GC_MMU_50 = 9, + JS_TELEMETRY_GC_RESET = 10, + JS_TELEMETRY_GC_INCREMENTAL_DISABLED = 11, + JS_TELEMETRY_GC_NON_INCREMENTAL = 12, + JS_TELEMETRY_GC_SCC_SWEEP_TOTAL_MS = 13, + JS_TELEMETRY_GC_SCC_SWEEP_MAX_PAUSE_MS = 14, + JS_TELEMETRY_DEPRECATED_LANGUAGE_EXTENSIONS_IN_CONTENT = 15, + JS_TELEMETRY_ADDON_EXCEPTIONS = 16, +} +pub type JSAccumulateTelemetryDataCallback = + ::std::option::Option; +#[repr(i32)] +#[derive(Copy, Clone)] +pub enum jsfriendapi_hpp_unnamed_7 { + MakeNonConfigurableIntoConfigurable = 0, + CopyNonConfigurableAsIs = 1, +} +pub type PropertyCopyBehavior = jsfriendapi_hpp_unnamed_7; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct JSFunctionSpecWithHelp { + pub name: *const i8, + pub call: JSNative, + pub nargs: u16, + pub flags: u16, + pub usage: *const i8, + pub help: *const i8, +} +impl ::std::default::Default for JSFunctionSpecWithHelp { + fn default() -> JSFunctionSpecWithHelp { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct SourceHook; +impl ::std::default::Default for SourceHook { + fn default() -> SourceHook { unsafe { ::std::mem::zeroed() } } +} +pub type PreserveWrapperCallback = + ::std::option::Option u8>; +#[repr(i32)] +#[derive(Copy, Clone)] +pub enum jsfriendapi_hpp_unnamed_8 { + CollectNurseryBeforeDump = 0, + IgnoreNurseryObjects = 1, +} +pub type DumpHeapNurseryBehaviour = jsfriendapi_hpp_unnamed_8; +pub type WeakMapTraceCallback = + ::std::option::Option; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct WeakMapTracer { + pub runtime: *mut JSRuntime, + pub callback: WeakMapTraceCallback, +} +impl ::std::default::Default for WeakMapTracer { + fn default() -> WeakMapTracer { unsafe { ::std::mem::zeroed() } } +} +pub type GCThingCallback = + ::std::option::Option; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ObjectGroup { + pub clasp: *const Class, + pub proto: *mut JSObject, + pub compartment: *mut JSCompartment, +} +impl ::std::default::Default for ObjectGroup { + fn default() -> ObjectGroup { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct BaseShape { + pub clasp_: *const Class, + pub parent: *mut JSObject, +} +impl ::std::default::Default for BaseShape { + fn default() -> BaseShape { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Shape { + pub base: *mut BaseShape, + pub _1: jsid, + pub slotInfo: u32, +} +impl ::std::default::Default for Shape { + fn default() -> Shape { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Object { + pub group: *mut ObjectGroup, + pub shape: *mut Shape, + pub slots: *mut Value, + pub _1: *mut ::libc::c_void, +} +impl ::std::default::Default for Object { + fn default() -> Object { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Function { + pub base: Object, + pub nargs: u16, + pub flags: u16, + pub native: JSNative, + pub jitinfo: *const JSJitInfo, + pub _1: *mut ::libc::c_void, +} +impl ::std::default::Default for Function { + fn default() -> Function { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct String { + pub flags: u32, + pub length: u32, + pub _bindgen_data_1_: [u32; 1usize], +} +impl String { + pub unsafe fn nonInlineCharsLatin1(&mut self) -> *mut *const Latin1Char { + ::std::mem::transmute(&self._bindgen_data_1_) + } + pub unsafe fn nonInlineCharsTwoByte(&mut self) -> *mut *const i16 { + ::std::mem::transmute(&self._bindgen_data_1_) + } + pub unsafe fn inlineStorageLatin1(&mut self) + -> *mut [Latin1Char; 1usize] { + ::std::mem::transmute(&self._bindgen_data_1_) + } + pub unsafe fn inlineStorageTwoByte(&mut self) -> *mut [i16; 1usize] { + ::std::mem::transmute(&self._bindgen_data_1_) + } +} +impl ::std::default::Default for String { + fn default() -> String { unsafe { ::std::mem::zeroed() } } +} +pub type ActivityCallback = + ::std::option::Option; +pub type DOMInstanceClassHasProtoAtDepth = + ::std::option::Option u8>; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct JSDOMCallbacks { + pub instanceClassMatchesProto: DOMInstanceClassHasProtoAtDepth, +} +impl ::std::default::Default for JSDOMCallbacks { + fn default() -> JSDOMCallbacks { unsafe { ::std::mem::zeroed() } } +} +pub type DOMCallbacks = JSDOMCallbacks; +pub enum RegExpGuard { } +#[repr(i32)] +#[derive(Copy, Clone)] +pub enum NukeReferencesToWindow { + NukeWindowReferences = 0, + DontNukeWindowReferences = 1, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct CompartmentFilter; +impl ::std::default::Default for CompartmentFilter { + fn default() -> CompartmentFilter { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct AllCompartments; +impl ::std::default::Default for AllCompartments { + fn default() -> AllCompartments { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ContentCompartmentsOnly; +impl ::std::default::Default for ContentCompartmentsOnly { + fn default() -> ContentCompartmentsOnly { + unsafe { ::std::mem::zeroed() } + } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct ChromeCompartmentsOnly; +impl ::std::default::Default for ChromeCompartmentsOnly { + fn default() -> ChromeCompartmentsOnly { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct SingleCompartment { + pub ours: *mut JSCompartment, +} +impl ::std::default::Default for SingleCompartment { + fn default() -> SingleCompartment { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct CompartmentsWithPrincipals { + pub principals: *mut JSPrincipals, +} +impl ::std::default::Default for CompartmentsWithPrincipals { + fn default() -> CompartmentsWithPrincipals { + unsafe { ::std::mem::zeroed() } + } +} +#[repr(C)] +pub struct ExpandoAndGeneration { + pub expando: Heap, + pub generation: u32, +} +impl ::std::default::Default for ExpandoAndGeneration { + fn default() -> ExpandoAndGeneration { unsafe { ::std::mem::zeroed() } } +} +#[repr(i32)] +#[derive(Copy, Clone)] +pub enum DOMProxyShadowsResult { + ShadowCheckFailed = 0, + Shadows = 1, + DoesntShadow = 2, + DoesntShadowUnique = 3, + ShadowsViaDirectExpando = 4, + ShadowsViaIndirectExpando = 5, +} +pub type DOMProxyShadowsCheck = + ::std::option::Option DOMProxyShadowsResult>; +#[repr(i32)] +#[derive(Copy, Clone)] +pub enum JSErrNum { + JSMSG_NOT_AN_ERROR = 0, + JSMSG_NOT_DEFINED = 1, + JSMSG_MORE_ARGS_NEEDED = 2, + JSMSG_INCOMPATIBLE_PROTO = 3, + JSMSG_NO_CONSTRUCTOR = 4, + JSMSG_BAD_SORT_ARG = 5, + JSMSG_CANT_WATCH = 6, + JSMSG_READ_ONLY = 7, + JSMSG_CANT_DELETE = 8, + JSMSG_CANT_TRUNCATE_ARRAY = 9, + JSMSG_NOT_FUNCTION = 10, + JSMSG_NOT_CONSTRUCTOR = 11, + JSMSG_CANT_CONVERT = 12, + JSMSG_CANT_CONVERT_TO = 13, + JSMSG_NO_PROPERTIES = 14, + JSMSG_BAD_REGEXP_FLAG = 15, + JSMSG_ARG_INDEX_OUT_OF_RANGE = 16, + JSMSG_SPREAD_TOO_LARGE = 17, + JSMSG_BAD_WEAKMAP_KEY = 18, + JSMSG_BAD_GETTER_OR_SETTER = 19, + JSMSG_BAD_ARRAY_LENGTH = 20, + JSMSG_REDECLARED_VAR = 21, + JSMSG_UNDECLARED_VAR = 22, + JSMSG_GETTER_ONLY = 23, + JSMSG_UNDEFINED_PROP = 24, + JSMSG_INVALID_MAP_ITERABLE = 25, + JSMSG_NESTING_GENERATOR = 26, + JSMSG_INCOMPATIBLE_METHOD = 27, + JSMSG_OBJECT_WATCH_DEPRECATED = 28, + JSMSG_TYPE_ERR_BAD_ARGS = 29, + JSMSG_BAD_SURROGATE_CHAR = 30, + JSMSG_UTF8_CHAR_TOO_LARGE = 31, + JSMSG_MALFORMED_UTF8_CHAR = 32, + JSMSG_WRONG_CONSTRUCTOR = 33, + JSMSG_BUILTIN_CTOR_NO_NEW = 34, + JSMSG_PROTO_SETTING_SLOW = 35, + JSMSG_BAD_GENERATOR_YIELD = 36, + JSMSG_EMPTY_ARRAY_REDUCE = 37, + JSMSG_UNEXPECTED_TYPE = 38, + JSMSG_MISSING_FUN_ARG = 39, + JSMSG_NOT_NONNULL_OBJECT = 40, + JSMSG_INVALID_DESCRIPTOR = 41, + JSMSG_OBJECT_NOT_EXTENSIBLE = 42, + JSMSG_CANT_REDEFINE_PROP = 43, + JSMSG_CANT_APPEND_TO_ARRAY = 44, + JSMSG_CANT_REDEFINE_ARRAY_LENGTH = 45, + JSMSG_CANT_DEFINE_PAST_ARRAY_LENGTH = 46, + JSMSG_BAD_GET_SET_FIELD = 47, + JSMSG_THROW_TYPE_ERROR = 48, + JSMSG_NOT_EXPECTED_TYPE = 49, + JSMSG_NOT_ITERABLE = 50, + JSMSG_ALREADY_HAS_PRAGMA = 51, + JSMSG_NEXT_RETURNED_PRIMITIVE = 52, + JSMSG_WRONG_VALUE = 53, + JSMSG_CANT_SET_PROTO = 54, + JSMSG_CANT_SET_PROTO_OF = 55, + JSMSG_CANT_SET_PROTO_CYCLE = 56, + JSMSG_INVALID_ARG_TYPE = 57, + JSMSG_TERMINATED = 58, + JSMSG_PROTO_NOT_OBJORNULL = 59, + JSMSG_JSON_BAD_PARSE = 60, + JSMSG_JSON_CYCLIC_VALUE = 61, + JSMSG_BAD_INSTANCEOF_RHS = 62, + JSMSG_BAD_LEFTSIDE_OF_ASS = 63, + JSMSG_BAD_PROTOTYPE = 64, + JSMSG_IN_NOT_OBJECT = 65, + JSMSG_TOO_MANY_CON_SPREADARGS = 66, + JSMSG_TOO_MANY_FUN_SPREADARGS = 67, + JSMSG_UNINITIALIZED_LEXICAL = 68, + JSMSG_INVALID_DATE = 69, + JSMSG_BAD_TOISOSTRING_PROP = 70, + JSMSG_BAD_URI = 71, + JSMSG_INVALID_NORMALIZE_FORM = 72, + JSMSG_NEGATIVE_REPETITION_COUNT = 73, + JSMSG_NOT_A_CODEPOINT = 74, + JSMSG_RESULTING_STRING_TOO_LARGE = 75, + JSMSG_BAD_RADIX = 76, + JSMSG_PRECISION_RANGE = 77, + JSMSG_BAD_APPLY_ARGS = 78, + JSMSG_BAD_FORMAL = 79, + JSMSG_CALLER_IS_STRICT = 80, + JSMSG_DEPRECATED_USAGE = 81, + JSMSG_FUNCTION_ARGUMENTS_AND_REST = 82, + JSMSG_NOT_SCRIPTED_FUNCTION = 83, + JSMSG_NO_REST_NAME = 84, + JSMSG_PARAMETER_AFTER_REST = 85, + JSMSG_TOO_MANY_FUN_APPLY_ARGS = 86, + JSMSG_CSP_BLOCKED_EVAL = 87, + JSMSG_CSP_BLOCKED_FUNCTION = 88, + JSMSG_ACCESSOR_DEF_DENIED = 89, + JSMSG_DEAD_OBJECT = 90, + JSMSG_UNWRAP_DENIED = 91, + JSMSG_BAD_CHAR = 92, + JSMSG_BAD_CLONE_FUNOBJ_SCOPE = 93, + JSMSG_BAD_NEW_RESULT = 94, + JSMSG_BAD_TYPE = 95, + JSMSG_CANT_CLONE_OBJECT = 96, + JSMSG_CANT_OPEN = 97, + JSMSG_USER_DEFINED_ERROR = 98, + JSMSG_ALLOC_OVERFLOW = 99, + JSMSG_BAD_BYTECODE = 100, + JSMSG_BAD_SCRIPT_MAGIC = 101, + JSMSG_BUFFER_TOO_SMALL = 102, + JSMSG_BYTECODE_TOO_BIG = 103, + JSMSG_CANT_SET_ARRAY_ATTRS = 104, + JSMSG_INACTIVE = 105, + JSMSG_NEED_DIET = 106, + JSMSG_OUT_OF_MEMORY = 107, + JSMSG_OVER_RECURSED = 108, + JSMSG_TOO_BIG_TO_ENCODE = 109, + JSMSG_TOO_DEEP = 110, + JSMSG_UNCAUGHT_EXCEPTION = 111, + JSMSG_UNKNOWN_FORMAT = 112, + JSMSG_ACCESSOR_WRONG_ARGS = 113, + JSMSG_ARGUMENTS_AND_REST = 114, + JSMSG_ARRAY_COMP_LEFTSIDE = 115, + JSMSG_ARRAY_INIT_TOO_BIG = 116, + JSMSG_AS_AFTER_RESERVED_WORD = 117, + JSMSG_BAD_ANON_GENERATOR_RETURN = 118, + JSMSG_BAD_ARROW_ARGS = 119, + JSMSG_BAD_BINDING = 120, + JSMSG_BAD_CONST_DECL = 121, + JSMSG_BAD_CONST_ASSIGN = 122, + JSMSG_BAD_CONTINUE = 123, + JSMSG_BAD_DESTRUCT_ASS = 124, + JSMSG_BAD_DESTRUCT_TARGET = 125, + JSMSG_BAD_DESTRUCT_DECL = 126, + JSMSG_BAD_DUP_ARGS = 127, + JSMSG_BAD_FOR_EACH_LOOP = 128, + JSMSG_BAD_FOR_LEFTSIDE = 129, + JSMSG_BAD_GENERATOR_RETURN = 130, + JSMSG_BAD_GENERATOR_SYNTAX = 131, + JSMSG_BAD_GENEXP_BODY = 132, + JSMSG_BAD_INCOP_OPERAND = 133, + JSMSG_BAD_METHOD_DEF = 134, + JSMSG_BAD_OCTAL = 135, + JSMSG_BAD_OPERAND = 136, + JSMSG_BAD_PROP_ID = 137, + JSMSG_BAD_RETURN_OR_YIELD = 138, + JSMSG_BAD_STRICT_ASSIGN = 139, + JSMSG_BAD_SWITCH = 140, + JSMSG_BRACKET_AFTER_ARRAY_COMPREHENSION = 141, + JSMSG_BRACKET_AFTER_LIST = 142, + JSMSG_BRACKET_IN_INDEX = 143, + JSMSG_CATCH_AFTER_GENERAL = 144, + JSMSG_CATCH_IDENTIFIER = 145, + JSMSG_CATCH_OR_FINALLY = 146, + JSMSG_CATCH_WITHOUT_TRY = 147, + JSMSG_COLON_AFTER_CASE = 148, + JSMSG_COLON_AFTER_ID = 149, + JSMSG_COLON_IN_COND = 150, + JSMSG_COMP_PROP_UNTERM_EXPR = 151, + JSMSG_CONTRARY_NONDIRECTIVE = 152, + JSMSG_CURLY_AFTER_BODY = 153, + JSMSG_CURLY_AFTER_CATCH = 154, + JSMSG_CURLY_AFTER_FINALLY = 155, + JSMSG_CURLY_AFTER_LET = 156, + JSMSG_CURLY_AFTER_LIST = 157, + JSMSG_CURLY_AFTER_TRY = 158, + JSMSG_CURLY_BEFORE_BODY = 159, + JSMSG_CURLY_BEFORE_CATCH = 160, + JSMSG_CURLY_BEFORE_CLASS = 161, + JSMSG_CURLY_BEFORE_FINALLY = 162, + JSMSG_CURLY_BEFORE_SWITCH = 163, + JSMSG_CURLY_BEFORE_TRY = 164, + JSMSG_CURLY_IN_COMPOUND = 165, + JSMSG_DECLARATION_AFTER_EXPORT = 166, + JSMSG_DECLARATION_AFTER_IMPORT = 167, + JSMSG_DEPRECATED_DELETE_OPERAND = 168, + JSMSG_DEPRECATED_LET_BLOCK = 169, + JSMSG_DEPRECATED_FOR_EACH = 170, + JSMSG_DEPRECATED_LET_EXPRESSION = 171, + JSMSG_DEPRECATED_OCTAL = 172, + JSMSG_DEPRECATED_PRAGMA = 173, + JSMSG_DUPLICATE_FORMAL = 174, + JSMSG_DUPLICATE_LABEL = 175, + JSMSG_DUPLICATE_PROPERTY = 176, + JSMSG_EMPTY_CONSEQUENT = 177, + JSMSG_EQUAL_AS_ASSIGN = 178, + JSMSG_EXPORT_DECL_AT_TOP_LEVEL = 179, + JSMSG_FINALLY_WITHOUT_TRY = 180, + JSMSG_FROM_AFTER_IMPORT_SPEC_SET = 181, + JSMSG_GARBAGE_AFTER_INPUT = 182, + JSMSG_IDSTART_AFTER_NUMBER = 183, + JSMSG_ILLEGAL_CHARACTER = 184, + JSMSG_IMPORT_DECL_AT_TOP_LEVEL = 185, + JSMSG_INVALID_FOR_IN_INIT = 186, + JSMSG_INVALID_FOR_OF_INIT = 187, + JSMSG_IN_AFTER_FOR_NAME = 188, + JSMSG_LABEL_NOT_FOUND = 189, + JSMSG_LET_CLASS_BINDING = 190, + JSMSG_LET_COMP_BINDING = 191, + JSMSG_LEXICAL_DECL_NOT_IN_BLOCK = 192, + JSMSG_LINE_BREAK_AFTER_THROW = 193, + JSMSG_MALFORMED_ESCAPE = 194, + JSMSG_MISSING_BINARY_DIGITS = 195, + JSMSG_MISSING_EXPONENT = 196, + JSMSG_MISSING_EXPR_AFTER_THROW = 197, + JSMSG_MISSING_FORMAL = 198, + JSMSG_MISSING_HEXDIGITS = 199, + JSMSG_MISSING_OCTAL_DIGITS = 200, + JSMSG_MODULES_NOT_IMPLEMENTED = 201, + JSMSG_MODULE_SPEC_AFTER_FROM = 202, + JSMSG_NAME_AFTER_DOT = 203, + JSMSG_NONDEFAULT_FORMAL_AFTER_DEFAULT = 204, + JSMSG_NO_BINDING_NAME = 205, + JSMSG_NO_CLASS_CONSTRUCTOR = 206, + JSMSG_NO_EXPORT_NAME = 207, + JSMSG_NO_IMPORT_NAME = 208, + JSMSG_NO_VARIABLE_NAME = 209, + JSMSG_OF_AFTER_FOR_NAME = 210, + JSMSG_PAREN_AFTER_ARGS = 211, + JSMSG_PAREN_AFTER_CATCH = 212, + JSMSG_PAREN_AFTER_COND = 213, + JSMSG_PAREN_AFTER_FOR = 214, + JSMSG_PAREN_AFTER_FORMAL = 215, + JSMSG_PAREN_AFTER_FOR_CTRL = 216, + JSMSG_PAREN_AFTER_FOR_OF_ITERABLE = 217, + JSMSG_PAREN_AFTER_LET = 218, + JSMSG_PAREN_AFTER_SWITCH = 219, + JSMSG_PAREN_AFTER_WITH = 220, + JSMSG_PAREN_BEFORE_CATCH = 221, + JSMSG_PAREN_BEFORE_COND = 222, + JSMSG_PAREN_BEFORE_FORMAL = 223, + JSMSG_PAREN_BEFORE_LET = 224, + JSMSG_PAREN_BEFORE_SWITCH = 225, + JSMSG_PAREN_BEFORE_WITH = 226, + JSMSG_PAREN_IN_PAREN = 227, + JSMSG_RC_AFTER_EXPORT_SPEC_LIST = 228, + JSMSG_RC_AFTER_IMPORT_SPEC_LIST = 229, + JSMSG_REDECLARED_CATCH_IDENTIFIER = 230, + JSMSG_REDECLARED_PARAM = 231, + JSMSG_RESERVED_ID = 232, + JSMSG_REST_WITH_DEFAULT = 233, + JSMSG_SELFHOSTED_TOP_LEVEL_LEXICAL = 234, + JSMSG_SELFHOSTED_UNBOUND_NAME = 235, + JSMSG_SEMI_AFTER_FOR_COND = 236, + JSMSG_SEMI_AFTER_FOR_INIT = 237, + JSMSG_SEMI_BEFORE_STMNT = 238, + JSMSG_SOURCE_TOO_LONG = 239, + JSMSG_STRICT_CODE_LET_EXPR_STMT = 240, + JSMSG_STRICT_CODE_WITH = 241, + JSMSG_STRICT_FUNCTION_STATEMENT = 242, + JSMSG_TEMPLSTR_UNTERM_EXPR = 243, + JSMSG_SIMD_NOT_A_VECTOR = 244, + JSMSG_TOO_MANY_CASES = 245, + JSMSG_TOO_MANY_CATCH_VARS = 246, + JSMSG_TOO_MANY_CON_ARGS = 247, + JSMSG_TOO_MANY_DEFAULTS = 248, + JSMSG_TOO_MANY_FUN_ARGS = 249, + JSMSG_TOO_MANY_LOCALS = 250, + JSMSG_TOO_MANY_YIELDS = 251, + JSMSG_TOUGH_BREAK = 252, + JSMSG_UNEXPECTED_TOKEN = 253, + JSMSG_UNNAMED_CLASS_STMT = 254, + JSMSG_UNNAMED_FUNCTION_STMT = 255, + JSMSG_UNTERMINATED_COMMENT = 256, + JSMSG_UNTERMINATED_REGEXP = 257, + JSMSG_UNTERMINATED_STRING = 258, + JSMSG_USELESS_EXPR = 259, + JSMSG_USE_ASM_DIRECTIVE_FAIL = 260, + JSMSG_VAR_HIDES_ARG = 261, + JSMSG_WHILE_AFTER_DO = 262, + JSMSG_YIELD_IN_ARROW = 263, + JSMSG_YIELD_IN_DEFAULT = 264, + JSMSG_BAD_COLUMN_NUMBER = 265, + JSMSG_COMPUTED_NAME_IN_PATTERN = 266, + JSMSG_DEFAULT_IN_PATTERN = 267, + JSMSG_USE_ASM_TYPE_FAIL = 268, + JSMSG_USE_ASM_LINK_FAIL = 269, + JSMSG_USE_ASM_TYPE_OK = 270, + JSMSG_BAD_TRAP_RETURN_VALUE = 271, + JSMSG_CANT_CHANGE_EXTENSIBILITY = 272, + JSMSG_CANT_DEFINE_INVALID = 273, + JSMSG_CANT_DEFINE_NEW = 274, + JSMSG_CANT_DEFINE_NE_AS_NC = 275, + JSMSG_PROXY_DEFINE_RETURNED_FALSE = 276, + JSMSG_PROXY_DELETE_RETURNED_FALSE = 277, + JSMSG_PROXY_PREVENTEXTENSIONS_RETURNED_FALSE = 278, + JSMSG_PROXY_SET_RETURNED_FALSE = 279, + JSMSG_CANT_REPORT_AS_NON_EXTENSIBLE = 280, + JSMSG_CANT_REPORT_C_AS_NC = 281, + JSMSG_CANT_REPORT_E_AS_NE = 282, + JSMSG_CANT_REPORT_INVALID = 283, + JSMSG_CANT_REPORT_NC_AS_NE = 284, + JSMSG_CANT_REPORT_NEW = 285, + JSMSG_CANT_REPORT_NE_AS_NC = 286, + JSMSG_CANT_SET_NW_NC = 287, + JSMSG_CANT_SET_WO_SETTER = 288, + JSMSG_CANT_SKIP_NC = 289, + JSMSG_INVALID_TRAP_RESULT = 290, + JSMSG_MUST_REPORT_SAME_VALUE = 291, + JSMSG_MUST_REPORT_UNDEFINED = 292, + JSMSG_OBJECT_ACCESS_DENIED = 293, + JSMSG_PROPERTY_ACCESS_DENIED = 294, + JSMSG_PROXY_CONSTRUCT_OBJECT = 295, + JSMSG_PROXY_EXTENSIBILITY = 296, + JSMSG_PROXY_GETOWN_OBJORUNDEF = 297, + JSMSG_PROXY_REVOKED = 298, + JSMSG_SC_BAD_CLONE_VERSION = 299, + JSMSG_SC_BAD_SERIALIZED_DATA = 300, + JSMSG_SC_DUP_TRANSFERABLE = 301, + JSMSG_SC_NOT_TRANSFERABLE = 302, + JSMSG_SC_UNSUPPORTED_TYPE = 303, + JSMSG_SC_SHMEM_MUST_TRANSFER = 304, + JSMSG_ASSIGN_FUNCTION_OR_NULL = 305, + JSMSG_DEBUG_BAD_LINE = 306, + JSMSG_DEBUG_BAD_OFFSET = 307, + JSMSG_DEBUG_BAD_REFERENT = 308, + JSMSG_DEBUG_BAD_RESUMPTION = 309, + JSMSG_DEBUG_CANT_DEBUG_GLOBAL = 310, + JSMSG_DEBUG_CCW_REQUIRED = 311, + JSMSG_DEBUG_COMPARTMENT_MISMATCH = 312, + JSMSG_DEBUG_LOOP = 313, + JSMSG_DEBUG_NOT_DEBUGGEE = 314, + JSMSG_DEBUG_NOT_DEBUGGING = 315, + JSMSG_DEBUG_NOT_IDLE = 316, + JSMSG_DEBUG_NOT_LIVE = 317, + JSMSG_DEBUG_NO_SCOPE_OBJECT = 318, + JSMSG_DEBUG_OBJECT_PROTO = 319, + JSMSG_DEBUG_OBJECT_WRONG_OWNER = 320, + JSMSG_DEBUG_OPTIMIZED_OUT = 321, + JSMSG_DEBUG_RESUMPTION_VALUE_DISALLOWED = 322, + JSMSG_DEBUG_VARIABLE_NOT_FOUND = 323, + JSMSG_DEBUG_WRAPPER_IN_WAY = 324, + JSMSG_NOT_CALLABLE_OR_UNDEFINED = 325, + JSMSG_NOT_TRACKING_ALLOCATIONS = 326, + JSMSG_OBJECT_METADATA_CALLBACK_ALREADY_SET = 327, + JSMSG_QUERY_INNERMOST_WITHOUT_LINE_URL = 328, + JSMSG_QUERY_LINE_WITHOUT_URL = 329, + JSMSG_DEBUG_CANT_SET_OPT_ENV = 330, + JSMSG_DEBUG_INVISIBLE_COMPARTMENT = 331, + JSMSG_TRACELOGGER_ENABLE_FAIL = 332, + JSMSG_DATE_NOT_FINITE = 333, + JSMSG_INTERNAL_INTL_ERROR = 334, + JSMSG_INTL_OBJECT_NOT_INITED = 335, + JSMSG_INTL_OBJECT_REINITED = 336, + JSMSG_INVALID_CURRENCY_CODE = 337, + JSMSG_INVALID_DIGITS_VALUE = 338, + JSMSG_INVALID_LANGUAGE_TAG = 339, + JSMSG_INVALID_LOCALES_ELEMENT = 340, + JSMSG_INVALID_LOCALE_MATCHER = 341, + JSMSG_INVALID_OPTION_VALUE = 342, + JSMSG_INVALID_TIME_ZONE = 343, + JSMSG_UNDEFINED_CURRENCY = 344, + JSMSG_BAD_CLASS_RANGE = 345, + JSMSG_ESCAPE_AT_END_OF_REGEXP = 346, + JSMSG_INVALID_GROUP = 347, + JSMSG_MISSING_PAREN = 348, + JSMSG_NEWREGEXP_FLAGGED = 349, + JSMSG_NOTHING_TO_REPEAT = 350, + JSMSG_NUMBERS_OUT_OF_ORDER = 351, + JSMSG_TOO_MANY_PARENS = 352, + JSMSG_UNMATCHED_RIGHT_PAREN = 353, + JSMSG_UNTERM_CLASS = 354, + JSMSG_DEFAULT_LOCALE_ERROR = 355, + JSMSG_NO_SUCH_SELF_HOSTED_PROP = 356, + JSMSG_INVALID_PROTOTYPE = 357, + JSMSG_TYPEDOBJECT_ARRAYTYPE_BAD_ARGS = 358, + JSMSG_TYPEDOBJECT_BAD_ARGS = 359, + JSMSG_TYPEDOBJECT_BINARYARRAY_BAD_INDEX = 360, + JSMSG_TYPEDOBJECT_HANDLE_UNATTACHED = 361, + JSMSG_TYPEDOBJECT_STRUCTTYPE_BAD_ARGS = 362, + JSMSG_TYPEDOBJECT_TOO_BIG = 363, + JSMSG_BAD_INDEX = 364, + JSMSG_TYPED_ARRAY_BAD_ARGS = 365, + JSMSG_TYPED_ARRAY_BAD_OBJECT = 366, + JSMSG_TYPED_ARRAY_BAD_INDEX = 367, + JSMSG_TYPED_ARRAY_NEGATIVE_ARG = 368, + JSMSG_TYPED_ARRAY_DETACHED = 369, + JSMSG_SHARED_ARRAY_BAD_OBJECT = 370, + JSMSG_SHARED_ARRAY_BAD_LENGTH = 371, + JSMSG_SHARED_TYPED_ARRAY_BAD_OBJECT = 372, + JSMSG_SHARED_TYPED_ARRAY_BAD_ARGS = 373, + JSMSG_SHARED_TYPED_ARRAY_ARG_RANGE = 374, + JSMSG_SHARED_TYPED_ARRAY_BAD_LENGTH = 375, + JSMSG_BAD_PARSE_NODE = 376, + JSMSG_BAD_SYMBOL = 377, + JSMSG_SYMBOL_TO_STRING = 378, + JSMSG_SYMBOL_TO_NUMBER = 379, + JSMSG_ATOMICS_BAD_ARRAY = 380, + JSMSG_ATOMICS_TOO_LONG = 381, + JSMSG_ATOMICS_WAIT_NOT_ALLOWED = 382, + JSMSG_CANT_SET_INTERPOSED = 383, + JSMSG_CANT_DEFINE_WINDOW_ELEMENT = 384, + JSMSG_CANT_DELETE_WINDOW_ELEMENT = 385, + JSMSG_CANT_DELETE_WINDOW_NAMED_PROPERTY = 386, + JSMSG_CANT_PREVENT_EXTENSIONS = 387, + JSErr_Limit = 388, +} +#[repr(C)] +pub struct AutoStableStringChars { + pub s_: RootedString, + pub _bindgen_data_1_: [u32; 1usize], + pub state_: State, + pub ownsChars_: u8, +} +impl AutoStableStringChars { + pub unsafe fn twoByteChars_(&mut self) -> *mut *const i16 { + ::std::mem::transmute(&self._bindgen_data_1_) + } + pub unsafe fn latin1Chars_(&mut self) -> *mut *const Latin1Char { + ::std::mem::transmute(&self._bindgen_data_1_) + } +} +impl ::std::default::Default for AutoStableStringChars { + fn default() -> AutoStableStringChars { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +pub struct ErrorReport { + pub reportp: *mut JSErrorReport, + pub message_: *const i8, + pub ownedReport: JSErrorReport, + pub ownedMessage: *mut i8, + pub _str: RootedString, + pub strChars: AutoStableStringChars, + pub exnObject: RootedObject, + pub bytesStorage: JSAutoByteString, + pub filename: JSAutoByteString, + pub ownsMessageAndReport: u8, +} +impl ::std::default::Default for ErrorReport { + fn default() -> ErrorReport { unsafe { ::std::mem::zeroed() } } +} +#[repr(i32)] +#[derive(Copy, Clone)] +pub enum Type { + Int8 = 0, + Uint8 = 1, + Int16 = 2, + Uint16 = 3, + Int32 = 4, + Uint32 = 5, + Float32 = 6, + Float64 = 7, + Uint8Clamped = 8, + MaxTypedArrayViewType = 9, + Float32x4 = 10, + Int32x4 = 11, +} +#[repr(i32)] +#[derive(Copy, Clone)] +pub enum jsfriendapi_hpp_unnamed_9 { ChangeData = 0, KeepData = 1, } +pub type NeuterDataDisposition = jsfriendapi_hpp_unnamed_9; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct JSJitGetterCallArgs { + pub _base: MutableHandleValue +} +impl ::std::default::Default for JSJitGetterCallArgs { + fn default() -> JSJitGetterCallArgs { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct JSJitSetterCallArgs { + pub _base: HandleValue +} +impl ::std::default::Default for JSJitSetterCallArgs { + fn default() -> JSJitSetterCallArgs { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct JSJitMethodCallArgs { + pub argv_: *mut Value, + pub argc_: u32, +} +impl ::std::default::Default for JSJitMethodCallArgs { + fn default() -> JSJitMethodCallArgs { unsafe { ::std::mem::zeroed() } } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct JSJitMethodCallArgsTraits; +impl ::std::default::Default for JSJitMethodCallArgsTraits { + fn default() -> JSJitMethodCallArgsTraits { + unsafe { ::std::mem::zeroed() } + } +} +pub type JSJitGetterOp = + ::std::option::Option u8>; +pub type JSJitSetterOp = + ::std::option::Option u8>; +pub type JSJitMethodOp = + ::std::option::Option u8>; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct JSJitInfo { + pub _bindgen_data_1_: *const ::libc::c_void, + pub protoID: u16, + pub depth: u16, + pub _bitfield_1: u32, +} +impl JSJitInfo { + pub unsafe fn getter(&mut self) -> *mut JSJitGetterOp { + ::std::mem::transmute(&self._bindgen_data_1_) + } + pub unsafe fn setter(&mut self) -> *mut JSJitSetterOp { + ::std::mem::transmute(&self._bindgen_data_1_) + } + pub unsafe fn method(&mut self) -> *mut JSJitMethodOp { + ::std::mem::transmute(&self._bindgen_data_1_) + } + pub unsafe fn staticMethod(&mut self) -> *mut JSNative { + ::std::mem::transmute(&self._bindgen_data_1_) + } +} +impl ::std::default::Default for JSJitInfo { + fn default() -> JSJitInfo { unsafe { ::std::mem::zeroed() } } +} +#[repr(i32)] +#[derive(Copy, Clone)] +pub enum JSJitInfo_OpType { + Getter = 0, + Setter = 1, + Method = 2, + StaticMethod = 3, + OpTypeCount = 4, +} +#[repr(i32)] +#[derive(Copy, Clone)] +pub enum JSJitInfo_ArgType { + String = 1, + Integer = 2, + Double = 4, + Boolean = 8, + Object = 16, + Null = 32, + Numeric = 6, + Primitive = 47, + ObjectOrNull = 48, + Any = 63, + ArgTypeListEnd = -2147483648, +} +#[repr(i32)] +#[derive(Copy, Clone)] +pub enum JSJitInfo_AliasSet { + AliasNone = 0, + AliasDOMSets = 1, + AliasEverything = 2, + AliasSetCount = 3, +} +impl JSJitInfo { + pub fn set_type_(&mut self, val: u8) { + self._bitfield_1 &= !(((1 << 4usize) - 1) << 0usize); + self._bitfield_1 |= (val as u32) << 0usize; + } + pub fn set_aliasSet_(&mut self, val: u8) { + self._bitfield_1 &= !(((1 << 4usize) - 1) << 4usize); + self._bitfield_1 |= (val as u32) << 4usize; + } + pub fn set_returnType_(&mut self, val: u8) { + self._bitfield_1 &= !(((1 << 8usize) - 1) << 8usize); + self._bitfield_1 |= (val as u32) << 8usize; + } + pub fn set_isInfallible(&mut self, val: bool) { + self._bitfield_1 &= !(((1 << 1usize) - 1) << 16usize); + self._bitfield_1 |= (val as u32) << 16usize; + } + pub fn set_isMovable(&mut self, val: bool) { + self._bitfield_1 &= !(((1 << 1usize) - 1) << 17usize); + self._bitfield_1 |= (val as u32) << 17usize; + } + pub fn set_isAlwaysInSlot(&mut self, val: bool) { + self._bitfield_1 &= !(((1 << 1usize) - 1) << 18usize); + self._bitfield_1 |= (val as u32) << 18usize; + } + pub fn set_isLazilyCachedInSlot(&mut self, val: bool) { + self._bitfield_1 &= !(((1 << 1usize) - 1) << 19usize); + self._bitfield_1 |= (val as u32) << 19usize; + } + pub fn set_isTypedMethod(&mut self, val: bool) { + self._bitfield_1 &= !(((1 << 1usize) - 1) << 20usize); + self._bitfield_1 |= (val as u32) << 20usize; + } + pub fn set_slotIndex(&mut self, val: u16) { + self._bitfield_1 &= !(((1 << 11usize) - 1) << 21usize); + self._bitfield_1 |= (val as u32) << 21usize; + } + pub fn new_bitfield_1(type_: u8, aliasSet_: u8, returnType_: u8, + isInfallible: bool, isMovable: bool, + isAlwaysInSlot: bool, isLazilyCachedInSlot: bool, + isTypedMethod: bool, slotIndex: u16) -> u32 { + let mut _bitfield_val_ = 0; + _bitfield_val_ |= (type_ as u32) << 0u32; + _bitfield_val_ |= (aliasSet_ as u32) << 4u32; + _bitfield_val_ |= (returnType_ as u32) << 8u32; + _bitfield_val_ |= (isInfallible as u32) << 16u32; + _bitfield_val_ |= (isMovable as u32) << 17u32; + _bitfield_val_ |= (isAlwaysInSlot as u32) << 18u32; + _bitfield_val_ |= (isLazilyCachedInSlot as u32) << 19u32; + _bitfield_val_ |= (isTypedMethod as u32) << 20u32; + _bitfield_val_ |= (slotIndex as u32) << 21u32; + _bitfield_val_ + } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct JSTypedMethodJitInfo { + pub base: JSJitInfo, + pub argTypes: *const ArgType, +} +impl ::std::default::Default for JSTypedMethodJitInfo { + fn default() -> JSTypedMethodJitInfo { unsafe { ::std::mem::zeroed() } } +} +pub type DefaultJSContextCallback = + ::std::option::Option *mut JSContext>; +#[repr(i32)] +#[derive(Copy, Clone)] +pub enum CTypesActivityType { + CTYPES_CALL_BEGIN = 0, + CTYPES_CALL_END = 1, + CTYPES_CALLBACK_BEGIN = 2, + CTYPES_CALLBACK_END = 3, +} +pub type CTypesActivityCallback = + ::std::option::Option; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct AutoCTypesActivityCallback { + pub cx: *mut JSContext, + pub callback: CTypesActivityCallback, + pub endType: CTypesActivityType, +} +impl ::std::default::Default for AutoCTypesActivityCallback { + fn default() -> AutoCTypesActivityCallback { + unsafe { ::std::mem::zeroed() } + } +} +pub type ObjectMetadataCallback = + ::std::option::Option u8>; +extern "C" { + pub static JSVAL_NULL: Value; + pub static JSVAL_ZERO: Value; + pub static JSVAL_ONE: Value; + pub static JSVAL_FALSE: Value; + pub static JSVAL_TRUE: Value; + pub static JSVAL_VOID: Value; + pub static NullHandleValue: HandleValue; + pub static TrueHandleValue: HandleValue; + pub static FalseHandleValue: HandleValue; + pub static UndefinedHandleValue: HandleValue; + pub static JSID_VOID: jsid; + pub static JSID_EMPTY: jsid; + pub static JSID_VOIDHANDLE: HandleId; + pub static JSID_EMPTYHANDLE: HandleId; + pub static FunctionClassPtr: Class; + pub static ObjectClassPtr: Class; + pub static Int8ArrayClassPtr: *const Class; + pub static Uint8ArrayClassPtr: *const Class; + pub static Uint8ClampedArrayClassPtr: *const Class; + pub static Int16ArrayClassPtr: *const Class; + pub static Uint16ArrayClassPtr: *const Class; + pub static Int32ArrayClassPtr: *const Class; + pub static Uint32ArrayClassPtr: *const Class; + pub static Float32ArrayClassPtr: *const Class; + pub static Float64ArrayClassPtr: *const Class; + pub static SharedInt8ArrayClassPtr: *const Class; + pub static SharedUint8ArrayClassPtr: *const Class; + pub static SharedUint8ClampedArrayClassPtr: *const Class; + pub static SharedInt16ArrayClassPtr: *const Class; + pub static SharedUint16ArrayClassPtr: *const Class; + pub static SharedInt32ArrayClassPtr: *const Class; + pub static SharedUint32ArrayClassPtr: *const Class; + pub static SharedFloat32ArrayClassPtr: *const Class; + pub static SharedFloat64ArrayClassPtr: *const Class; } -pub const JSREPORT_ERROR: c_uint = 0x0; -pub const JSREPORT_WARNING: c_uint = 0x1; -pub const JSREPORT_EXCEPTION: c_uint = 0x2; -pub const JSREPORT_STRICT: c_uint = 0x4; -pub const JSREPORT_STRICT_MODE_ERROR: c_uint = 0x8; - -extern "C" { -pub fn JS_CreateHandleObject(cx: *mut JSContext, obj: *mut JSObject, phandle: *mut JSHandleObject) -> JSBool; - -pub fn JS_DestroyHandleObject(cx: *mut JSContext, handle: JSHandleObject); - -pub fn JS_CreateMutableHandleObject(cx: *mut JSContext, obj: *mut JSObject, phandle: *mut JSMutableHandleObject) -> JSBool; - -pub fn JS_DestroyMutableHandleObject(cx: *mut JSContext, handle: JSMutableHandleObject); - -pub fn JS_CreateHandleId(cx: *mut JSContext, id: jsid, phandle: *mut JSHandleId) -> JSBool; - -pub fn JS_DestroyHandleId(cx: *mut JSContext, handle: JSHandleId); - -pub fn JS_StringHasBeenInterned(cx: *mut JSContext, str: *mut JSString) -> JSBool; - -pub fn INTERNED_STRING_TO_JSID(cx: *mut JSContext, str: *mut JSString) -> jsid; - -pub fn JS_CallOnce(_once: *mut JSCallOnceType, func: JSInitCallback) -> JSBool; - -pub fn JS_Now() -> int64_t; - -pub fn JS_GetNaNValue(cx: *mut JSContext) -> JSVal; - -pub fn JS_GetNegativeInfinityValue(cx: *mut JSContext) -> JSVal; - -pub fn JS_GetPositiveInfinityValue(cx: *mut JSContext) -> JSVal; - -pub fn JS_GetEmptyStringValue(cx: *mut JSContext) -> JSVal; - -pub fn JS_GetEmptyString(rt: *mut JSRuntime) -> *mut JSString; - -pub fn JS_ConvertArguments(cx: *mut JSContext, argc: c_uint, argv: *mut JSVal, format: *const c_char, ...) -> JSBool; - -pub fn JS_ConvertValue(cx: *mut JSContext, v: JSVal, _type: JSType, vp: *mut JSVal) -> JSBool; - -pub fn JS_ValueToObject(cx: *mut JSContext, v: JSVal, objp: *mut *mut JSObject) -> JSBool; - -pub fn JS_ValueToFunction(cx: *mut JSContext, v: JSVal) -> *mut JSFunction; - -pub fn JS_ValueToConstructor(cx: *mut JSContext, v: JSVal) -> *mut JSFunction; - -pub fn JS_ValueToString(cx: *mut JSContext, v: JSVal) -> *mut JSString; - -pub fn JS_ValueToSource(cx: *mut JSContext, v: JSVal) -> *mut JSString; - -pub fn JS_ValueToNumber(cx: *mut JSContext, v: JSVal, dp: *mut c_double) -> JSBool; - -pub fn JS_DoubleIsInt32(d: c_double, ip: *mut int32_t) -> JSBool; - -pub fn JS_DoubleToInt32(d: c_double) -> int32_t; - -pub fn JS_DoubleToUint32(d: c_double) -> uint32_t; - -pub fn JS_ValueToECMAInt32(cx: *mut JSContext, v: JSVal, ip: *mut int32_t) -> JSBool; - -pub fn JS_ValueToInt64(cx: *mut JSContext, v: JSVal, ip: *mut int64_t) -> JSBool; - -pub fn JS_ValueToUint64(cx: *mut JSContext, v: JSVal, ip: *mut uint64_t) -> JSBool; - -pub fn JS_ValueToECMAUint32(cx: *mut JSContext, v: JSVal, ip: *mut uint32_t) -> JSBool; - -pub fn JS_ValueToInt32(cx: *mut JSContext, v: JSVal, ip: *mut int32_t) -> JSBool; - -pub fn JS_ValueToUint16(cx: *mut JSContext, v: JSVal, ip: *mut uint16_t) -> JSBool; - -pub fn JS_ValueToBoolean(cx: *mut JSContext, v: JSVal, bp: *mut JSBool) -> JSBool; - -pub fn JS_TypeOfValue(cx: *mut JSContext, v: JSVal) -> JSType; - -pub fn JS_GetTypeName(cx: *mut JSContext, _type: JSType) -> *const c_char; - -pub fn JS_StrictlyEqual(cx: *mut JSContext, v1: JSVal, v2: JSVal, equal: *mut JSBool) -> JSBool; - -pub fn JS_LooselyEqual(cx: *mut JSContext, v1: JSVal, v2: JSVal, equal: *mut JSBool) -> JSBool; - -pub fn JS_SameValue(cx: *mut JSContext, v1: JSVal, v2: JSVal, same: *mut JSBool) -> JSBool; - -pub fn JS_IsBuiltinEvalFunction(fun: *mut JSFunction) -> JSBool; - -pub fn JS_IsBuiltinFunctionConstructor(fun: *mut JSFunction) -> JSBool; - -pub fn JS_Init(maxbytes: uint32_t) -> *mut JSRuntime; - -pub fn JS_Finish(rt: *mut JSRuntime); - -pub fn JS_ShutDown(); - -pub fn JS_GetRuntimePrivate(rt: *mut JSRuntime) -> *mut c_void; - -pub fn JS_GetRuntime(cx: *mut JSContext) -> *mut JSRuntime; - -pub fn JS_SetRuntimePrivate(rt: *mut JSRuntime, data: *mut c_void); - -pub fn JS_BeginRequest(cx: *mut JSContext); - -pub fn JS_EndRequest(cx: *mut JSContext); - -pub fn JS_YieldRequest(cx: *mut JSContext); - -pub fn JS_SuspendRequest(cx: *mut JSContext) -> c_uint; - -pub fn JS_ResumeRequest(cx: *mut JSContext, saveDepth: c_uint); - -pub fn JS_IsInRequest(rt: *mut JSRuntime) -> JSBool; - -pub fn JS_IsInSuspendedRequest(rt: *mut JSRuntime) -> JSBool; - -pub fn JS_SetContextCallback(rt: *mut JSRuntime, cxCallback: JSContextCallback) -> JSContextCallback; - -pub fn JS_NewContext(rt: *mut JSRuntime, stackChunkSize: size_t) -> *mut JSContext; - -pub fn JS_DestroyContext(cx: *mut JSContext); - -pub fn JS_DestroyContextNoGC(cx: *mut JSContext); - -pub fn JS_GetContextPrivate(cx: *mut JSContext) -> *mut c_void; - -pub fn JS_SetContextPrivate(cx: *mut JSContext, data: *mut c_void); - -pub fn JS_GetSecondContextPrivate(cx: *mut JSContext) -> *mut c_void; - -pub fn JS_SetSecondContextPrivate(cx: *mut JSContext, data: *mut c_void); - -pub fn JS_ContextIterator(rt: *mut JSRuntime, iterp: *mut *mut JSContext) -> *mut JSContext; - -pub fn JS_GetVersion(cx: *mut JSContext) -> JSVersion; - -pub fn JS_SetVersion(cx: *mut JSContext, version: JSVersion) -> JSVersion; - -pub fn JS_VersionToString(version: JSVersion) -> *const c_char; - -pub fn JS_StringToVersion(string: *const c_char) -> JSVersion; - -pub fn JS_GetOptions(cx: *mut JSContext) -> uint32_t; - -pub fn JS_SetOptions(cx: *mut JSContext, options: uint32_t) -> uint32_t; - -pub fn JS_ToggleOptions(cx: *mut JSContext, options: uint32_t) -> uint32_t; - -pub fn JS_SetJitHardening(rt: *mut JSRuntime, enabled: JSBool); - -pub fn JS_GetImplementationVersion() -> *const c_char; - -pub fn JS_SetDestroyCompartmentCallback(rt: *mut JSRuntime, callback: JSDestroyCompartmentCallback); - -pub fn JS_SetCompartmentNameCallback(rt: *mut JSRuntime, callback: JSCompartmentNameCallback); - -pub fn JS_SetWrapObjectCallbacks(rt: *mut JSRuntime, callback: JSWrapObjectCallback, sccallback: JSSameCompartmentWrapObjectCallback, precallback: JSPreWrapCallback) -> JSWrapObjectCallback; - -pub fn JS_EnterCrossCompartmentCall(cx: *mut JSContext, target: JSRawObject) -> *mut JSCrossCompartmentCall; - -pub fn JS_LeaveCrossCompartmentCall(call: *mut JSCrossCompartmentCall); - -pub fn JS_SetCompartmentPrivate(compartment: *mut JSCompartment, data: *mut c_void); - -pub fn JS_GetCompartmentPrivate(compartment: *mut JSCompartment) -> *mut c_void; - -pub fn JS_WrapObject(cx: *mut JSContext, objp: *mut *mut JSObject) -> JSBool; - -pub fn JS_WrapValue(cx: *mut JSContext, vp: *mut JSVal) -> JSBool; - -pub fn JS_TransplantObject(cx: *mut JSContext, origobj: *mut JSObject, target: *mut JSObject) -> *mut JSObject; - -pub fn js_TransplantObjectWithWrapper(cx: *mut JSContext, origobj: *mut JSObject, origwrapper: *mut JSObject, targetobj: *mut JSObject, targetwrapper: *mut JSObject) -> *mut JSObject; - -pub fn JS_RefreshCrossCompartmentWrappers(cx: *mut JSContext, ob: *mut JSObject) -> JSBool; - -pub fn JS_IterateCompartments(rt: *mut JSRuntime, data: *mut c_void, compartmentCallback: JSIterateCompartmentCallback); - -pub fn JS_GetGlobalObject(cx: *mut JSContext) -> *mut JSObject; - -pub fn JS_SetGlobalObject(cx: *mut JSContext, obj: JSRawObject); - -pub fn JS_InitStandardClasses(cx: *mut JSContext, obj: *mut JSObject) -> JSBool; - -pub fn JS_ResolveStandardClass(cx: *mut JSContext, obj: *mut JSObject, id: jsid, resolved: *mut JSBool) -> JSBool; - -pub fn JS_EnumerateStandardClasses(cx: *mut JSContext, obj: *mut JSObject) -> JSBool; - -pub fn JS_EnumerateResolvedStandardClasses(cx: *mut JSContext, obj: *mut JSObject, ida: *mut JSIdArray) -> *mut JSIdArray; - -pub fn JS_GetClassObject(cx: *mut JSContext, obj: JSRawObject, key: JSProtoKey, objp: *mut *mut JSObject) -> JSBool; - -pub fn JS_GetClassPrototype(cx: *mut JSContext, key: JSProtoKey, objp: *mut *mut JSObject) -> JSBool; - -pub fn JS_IdentifyClassPrototype(cx: *mut JSContext, obj: *mut JSObject) -> JSProtoKey; - -pub fn JS_GetFunctionPrototype(cx: *mut JSContext, forObj: JSRawObject) -> *mut JSObject; - -pub fn JS_GetObjectPrototype(cx: *mut JSContext, forObj: JSRawObject) -> *mut JSObject; - -pub fn JS_GetGlobalForObject(cx: *mut JSContext, obj: JSRawObject) -> *mut JSObject; - -pub fn JS_GetGlobalForCompartmentOrNull(cx: *mut JSContext, c: *mut JSCompartment) -> *mut JSObject; - -pub fn JS_GetGlobalForScopeChain(cx: *mut JSContext) -> *mut JSObject; - -pub fn JS_GetScriptedGlobal(cx: *mut JSContext) -> *mut JSObject; - -pub fn JS_InitReflect(cx: *mut JSContext, global: *mut JSObject) -> *mut JSObject; - -pub fn JS_EnumerateDiagnosticMemoryRegions(callback: JSEnumerateDiagnosticMemoryCallback); - -pub fn JS_ComputeThis(cx: *mut JSContext, vp: *mut JSVal) -> JSVal; - -pub fn JS_MallocInCompartment(comp: *mut JSCompartment, nbytes: size_t); - -pub fn JS_FreeInCompartment(comp: *mut JSCompartment, nbytes: size_t); - -pub fn JS_malloc(cx: *mut JSContext, nbytes: size_t) -> *mut c_void; - -pub fn JS_realloc(cx: *mut JSContext, p: *mut c_void, nbytes: size_t) -> *mut c_void; - -pub fn JS_free(cx: *mut JSContext, p: *mut c_void); - -pub fn JS_freeop(fop: *mut JSFreeOp, p: *mut c_void); - -pub fn JS_GetDefaultFreeOp(rt: *mut JSRuntime) -> *mut JSFreeOp; - -pub fn JS_updateMallocCounter(cx: *mut JSContext, nbytes: size_t); - -pub fn JS_strdup(cx: *mut JSContext, s: *const c_char) -> *mut c_char; - -pub fn JS_AddValueRoot(cx: *mut JSContext, vp: *mut JSVal) -> JSBool; - -pub fn JS_AddStringRoot(cx: *mut JSContext, rp: *mut *mut JSString) -> JSBool; - -pub fn JS_AddObjectRoot(cx: *mut JSContext, rp: *mut *mut JSObject) -> JSBool; - -pub fn JS_AddGCThingRoot(cx: *mut JSContext, rp: *mut *mut c_void) -> JSBool; - -pub fn JS_AddNamedValueRoot(cx: *mut JSContext, vp: *mut JSVal, name: *const c_char) -> JSBool; - -pub fn JS_AddNamedStringRoot(cx: *mut JSContext, rp: *mut *mut JSString, name: *const c_char) -> JSBool; - -pub fn JS_AddNamedObjectRoot(cx: *mut JSContext, rp: *mut *mut JSObject, name: *const c_char) -> JSBool; - -pub fn JS_AddNamedScriptRoot(cx: *mut JSContext, rp: *mut *mut JSScript, name: *const c_char) -> JSBool; - -pub fn JS_AddNamedGCThingRoot(cx: *mut JSContext, rp: *mut *mut c_void, name: *const c_char) -> JSBool; - -pub fn JS_RemoveValueRoot(cx: *mut JSContext, vp: *mut JSVal); - -pub fn JS_RemoveStringRoot(cx: *mut JSContext, rp: *mut *mut JSString); - -pub fn JS_RemoveObjectRoot(cx: *mut JSContext, rp: *mut *mut JSObject); - -pub fn JS_RemoveScriptRoot(cx: *mut JSContext, rp: *mut *mut JSScript); - -pub fn JS_RemoveGCThingRoot(cx: *mut JSContext, rp: *mut *mut c_void); - -pub fn JS_RemoveValueRootRT(rt: *mut JSRuntime, vp: *mut JSVal); - -pub fn JS_RemoveStringRootRT(rt: *mut JSRuntime, rp: *mut *mut JSString); - -pub fn JS_RemoveObjectRootRT(rt: *mut JSRuntime, rp: *mut *mut JSObject); - -pub fn js_AddRootRT(rt: *mut JSRuntime, vp: *mut JSVal, name: *const c_char) -> JSBool; - -pub fn js_AddGCThingRootRT(rt: *mut JSRuntime, rp: *mut *mut c_void, name: *const c_char) -> JSBool; - -pub fn js_RemoveRoot(rt: *mut JSRuntime, rp: *mut c_void); - -pub fn JS_AnchorPtr(p: *mut c_void); - -pub fn JS_MapGCRoots(rt: *mut JSRuntime, map: JSGCRootMapFun, data: *mut c_void) -> uint32_t; - -pub fn JS_LockGCThing(cx: *mut JSContext, thing: *mut c_void) -> JSBool; - -pub fn JS_LockGCThingRT(rt: *mut JSRuntime, thing: *mut c_void) -> JSBool; - -pub fn JS_UnlockGCThing(cx: *mut JSContext, thing: *mut c_void) -> JSBool; - -pub fn JS_UnlockGCThingRT(rt: *mut JSRuntime, thing: *mut c_void) -> JSBool; - -pub fn JS_SetExtraGCRootsTracer(rt: *mut JSRuntime, traceOp: JSTraceDataOp, data: *mut c_void); - -pub fn JS_CallTracer(trc: *mut JSTracer, thing: *mut c_void, kind: JSGCTraceKind); - -pub fn JS_TracerInit(trc: *mut JSTracer, rt: *mut JSRuntime, callback: JSTraceCallback); - -pub fn JS_TraceChildren(trc: *mut JSTracer, thing: *mut c_void, kind: JSGCTraceKind); - -pub fn JS_TraceRuntime(trc: *mut JSTracer); - -pub fn JS_GetTraceThingInfo(buf: *mut c_char, bufsize: size_t, trc: *mut JSTracer, thing: *mut c_void, kind: JSGCTraceKind, includeDetails: JSBool); - -pub fn JS_GetTraceEdgeName(trc: *mut JSTracer, buffer: *mut c_char, bufferSize: c_int) -> *const c_char; - -pub fn JS_GC(rt: *mut JSRuntime); - -pub fn JS_MaybeGC(cx: *mut JSContext); - -pub fn JS_SetGCZeal(cx: *mut JSContext, zeal: uint8_t, frequency: uint32_t); - -pub fn JS_InhibitGC(cx: *mut JSContext); - -pub fn JS_AllowGC(cx: *mut JSContext); - -pub fn JS_SetGCCallback(rt: *mut JSRuntime, cb: JSGCCallback); - -pub fn JS_SetFinalizeCallback(rt: *mut JSRuntime, cb: JSFinalizeCallback); - -pub fn JS_IsGCMarkingTracer(trc: *mut JSTracer) -> JSBool; - -pub fn JS_IsAboutToBeFinalized(thing: *mut c_void) -> JSBool; - -pub fn JS_SetGCParameter(rt: *mut JSRuntime, key: JSGCParamKey, value: uint32_t); - -pub fn JS_GetGCParameter(rt: *mut JSRuntime, key: JSGCParamKey) -> uint32_t; - -pub fn JS_SetGCParameterForThread(cx: *mut JSContext, key: JSGCParamKey, value: uint32_t); - -pub fn JS_GetGCParameterForThread(cx: *mut JSContext, key: JSGCParamKey) -> uint32_t; - -pub fn JS_NewExternalString(cx: *mut JSContext, chars: *const jschar, length: size_t, fin: *const JSStringFinalizer) -> *mut JSString; - -pub fn JS_IsExternalString(str: *mut JSString) -> JSBool; - -pub fn JS_GetExternalStringFinalizer(str: *mut JSString) -> *const JSStringFinalizer; - -pub fn JS_SetNativeStackQuota(cx: *mut JSRuntime, stackSize: size_t); - -pub fn JS_IdArrayLength(cx: *mut JSContext, ida: *mut JSIdArray) -> c_int; - -pub fn JS_IdArrayGet(cx: *mut JSContext, ida: *mut JSIdArray, index: c_int) -> jsid; - -pub fn JS_DestroyIdArray(cx: *mut JSContext, ida: *mut JSIdArray); - -pub fn JS_ValueToId(cx: *mut JSContext, v: JSVal, idp: *mut jsid) -> JSBool; - -pub fn JS_IdToValue(cx: *mut JSContext, id: jsid, vp: *mut JSVal) -> JSBool; - -pub fn JS_DefaultValue(cx: *mut JSContext, obj: *mut JSObject, hint: JSType, vp: *mut JSVal) -> JSBool; - -pub fn JS_PropertyStub(cx: *mut JSContext, obj: JSHandleObject, id: JSHandleId, vp: JSMutableHandleValue) -> JSBool; - -pub fn JS_StrictPropertyStub(cx: *mut JSContext, obj: JSHandleObject, id: JSHandleId, strict: JSBool, vp: JSMutableHandleValue) -> JSBool; - -pub fn JS_EnumerateStub(cx: *mut JSContext, obj: JSHandleObject) -> JSBool; - -pub fn JS_ResolveStub(cx: *mut JSContext, obj: JSHandleObject, id: JSHandleId) -> JSBool; - -pub fn JS_ConvertStub(cx: *mut JSContext, obj: JSHandleObject, _type: JSType, vp: JSMutableHandleValue) -> JSBool; - -pub fn JS_InitClass(cx: *mut JSContext, obj: *mut JSObject, parent_proto: *mut JSObject, clasp: *mut JSClass, constructor: JSNative, nargs: c_uint, ps: *mut JSPropertySpec, fs: *mut JSFunctionSpec, static_ps: *mut JSPropertySpec, static_fs: *mut JSFunctionSpec) -> *mut JSObject; - -pub fn JS_LinkConstructorAndPrototype(cx: *mut JSContext, ctor: *mut JSObject, proto: *mut JSObject) -> JSBool; - -pub fn JS_GetClass(obj: JSRawObject) -> *mut JSClass; - -pub fn JS_InstanceOf(cx: *mut JSContext, obj: *mut JSObject, clasp: *mut JSClass, argv: *mut JSVal) -> JSBool; - -pub fn JS_HasInstance(cx: *mut JSContext, obj: *mut JSObject, v: JSVal, bp: *mut JSBool) -> JSBool; - -pub fn JS_GetPrivate(obj: JSRawObject) -> *mut c_void; - -pub fn JS_SetPrivate(obj: JSRawObject, data: *mut c_void); - -pub fn JS_GetInstancePrivate(cx: *mut JSContext, obj: *mut JSObject, clasp: *mut JSClass, argv: *mut JSVal) -> *mut c_void; - -pub fn JS_GetPrototype(obj: JSRawObject) -> *mut JSObject; - -pub fn JS_SetPrototype(cx: *mut JSContext, obj: *mut JSObject, proto: *mut JSObject) -> JSBool; - -pub fn JS_GetParent(obj: JSRawObject) -> *mut JSObject; - -pub fn JS_SetParent(cx: *mut JSContext, obj: *mut JSObject, parent: *mut JSObject) -> JSBool; - -pub fn JS_GetConstructor(cx: *mut JSContext, proto: *mut JSObject) -> *mut JSObject; - -pub fn JS_GetObjectId(cx: *mut JSContext, obj: JSRawObject, idp: *mut jsid) -> JSBool; - -pub fn JS_NewGlobalObject(cx: *mut JSContext, clasp: *const JSClass, principals: *mut JSPrincipals) -> *mut JSObject; - -pub fn JS_NewObject(cx: *mut JSContext, clasp: *const JSClass, proto: *const JSObject, parent: *const JSObject) -> *mut JSObject; - -pub fn JS_IsExtensible(obj: JSRawObject) -> JSBool; - -pub fn JS_IsNative(obj: JSRawObject) -> JSBool; - -pub fn JS_GetObjectRuntime(obj: JSRawObject) -> *mut JSRuntime; - -pub fn JS_NewObjectWithGivenProto(cx: *mut JSContext, clasp: *mut JSClass, proto: *mut JSObject, parent: *mut JSObject) -> *mut JSObject; - -pub fn JS_DeepFreezeObject(cx: *mut JSContext, obj: *mut JSObject) -> JSBool; - -pub fn JS_FreezeObject(cx: *mut JSContext, obj: *mut JSObject) -> JSBool; - -pub fn JS_New(cx: *mut JSContext, ctor: *mut JSObject, argc: c_uint, argv: *mut JSVal) -> *mut JSObject; - -pub fn JS_DefineObject(cx: *mut JSContext, obj: *mut JSObject, name: *const c_char, clasp: *mut JSClass, proto: *mut JSObject, attrs: c_uint) -> *mut JSObject; - -pub fn JS_DefineConstDoubles(cx: *mut JSContext, obj: *mut JSObject, cds: *mut JSConstDoubleSpec) -> JSBool; - -pub fn JS_DefineProperties(cx: *mut JSContext, obj: *mut JSObject, ps: *const JSPropertySpec) -> JSBool; - -pub fn JS_DefineProperty(cx: *mut JSContext, obj: *mut JSObject, name: *const c_char, value: JSVal, getter: JSPropertyOp, setter: JSStrictPropertyOp, attrs: c_uint) -> JSBool; - -pub fn JS_DefinePropertyById(cx: *mut JSContext, obj: *mut JSObject, id: jsid, value: JSVal, getter: JSPropertyOp, setter: JSStrictPropertyOp, attrs: c_uint) -> JSBool; - -pub fn JS_DefineOwnProperty(cx: *mut JSContext, obj: *mut JSObject, id: jsid, descriptor: JSVal, bp: *mut JSBool) -> JSBool; - -pub fn JS_GetPropertyAttributes(cx: *mut JSContext, obj: *mut JSObject, name: *const c_char, attrsp: *mut c_uint, foundp: *mut JSBool) -> JSBool; - -pub fn JS_GetPropertyAttrsGetterAndSetter(cx: *mut JSContext, obj: *mut JSObject, name: *const c_char, attrsp: *mut c_uint, foundp: *mut JSBool, getterp: *mut JSPropertyOp, setterp: *mut JSStrictPropertyOp) -> JSBool; - -pub fn JS_GetPropertyAttrsGetterAndSetterById(cx: *mut JSContext, obj: *mut JSObject, id: jsid, attrsp: *mut c_uint, foundp: *mut JSBool, getterp: *mut JSPropertyOp, setterp: *mut JSStrictPropertyOp) -> JSBool; - -pub fn JS_SetPropertyAttributes(cx: *mut JSContext, obj: *mut JSObject, name: *const c_char, attrs: c_uint, foundp: *mut JSBool) -> JSBool; - -pub fn JS_DefinePropertyWithTinyId(cx: *mut JSContext, obj: *mut JSObject, name: *const c_char, tinyid: int8_t, value: JSVal, getter: JSPropertyOp, setter: JSStrictPropertyOp, attrs: c_uint) -> JSBool; - -pub fn JS_AlreadyHasOwnProperty(cx: *mut JSContext, obj: *mut JSObject, name: *const c_char, foundp: *mut JSBool) -> JSBool; - -pub fn JS_AlreadyHasOwnPropertyById(cx: *mut JSContext, obj: *mut JSObject, id: jsid, foundp: *mut JSBool) -> JSBool; - -pub fn JS_HasProperty(cx: *mut JSContext, obj: *mut JSObject, name: *const c_char, foundp: *mut JSBool) -> JSBool; - -pub fn JS_HasPropertyById(cx: *mut JSContext, obj: *mut JSObject, id: jsid, foundp: *mut JSBool) -> JSBool; - -pub fn JS_LookupProperty(cx: *mut JSContext, obj: *mut JSObject, name: *const c_char, vp: *mut JSVal) -> JSBool; - -pub fn JS_LookupPropertyById(cx: *mut JSContext, obj: *mut JSObject, id: jsid, vp: *mut JSVal) -> JSBool; - -pub fn JS_LookupPropertyWithFlags(cx: *mut JSContext, obj: *mut JSObject, name: *const c_char, flags: c_uint, vp: *mut JSVal) -> JSBool; - -pub fn JS_LookupPropertyWithFlagsById(cx: *mut JSContext, obj: *mut JSObject, id: jsid, flags: c_uint, objp: *mut *mut JSObject, vp: *mut JSVal) -> JSBool; - -pub fn JS_GetPropertyDescriptorById(cx: *mut JSContext, obj: *mut JSObject, id: jsid, flags: c_uint, desc: *mut JSPropertyDescriptor) -> JSBool; - -pub fn JS_GetOwnPropertyDescriptor(cx: *mut JSContext, obj: *mut JSObject, id: jsid, vp: *mut JSVal) -> JSBool; - -pub fn JS_GetProperty(cx: *mut JSContext, obj: *mut JSObject, name: *const c_char, vp: *mut JSVal) -> JSBool; - -pub fn JS_GetPropertyDefault(cx: *mut JSContext, obj: *mut JSObject, name: *const c_char, def: JSVal, vp: *mut JSVal) -> JSBool; - -pub fn JS_GetPropertyById(cx: *mut JSContext, obj: *mut JSObject, id: jsid, vp: *mut JSVal) -> JSBool; - -pub fn JS_GetPropertyByIdDefault(cx: *mut JSContext, obj: *mut JSObject, id: jsid, def: JSVal, vp: *mut JSVal) -> JSBool; - -pub fn JS_ForwardGetPropertyTo(cx: *mut JSContext, obj: *mut JSObject, id: jsid, onBehalfOf: *mut JSObject, vp: *mut JSVal) -> JSBool; - -pub fn JS_GetMethodById(cx: *mut JSContext, obj: *mut JSObject, id: jsid, objp: *mut *mut JSObject, vp: *mut JSVal) -> JSBool; - -pub fn JS_GetMethod(cx: *mut JSContext, obj: *mut JSObject, name: *const c_char, objp: *mut *mut JSObject, vp: *mut JSVal) -> JSBool; - -pub fn JS_SetProperty(cx: *mut JSContext, obj: *mut JSObject, name: *const c_char, vp: *mut JSVal) -> JSBool; - -pub fn JS_SetPropertyById(cx: *mut JSContext, obj: *mut JSObject, id: jsid, vp: *mut JSVal) -> JSBool; - -pub fn JS_DeleteProperty(cx: *mut JSContext, obj: *mut JSObject, name: *const c_char) -> JSBool; - -pub fn JS_DeleteProperty2(cx: *mut JSContext, obj: *mut JSObject, name: *const c_char, rval: *mut JSVal) -> JSBool; - -pub fn JS_DeletePropertyById(cx: *mut JSContext, obj: *mut JSObject, id: jsid) -> JSBool; - -pub fn JS_DeletePropertyById2(cx: *mut JSContext, obj: *mut JSObject, id: jsid, rval: *mut JSVal) -> JSBool; - -pub fn JS_DefineUCProperty(cx: *mut JSContext, obj: *mut JSObject, name: *const jschar, namelen: size_t, value: JSVal, getter: JSPropertyOp, setter: JSStrictPropertyOp, attrs: c_uint) -> JSBool; - -pub fn JS_GetUCPropertyAttributes(cx: *mut JSContext, obj: *mut JSObject, name: *const jschar, namelen: size_t, attrsp: *mut c_uint, foundp: *mut JSBool) -> JSBool; - -pub fn JS_GetUCPropertyAttrsGetterAndSetter(cx: *mut JSContext, obj: *mut JSObject, name: *const jschar, namelen: size_t, attrsp: *mut c_uint, foundp: *mut JSBool, getterp: *mut JSPropertyOp, setterp: *mut JSStrictPropertyOp) -> JSBool; - -pub fn JS_SetUCPropertyAttributes(cx: *mut JSContext, obj: *mut JSObject, name: *const jschar, namelen: size_t, attrs: c_uint, foundp: *mut JSBool) -> JSBool; - -pub fn JS_DefineUCPropertyWithTinyId(cx: *mut JSContext, obj: *mut JSObject, name: *const jschar, namelen: size_t, tinyid: int8_t, value: JSVal, getter: JSPropertyOp, setter: JSStrictPropertyOp, attrs: c_uint) -> JSBool; - -pub fn JS_AlreadyHasOwnUCProperty(cx: *mut JSContext, obj: *mut JSObject, name: *const jschar, namelen: size_t, foundp: *mut JSBool) -> JSBool; - -pub fn JS_HasUCProperty(cx: *mut JSContext, obj: *mut JSObject, name: *const jschar, namelen: size_t, vp: *mut JSBool) -> JSBool; - -pub fn JS_LookupUCProperty(cx: *mut JSContext, obj: *mut JSObject, name: *const jschar, namelen: size_t, vp: *mut JSVal) -> JSBool; - -pub fn JS_GetUCProperty(cx: *mut JSContext, obj: *mut JSObject, name: *const jschar, namelen: size_t, vp: *mut JSVal) -> JSBool; - -pub fn JS_SetUCProperty(cx: *mut JSContext, obj: *mut JSObject, name: *const jschar, namelen: size_t, vp: *mut JSVal) -> JSBool; - -pub fn JS_DeleteUCProperty2(cx: *mut JSContext, obj: *mut JSObject, name: *const jschar, namelen: size_t, rval: *mut JSVal) -> JSBool; - -pub fn JS_NewArrayObject(cx: *mut JSContext, length: c_int, vector: *mut JSVal) -> *mut JSObject; - -pub fn JS_IsArrayObject(cx: *mut JSContext, obj: *mut JSObject) -> JSBool; - -pub fn JS_GetArrayLength(cx: *mut JSContext, obj: *mut JSObject, lengthp: *mut uint32_t) -> JSBool; - -pub fn JS_SetArrayLength(cx: *mut JSContext, obj: *mut JSObject, length: uint32_t) -> JSBool; - -pub fn JS_DefineElement(cx: *mut JSContext, obj: *mut JSObject, index: uint32_t, value: JSVal, getter: JSPropertyOp, setter: JSStrictPropertyOp, attrs: c_uint) -> JSBool; - -pub fn JS_AlreadyHasOwnElement(cx: *mut JSContext, obj: *mut JSObject, index: uint32_t, foundp: *mut JSBool) -> JSBool; - -pub fn JS_HasElement(cx: *mut JSContext, obj: *mut JSObject, index: uint32_t, foundp: *mut JSBool) -> JSBool; - -pub fn JS_LookupElement(cx: *mut JSContext, obj: *mut JSObject, index: uint32_t, vp: *mut JSVal) -> JSBool; - -pub fn JS_GetElement(cx: *mut JSContext, obj: *mut JSObject, index: uint32_t, vp: *mut JSVal) -> JSBool; - -pub fn JS_ForwardGetElementTo(cx: *mut JSContext, obj: *mut JSObject, index: uint32_t, onBehalfOf: *mut JSObject, vp: *mut JSVal) -> JSBool; - -pub fn JS_GetElementIfPresent(cx: *mut JSContext, obj: *mut JSObject, index: uint32_t, onBehalfOf: *mut JSObject, vp: *mut JSVal, present: *mut JSBool) -> JSBool; - -pub fn JS_SetElement(cx: *mut JSContext, obj: *mut JSObject, index: uint32_t, vp: *mut JSVal) -> JSBool; - -pub fn JS_DeleteElement(cx: *mut JSContext, obj: *mut JSObject, index: uint32_t) -> JSBool; - -pub fn JS_DeleteElement2(cx: *mut JSContext, obj: *mut JSObject, index: uint32_t, rval: *mut JSVal) -> JSBool; - -pub fn JS_ClearScope(cx: *mut JSContext, obj: *mut JSObject); - -pub fn JS_Enumerate(cx: *mut JSContext, obj: *mut JSObject) -> *mut JSIdArray; - -pub fn JS_NewPropertyIterator(cx: *mut JSContext, obj: *mut JSObject) -> *mut JSObject; - -pub fn JS_NextProperty(cx: *mut JSContext, iterobj: *mut JSObject, idp: *mut jsid) -> JSBool; - -pub fn JS_ArrayIterator(cx: *mut JSContext, argc: c_uint, vp: *mut JSVal) -> JSBool; - -pub fn JS_CheckAccess(cx: *mut JSContext, obj: *mut JSObject, id: jsid, mode: JSAccessMode, vp: *mut JSVal, attrsp: *mut c_uint) -> JSBool; - -pub fn JS_GetReservedSlot(obj: JSRawObject, index: uint32_t) -> JSVal; - -pub fn JS_SetReservedSlot(obj: JSRawObject, index: uint32_t, v: JSVal); - -pub fn JS_HoldPrincipals(principals: *mut JSPrincipals); - -pub fn JS_DropPrincipals(rt: *mut JSRuntime, principals: *mut JSPrincipals); - -pub fn JS_SetSecurityCallbacks(rt: *mut JSRuntime, callbacks: *const JSSecurityCallbacks); - -pub fn JS_GetSecurityCallbacks(rt: *mut JSRuntime) -> *const JSSecurityCallbacks; - -pub fn JS_SetTrustedPrincipals(rt: *mut JSRuntime, prin: *mut JSPrincipals); - -pub fn JS_InitDestroyPrincipalsCallback(rt: *mut JSRuntime, destroyPrincipals: JSDestroyPrincipalsOp); - -pub fn JS_NewFunction(cx: *mut JSContext, call: JSNative, nargs: c_uint, flags: c_uint, parent: *mut JSObject, name: *const c_char) -> *mut JSFunction; - -pub fn JS_NewFunctionById(cx: *mut JSContext, call: JSNative, nargs: c_uint, flags: c_uint, parent: *mut JSObject, id: jsid) -> *mut JSFunction; - -pub fn JS_GetFunctionObject(fun: *mut JSFunction) -> *mut JSObject; - -pub fn JS_GetFunctionId(fun: *mut JSFunction) -> *mut JSString; - -pub fn JS_GetFunctionDisplayId(fun: *mut JSFunction) -> *mut JSString; - -pub fn JS_GetFunctionFlags(fun: *mut JSFunction) -> c_uint; - -pub fn JS_GetFunctionArity(fun: *mut JSFunction) -> uint16_t; - -pub fn JS_ObjectIsFunction(cx: *mut JSContext, obj: JSRawObject) -> JSBool; - -pub fn JS_ObjectIsCallable(cx: *mut JSContext, obj: JSRawObject) -> JSBool; - -pub fn JS_IsNativeFunction(funobj: JSRawObject, call: JSNative) -> JSBool; - -pub fn JS_BindCallable(cx: *mut JSContext, callable: *mut JSObject, newThis: JSRawObject) -> *mut JSObject; - -pub fn JS_DefineFunctions(cx: *mut JSContext, obj: *mut JSObject, fs: *const JSFunctionSpec) -> JSBool; - -pub fn JS_DefineFunction(cx: *mut JSContext, obj: *mut JSObject, name: *const c_char, call: JSNative, nargs: c_uint, attrs: c_uint) -> *mut JSFunction; - -pub fn JS_DefineUCFunction(cx: *mut JSContext, obj: *mut JSObject, name: *const jschar, namelen: size_t, call: JSNative, nargs: c_uint, attrs: c_uint) -> *mut JSFunction; - -pub fn JS_DefineFunctionById(cx: *mut JSContext, obj: *mut JSObject, id: jsid, call: JSNative, nargs: c_uint, attrs: c_uint) -> *mut JSFunction; - -pub fn JS_CloneFunctionObject(cx: *mut JSContext, funobj: *mut JSObject, parent: JSRawObject) -> *mut JSObject; - -pub fn JS_BufferIsCompilableUnit(cx: *mut JSContext, bytes_are_utf8: JSBool, obj: *mut JSObject, bytes: *const c_char, length: size_t) -> JSBool; - -pub fn JS_CompileScript(cx: *mut JSContext, obj: *mut JSObject, bytes: *const c_char, length: size_t, filename: *const c_char, lineno: c_uint) -> *mut JSScript; - -pub fn JS_CompileScriptForPrincipals(cx: *mut JSContext, obj: *mut JSObject, principals: *mut JSPrincipals, bytes: *const c_char, length: size_t, filename: *const c_char, lineno: c_uint) -> *mut JSScript; - -pub fn JS_CompileScriptForPrincipalsVersion(cx: *mut JSContext, obj: *mut JSObject, principals: *mut JSPrincipals, bytes: *const c_char, length: size_t, filename: *const c_char, lineno: c_uint, version: JSVersion) -> *mut JSScript; - -pub fn JS_CompileUCScript(cx: *mut JSContext, obj: *mut JSObject, chars: *const jschar, length: size_t, filename: *const c_char, lineno: c_uint) -> *mut JSScript; - -pub fn JS_CompileUCScriptForPrincipals(cx: *mut JSContext, obj: *mut JSObject, principals: *mut JSPrincipals, chars: *const jschar, length: size_t, filename: *const c_char, lineno: c_uint) -> *mut JSScript; - -pub fn JS_CompileUCScriptForPrincipalsVersion(cx: *mut JSContext, obj: *mut JSObject, principals: *mut JSPrincipals, chars: *const jschar, length: size_t, filename: *const c_char, lineno: c_uint, version: JSVersion) -> *mut JSScript; - -pub fn JS_CompileUCScriptForPrincipalsVersionOrigin(cx: *mut JSContext, obj: *mut JSObject, principals: *mut JSPrincipals, originPrincipals: *mut JSPrincipals, chars: *const jschar, length: size_t, filename: *const c_char, lineno: c_uint, version: JSVersion) -> *mut JSScript; - -pub fn JS_CompileUTF8File(cx: *mut JSContext, obj: *mut JSObject, filename: *const c_char) -> *mut JSScript; - -pub fn JS_CompileUTF8FileHandle(cx: *mut JSContext, obj: *mut JSObject, filename: *const c_char, fh: *mut FILE) -> *mut JSScript; - -pub fn JS_CompileUTF8FileHandleForPrincipals(cx: *mut JSContext, obj: *mut JSObject, filename: *const c_char, fh: *mut FILE, principals: *mut JSPrincipals) -> *mut JSScript; - -pub fn JS_CompileUTF8FileHandleForPrincipalsVersion(cx: *mut JSContext, obj: *mut JSObject, filename: *const c_char, fh: *mut FILE, principals: *mut JSPrincipals, version: JSVersion) -> *mut JSScript; - -pub fn JS_GetGlobalFromScript(script: *mut JSScript) -> *mut JSObject; - -pub fn JS_CompileFunction(cx: *mut JSContext, obj: *mut JSObject, name: *const c_char, nargs: c_uint, argnames: *mut *const c_char, bytes: *const c_char, length: size_t, filename: *const c_char, lineno: c_uint) -> *mut JSFunction; - -pub fn JS_CompileFunctionForPrincipals(cx: *mut JSContext, obj: *mut JSObject, principals: *mut JSPrincipals, name: *const c_char, nargs: c_uint, argnames: *mut *const c_char, bytes: *const c_char, length: size_t, filename: *const c_char, lineno: c_uint) -> *mut JSFunction; - -pub fn JS_CompileUCFunction(cx: *mut JSContext, obj: *mut JSObject, name: *const c_char, nargs: c_uint, argnames: *mut *const c_char, chars: *const jschar, length: size_t, filename: *const c_char, lineno: c_uint) -> *mut JSFunction; - -pub fn JS_CompileUCFunctionForPrincipals(cx: *mut JSContext, obj: *mut JSObject, principals: *mut JSPrincipals, name: *const c_char, nargs: c_uint, argnames: *mut *const c_char, chars: *const jschar, length: size_t, filename: *const c_char, lineno: c_uint) -> *mut JSFunction; - -pub fn JS_CompileUCFunctionForPrincipalsVersion(cx: *mut JSContext, obj: *mut JSObject, principals: *mut JSPrincipals, name: *const c_char, nargs: c_uint, argnames: *mut *const c_char, chars: *const jschar, length: size_t, filename: *const c_char, lineno: c_uint, version: JSVersion) -> *mut JSFunction; - -pub fn JS_DecompileScript(cx: *mut JSContext, script: *mut JSScript, name: *const c_char, indent: c_uint) -> *mut JSString; - -pub fn JS_DecompileFunction(cx: *mut JSContext, fun: *mut JSFunction, indent: c_uint) -> *mut JSString; - -pub fn JS_DecompileFunctionBody(cx: *mut JSContext, fun: *mut JSFunction, indent: c_uint) -> *mut JSString; - -pub fn JS_ExecuteScript(cx: *mut JSContext, obj: *mut JSObject, script: *mut JSScript, rval: *mut JSVal) -> JSBool; - -pub fn JS_ExecuteScriptVersion(cx: *mut JSContext, obj: *mut JSObject, script: *mut JSScript, rval: *mut JSVal, version: JSVersion) -> JSBool; - -pub fn JS_EvaluateScript(cx: *mut JSContext, obj: *mut JSObject, bytes: *const c_char, length: c_uint, filename: *const c_char, lineno: c_uint, rval: *mut JSVal) -> JSBool; - -pub fn JS_EvaluateScriptForPrincipals(cx: *mut JSContext, obj: *mut JSObject, principals: *mut JSPrincipals, bytes: *const c_char, length: c_uint, filename: *const c_char, lineno: c_uint, rval: *mut JSVal) -> JSBool; - -pub fn JS_EvaluateScriptForPrincipalsVersion(cx: *mut JSContext, obj: *mut JSObject, principals: *mut JSPrincipals, bytes: *const c_char, length: c_uint, filename: *const c_char, lineno: c_uint, rval: *mut JSVal, version: JSVersion) -> JSBool; - -pub fn JS_EvaluateUCScript(cx: *mut JSContext, obj: *mut JSObject, chars: *const jschar, length: c_uint, filename: *const c_char, lineno: c_uint, rval: *mut JSVal) -> JSBool; - -pub fn JS_EvaluateUCScriptForPrincipals(cx: *mut JSContext, obj: *mut JSObject, principals: *mut JSPrincipals, chars: *const jschar, length: c_uint, filename: *const c_char, lineno: c_uint, rval: *mut JSVal) -> JSBool; - -pub fn JS_EvaluateUCScriptForPrincipalsVersion(cx: *mut JSContext, obj: *mut JSObject, principals: *mut JSPrincipals, chars: *const jschar, length: c_uint, filename: *const c_char, lineno: c_uint, rval: *mut JSVal, version: JSVersion) -> JSBool; - -pub fn JS_EvaluateUCScriptForPrincipalsVersionOrigin(cx: *mut JSContext, obj: *mut JSObject, principals: *mut JSPrincipals, originPrincipals: *mut JSPrincipals, chars: *const jschar, length: c_uint, filename: *const c_char, lineno: c_uint, rval: *mut JSVal, version: JSVersion) -> JSBool; - -pub fn JS_CallFunction(cx: *mut JSContext, obj: *mut JSObject, fun: *mut JSFunction, argc: c_uint, argv: *mut JSVal, rval: *mut JSVal) -> JSBool; - -pub fn JS_CallFunctionName(cx: *mut JSContext, obj: *mut JSObject, name: *const c_char, argc: c_uint, argv: *mut JSVal, rval: *mut JSVal) -> JSBool; - -pub fn JS_CallFunctionValue(cx: *mut JSContext, obj: *mut JSObject, fval: JSVal, argc: c_uint, argv: *mut JSVal, rval: *mut JSVal) -> JSBool; - -pub fn JS_SetOperationCallback(cx: *mut JSContext, callback: JSOperationCallback) -> JSOperationCallback; - -pub fn JS_GetOperationCallback(cx: *mut JSContext) -> JSOperationCallback; - -pub fn JS_TriggerOperationCallback(rt: *mut JSRuntime); - -pub fn JS_IsRunning(cx: *mut JSContext) -> JSBool; - -pub fn JS_SaveFrameChain(cx: *mut JSContext) -> JSBool; - -pub fn JS_RestoreFrameChain(cx: *mut JSContext); - -pub fn JS_NewStringCopyN(cx: *mut JSContext, s: *const c_char, n: size_t) -> *mut JSString; - -pub fn JS_NewStringCopyZ(cx: *mut JSContext, s: *const c_char) -> *mut JSString; - -pub fn JS_InternJSString(cx: *mut JSContext, str: *mut JSString) -> *mut JSString; - -pub fn JS_InternStringN(cx: *mut JSContext, s: *const c_char, length: size_t) -> *mut JSString; - -pub fn JS_InternString(cx: *mut JSContext, s: *const c_char) -> *mut JSString; - -pub fn JS_NewUCString(cx: *mut JSContext, chars: *mut jschar, length: size_t) -> *mut JSString; - -pub fn JS_NewUCStringCopyN(cx: *mut JSContext, s: *const jschar, n: size_t) -> *mut JSString; - -pub fn JS_NewUCStringCopyZ(cx: *mut JSContext, s: *const jschar) -> *mut JSString; - -pub fn JS_InternUCStringN(cx: *mut JSContext, s: *const jschar, length: size_t) -> *mut JSString; - -pub fn JS_InternUCString(cx: *mut JSContext, s: *const jschar) -> *mut JSString; - -pub fn JS_CompareStrings(cx: *mut JSContext, str1: *mut JSString, str2: *mut JSString, result: *mut int32_t) -> JSBool; - -pub fn JS_StringEqualsAscii(cx: *mut JSContext, str: *mut JSString, asciiBytes: *const c_char, _match: *mut JSBool) -> JSBool; - -pub fn JS_PutEscapedString(cx: *mut JSContext, buffer: *mut c_char, size: size_t, str: *mut JSString, quote: c_char) -> size_t; - -pub fn JS_FileEscapedString(fp: *mut FILE, str: *mut JSString, quote: c_char) -> JSBool; - -pub fn JS_GetStringLength(str: *mut JSString) -> size_t; - -pub fn JS_GetStringCharsAndLength(cx: *mut JSContext, str: *mut JSString, length: *mut size_t) -> *const jschar; - -pub fn JS_GetInternedStringChars(str: *mut JSString) -> *const jschar; - -pub fn JS_GetInternedStringCharsAndLength(str: *mut JSString, length: *mut size_t) -> *const jschar; - -pub fn JS_GetStringCharsZ(cx: *mut JSContext, str: *mut JSString) -> *const jschar; - -pub fn JS_GetStringCharsZAndLength(cx: *mut JSContext, str: *mut JSString, length: *mut size_t) -> *const jschar; - -pub fn JS_FlattenString(cx: *mut JSContext, str: *mut JSString) -> *mut JSFlatString; - -pub fn JS_GetFlatStringChars(str: *mut JSFlatString) -> *const jschar; - -pub fn JS_FlatStringEqualsAscii(str: *mut JSFlatString, asciiBytes: *const c_char) -> JSBool; - -pub fn JS_PutEscapedFlatString(buffer: *mut c_char, size: size_t, str: *mut JSFlatString, quote: c_char) -> size_t; - -pub fn JS_NewGrowableString(cx: *mut JSContext, chars: *mut jschar, length: size_t) -> *mut JSString; - -pub fn JS_NewDependentString(cx: *mut JSContext, str: *mut JSString, start: size_t, length: size_t) -> *mut JSString; - -pub fn JS_ConcatStrings(cx: *mut JSContext, left: *mut JSString, right: *mut JSString) -> *mut JSString; - -pub fn JS_UndependString(cx: *mut JSContext, str: *mut JSString) -> *const jschar; - -pub fn JS_MakeStringImmutable(cx: *mut JSContext, str: *mut JSString) -> JSBool; - -pub fn JS_CStringsAreUTF8() -> JSBool; - -pub fn JS_SetCStringsAreUTF8(); - -pub fn JS_EncodeCharacters(cx: *mut JSContext, src: *const jschar, srclen: size_t, dst: *mut c_char, dstlenp: *mut size_t) -> JSBool; - -pub fn JS_DecodeBytes(cx: *mut JSContext, src: *const c_char, srclen: size_t, dst: *mut jschar, dstlenp: *mut size_t) -> JSBool; - -pub fn JS_DecodeUTF8(cx: *mut JSContext, src: *const c_char, srclen: size_t, dst: *mut jschar, dstlenp: *mut size_t) -> JSBool; - -pub fn JS_EncodeString(cx: *mut JSContext, str: *mut JSString) -> *mut c_char; - -pub fn JS_GetStringEncodingLength(cx: *mut JSContext, str: *mut JSString) -> size_t; - -pub fn JS_EncodeStringToBuffer(str: *mut JSString, buffer: *mut c_char, length: size_t) -> size_t; - -pub fn JS_Stringify(cx: *mut JSContext, vp: *mut JSVal, replacer: *mut JSObject, space: JSVal, callback: JSONWriteCallback, data: *mut c_void) -> JSBool; - -pub fn JS_ParseJSON(cx: *mut JSContext, chars: *const jschar, len: uint32_t, vp: *mut JSVal) -> JSBool; - -pub fn JS_ParseJSONWithReviver(cx: *mut JSContext, chars: *const jschar, len: uint32_t, reviver: JSVal, vp: *mut JSVal) -> JSBool; - -pub fn JS_ReadStructuredClone(cx: *mut JSContext, data: *const uint64_t, nbytes: size_t, version: uint32_t, vp: *mut JSVal, optionalCallbacks: *const JSStructuredCloneCallbacks, closure: *mut c_void) -> JSBool; - -pub fn JS_WriteStructuredClone(cx: *mut JSContext, v: JSVal, datap: *mut *mut uint64_t, nbytesp: *mut size_t, optionalCallbacks: *const JSStructuredCloneCallbacks, closure: *mut c_void) -> JSBool; - -pub fn JS_StructuredClone(cx: *mut JSContext, v: JSVal, vp: *mut JSVal, optionalCallbacks: *const JSStructuredCloneCallbacks, closure: *mut c_void) -> JSBool; - -pub fn JS_SetStructuredCloneCallbacks(rt: *mut JSRuntime, callbacks: *const JSStructuredCloneCallbacks); - -pub fn JS_ReadUint32Pair(r: *mut JSStructuredCloneReader, p1: *mut uint32_t, p2: *mut uint32_t) -> JSBool; - -pub fn JS_ReadBytes(r: *mut JSStructuredCloneReader, p: *mut c_void, len: size_t) -> JSBool; - -pub fn JS_ReadTypedArray(r: *mut JSStructuredCloneReader, vp: *mut JSVal) -> JSBool; - -pub fn JS_WriteUint32Pair(w: *mut JSStructuredCloneWriter, tag: uint32_t, data: uint32_t) -> JSBool; - -pub fn JS_WriteBytes(w: *mut JSStructuredCloneWriter, p: *const c_void, len: size_t) -> JSBool; - -pub fn JS_WriteTypedArray(w: *mut JSStructuredCloneWriter, v: JSVal) -> JSBool; - -pub fn JS_SetLocaleCallbacks(cx: *mut JSContext, callbacks: *mut JSLocaleCallbacks); - -pub fn JS_GetLocaleCallbacks(cx: *mut JSContext) -> *mut JSLocaleCallbacks; - -pub fn JS_ReportError(cx: *mut JSContext, format: *const c_char, ...); - -pub fn JS_ReportErrorNumber(cx: *mut JSContext, errorCallback: JSErrorCallback, userRef: *mut c_void, errorNumber: c_uint, ...); - -pub fn JS_ReportErrorNumberUC(cx: *mut JSContext, errorCallback: JSErrorCallback, userRef: *mut c_void, errorNumber: c_uint, ...); - -pub fn JS_ReportWarning(cx: *mut JSContext, format: *const c_char, ...) -> JSBool; - -pub fn JS_ReportErrorFlagsAndNumber(cx: *mut JSContext, flags: c_uint, errorCallback: JSErrorCallback, userRef: *mut c_void, errorNumber: c_uint, ...) -> JSBool; - -pub fn JS_ReportErrorFlagsAndNumberUC(cx: *mut JSContext, flags: c_uint, errorCallback: JSErrorCallback, userRef: *mut c_void, errorNumber: c_uint, ...) -> JSBool; - -pub fn JS_ReportOutOfMemory(cx: *mut JSContext); - -pub fn JS_ReportAllocationOverflow(cx: *mut JSContext); - -pub fn JS_GetErrorReporter(cx: *mut JSContext) -> JSErrorReporter; - -pub fn JS_SetErrorReporter(cx: *mut JSContext, er: JSErrorReporter) -> JSErrorReporter; - -pub fn JS_NewDateObject(cx: *mut JSContext, year: c_int, mon: c_int, mday: c_int, hour: c_int, min: c_int, sec: c_int) -> *mut JSObject; - -pub fn JS_NewDateObjectMsec(cx: *mut JSContext, msec: c_double) -> *mut JSObject; - -pub fn JS_ObjectIsDate(cx: *mut JSContext, obj: JSRawObject) -> JSBool; - -pub fn JS_ClearDateCaches(cx: *mut JSContext); - -pub fn JS_NewRegExpObject(cx: *mut JSContext, obj: *mut JSObject, bytes: *mut c_char, length: size_t, flags: c_uint) -> *mut JSObject; - -pub fn JS_NewUCRegExpObject(cx: *mut JSContext, obj: *mut JSObject, chars: *mut jschar, length: size_t, flags: c_uint) -> *mut JSObject; - -pub fn JS_SetRegExpInput(cx: *mut JSContext, obj: *mut JSObject, input: *mut JSString, multiline: JSBool); - -pub fn JS_ClearRegExpStatics(cx: *mut JSContext, obj: *mut JSObject); - -pub fn JS_ExecuteRegExp(cx: *mut JSContext, obj: *mut JSObject, reobj: *mut JSObject, chars: *mut jschar, length: size_t, indexp: *mut size_t, test: JSBool, rval: *mut JSVal) -> JSBool; - -pub fn JS_NewRegExpObjectNoStatics(cx: *mut JSContext, bytes: *mut c_char, length: size_t, flags: c_uint) -> *mut JSObject; - -pub fn JS_NewUCRegExpObjectNoStatics(cx: *mut JSContext, chars: *mut jschar, length: size_t, flags: c_uint) -> *mut JSObject; - -pub fn JS_ExecuteRegExpNoStatics(cx: *mut JSContext, reobj: *mut JSObject, chars: *mut jschar, length: size_t, indexp: *mut size_t, test: JSBool, rval: *mut JSVal) -> JSBool; - -pub fn JS_ObjectIsRegExp(cx: *mut JSContext, obj: *mut JSObject) -> JSBool; - -pub fn JS_GetRegExpFlags(cx: *mut JSContext, obj: *mut JSObject) -> c_uint; - -pub fn JS_GetRegExpSource(cx: *mut JSContext, obj: *mut JSObject) -> *mut JSString; - -pub fn JS_IsExceptionPending(cx: *mut JSContext) -> JSBool; - -pub fn JS_GetPendingException(cx: *mut JSContext, vp: *mut JSVal) -> JSBool; - -pub fn JS_SetPendingException(cx: *mut JSContext, v: JSVal); - -pub fn JS_ClearPendingException(cx: *mut JSContext); - -pub fn JS_ReportPendingException(cx: *mut JSContext) -> JSBool; - -pub fn JS_SaveExceptionState(cx: *mut JSContext) -> *mut JSExceptionState; - -pub fn JS_RestoreExceptionState(cx: *mut JSContext, state: *mut JSExceptionState); - -pub fn JS_DropExceptionState(cx: *mut JSContext, state: *mut JSExceptionState); - -pub fn JS_ErrorFromException(cx: *mut JSContext, v: JSVal) -> *mut JSErrorReport; - -pub fn JS_ThrowReportedError(cx: *mut JSContext, message: *const c_char, reportp: *mut JSErrorReport) -> JSBool; - -pub fn JS_ThrowStopIteration(cx: *mut JSContext) -> JSBool; - -pub fn JS_GetCurrentThread() -> intptr_t; - -pub fn JS_AbortIfWrongThread(rt: *mut JSRuntime); - -pub fn JS_ClearRuntimeThread(rt: *mut JSRuntime); - -pub fn JS_SetRuntimeThread(rt: *mut JSRuntime); - -pub fn JS_SetNativeStackBounds(rt: *mut JSRuntime, minValue: uintptr_t, maxValue: uintptr_t); - -pub fn JS_NewObjectForConstructor(cx: *mut JSContext, clasp: *mut JSClass, vp: *const JSVal) -> *mut JSObject; - -pub fn JS_IndexToId(cx: *mut JSContext, index: uint32_t, id: *mut jsid) -> JSBool; - -pub fn JS_IsIdentifier(cx: *mut JSContext, str: *mut JSString, isIdentifier: *mut JSBool) -> JSBool; - -pub fn JS_DescribeScriptedCaller(cx: *mut JSContext, script: *mut *mut JSScript, lineno: *mut c_uint) -> JSBool; - -pub fn JS_EncodeScript(cx: *mut JSContext, script: *mut JSScript, lengthp: *mut uint32_t) -> *mut c_void; - -pub fn JS_EncodeInterpretedFunction(cx: *mut JSContext, funobj: JSRawObject, lengthp: *mut uint32_t) -> *mut c_void; +extern "C" { + fn _Z9JS_AssertPKcS0_i(s: *const i8, file: *const i8, ln: i32); + fn _ZN2js6detail16ScrambleHashCodeEj(h: u32) -> u32; + fn _ZN2js8FinishGCEP9JSRuntime(rt: *mut JSRuntime); + fn _ZN2js2gc26MarkPersistentRootedChainsEP8JSTracer(arg1: *mut JSTracer); + fn _ZN2js2gc28FinishPersistentRootedChainsEP9JSRuntime(arg1: + *mut JSRuntime); + fn _ZN2js10GetRuntimeEPK9JSContext(cx: *const JSContext) + -> *mut JSRuntime; + fn _Z13JS_GetRuntimeP9JSContext(cx: *mut JSContext) + -> *mut JSRuntime; + fn _ZN2js21GetContextCompartmentEPK9JSContext(cx: *const JSContext) + -> *mut JSCompartment; + fn _ZN2js14GetContextZoneEPK9JSContext(cx: *const JSContext) -> *mut Zone; + fn _ZN2JS18GCTraceKindToAsciiE13JSGCTraceKind(kind: JSGCTraceKind) + -> *const i8; + fn _Z18JS_CallValueTracerP8JSTracerPN2JS4HeapINS1_5ValueEEEPKc(trc: + *mut JSTracer, + valuep: + *mut Heap, + name: + *const i8); + fn _Z15JS_CallIdTracerP8JSTracerPN2JS4HeapI4jsidEEPKc(trc: *mut JSTracer, + idp: + *mut Heap, + name: *const i8); + fn _Z19JS_CallObjectTracerP8JSTracerPN2JS4HeapIP8JSObjectEEPKc(trc: + *mut JSTracer, + objp: + *mut Heap<*mut JSObject>, + name: + *const i8); + fn _Z19JS_CallStringTracerP8JSTracerPN2JS4HeapIP8JSStringEEPKc(trc: + *mut JSTracer, + strp: + *mut Heap<*mut JSString>, + name: + *const i8); + fn _Z19JS_CallScriptTracerP8JSTracerPN2JS4HeapIP8JSScriptEEPKc(trc: + *mut JSTracer, + scriptp: + *mut Heap<*mut JSScript>, + name: + *const i8); + fn _Z21JS_CallFunctionTracerP8JSTracerPN2JS4HeapIP10JSFunctionEEPKc(trc: + *mut JSTracer, + funp: + *mut Heap<*mut JSFunction>, + name: + *const i8); + fn _Z29JS_CallUnbarrieredValueTracerP8JSTracerPN2JS5ValueEPKc(trc: + *mut JSTracer, + valuep: + *mut Value, + name: + *const i8); + fn _Z26JS_CallUnbarrieredIdTracerP8JSTracerP4jsidPKc(trc: *mut JSTracer, + idp: *mut jsid, + name: *const i8); + fn _Z30JS_CallUnbarrieredObjectTracerP8JSTracerPP8JSObjectPKc(trc: + *mut JSTracer, + objp: + *mut *mut JSObject, + name: + *const i8); + fn _Z30JS_CallUnbarrieredStringTracerP8JSTracerPP8JSStringPKc(trc: + *mut JSTracer, + strp: + *mut *mut JSString, + name: + *const i8); + fn _Z30JS_CallUnbarrieredScriptTracerP8JSTracerPP8JSScriptPKc(trc: + *mut JSTracer, + scriptp: + *mut *mut JSScript, + name: + *const i8); + fn _Z26JS_CallTenuredObjectTracerP8JSTracerPN2JS11TenuredHeapIP8JSObjectEEPKc(trc: + *mut JSTracer, + objp: + *mut TenuredHeap<*mut JSObject>, + name: + *const i8); + fn _Z16JS_TraceChildrenP8JSTracerPv13JSGCTraceKind(trc: *mut JSTracer, + thing: + *mut ::libc::c_void, + kind: JSGCTraceKind); + fn _Z15JS_TraceRuntimeP8JSTracer(trc: *mut JSTracer); + fn _Z20JS_TraceIncomingCCWsP8JSTracerRKN2js7HashSetIPN2JS4ZoneENS1_13DefaultHasherIS5_EENS1_17SystemAllocPolicyEEE(trc: + *mut JSTracer, + zones: + *const ZoneSet); + fn _Z20JS_GetTraceThingInfoPcjP8JSTracerPv13JSGCTraceKindb(buf: *mut i8, + bufsize: u32, + trc: + *mut JSTracer, + thing: + *mut ::libc::c_void, + kind: + JSGCTraceKind, + includeDetails: + u8); + fn _ZN2js29CurrentThreadCanAccessRuntimeEP9JSRuntime(rt: *mut JSRuntime) + -> u8; + fn _ZN2js26CurrentThreadCanAccessZoneEPN2JS4ZoneE(zone: *mut Zone) -> u8; + fn _ZN2js2gc20AssertGCThingHasTypeEPNS0_4CellE13JSGCTraceKind(cell: + *mut Cell, + kind: + JSGCTraceKind); + fn _ZN2JS13GetObjectZoneEP8JSObject(obj: *mut JSObject) -> *mut Zone; + fn _ZN2JS16PrepareZoneForGCEPNS_4ZoneE(zone: *mut Zone); + fn _ZN2JS16PrepareForFullGCEP9JSRuntime(rt: *mut JSRuntime); + fn _ZN2JS23PrepareForIncrementalGCEP9JSRuntime(rt: *mut JSRuntime); + fn _ZN2JS13IsGCScheduledEP9JSRuntime(rt: *mut JSRuntime) -> u8; + fn _ZN2JS13SkipZoneForGCEPNS_4ZoneE(zone: *mut Zone); + fn _ZN2JS11GCForReasonEP9JSRuntime18JSGCInvocationKindNS_8gcreason6ReasonE(rt: + *mut JSRuntime, + gckind: + JSGCInvocationKind, + reason: + Reason); + fn _ZN2JS18StartIncrementalGCEP9JSRuntime18JSGCInvocationKindNS_8gcreason6ReasonEx(rt: + *mut JSRuntime, + gckind: + JSGCInvocationKind, + reason: + Reason, + millis: + i64); + fn _ZN2JS18IncrementalGCSliceEP9JSRuntimeNS_8gcreason6ReasonEx(rt: + *mut JSRuntime, + reason: + Reason, + millis: + i64); + fn _ZN2JS19FinishIncrementalGCEP9JSRuntimeNS_8gcreason6ReasonE(rt: + *mut JSRuntime, + reason: + Reason); + fn _ZN2JS18SetGCSliceCallbackEP9JSRuntimePFvS1_NS_10GCProgressERKNS_13GCDescriptionEE(rt: + *mut JSRuntime, + callback: + GCSliceCallback) + -> GCSliceCallback; + fn _ZN2JS20DisableIncrementalGCEP9JSRuntime(rt: *mut JSRuntime); + fn _ZN2JS22IsIncrementalGCEnabledEP9JSRuntime(rt: *mut JSRuntime) -> u8; + fn _ZN2JS25IsIncrementalGCInProgressEP9JSRuntime(rt: *mut JSRuntime) + -> u8; + fn _ZN2JS26IsIncrementalBarrierNeededEP9JSRuntime(rt: *mut JSRuntime) + -> u8; + fn _ZN2JS26IsIncrementalBarrierNeededEP9JSContext(cx: *mut JSContext) + -> u8; + fn _ZN2JS27IncrementalReferenceBarrierENS_9GCCellPtrE(thing: GCCellPtr); + fn _ZN2JS23IncrementalValueBarrierERKNS_5ValueE(v: *const Value); + fn _ZN2JS24IncrementalObjectBarrierEP8JSObject(obj: *mut JSObject); + fn _ZN2JS16WasIncrementalGCEP9JSRuntime(rt: *mut JSRuntime) -> u8; + fn _ZN2JS23IsGenerationalGCEnabledEP9JSRuntime(rt: *mut JSRuntime) -> u8; + fn _ZN2JS11GetGCNumberEv() -> u32; + fn _ZN2JS15ShrinkGCBuffersEP9JSRuntime(rt: *mut JSRuntime); + fn _ZN2JS28UnmarkGrayGCThingRecursivelyENS_9GCCellPtrE(thing: GCCellPtr) + -> u8; + fn _ZN2JS6PokeGCEP9JSRuntime(rt: *mut JSRuntime); + fn _ZN2JS14NotifyDidPaintEP9JSRuntime(rt: *mut JSRuntime); + fn _ZN2JS11isGCEnabledEv() -> u8; + fn _ZN2JS19HeapCellPostBarrierEPPN2js2gc4CellE(cellp: *mut *mut Cell); + fn _ZN2JS16HeapCellRelocateEPPN2js2gc4CellE(cellp: *mut *mut Cell); + fn _ZN2JS26AssertGCThingMustBeTenuredEP8JSObject(obj: *mut JSObject); + fn _ZN2JS32IsOptimizedPlaceholderMagicValueERKNS_5ValueE(v: *const Value) + -> u8; + fn _ZN2JS8SameTypeERKNS_5ValueES2_(lhs: *const Value, rhs: *const Value) + -> u8; + fn _ZN2JS20HeapValuePostBarrierEPNS_5ValueE(valuep: *mut Value); + fn _ZN2JS17HeapValueRelocateEPNS_5ValueE(valuep: *mut Value); + fn _Z14JS_ComputeThisP9JSContextPN2JS5ValueE(cx: *mut JSContext, + vp: *mut Value) -> Value; + fn _ZN2JS20CallReceiverFromArgvEPNS_5ValueE(argv: *mut Value) + -> CallReceiver; + fn _ZN2JS18CallReceiverFromVpEPNS_5ValueE(vp: *mut Value) -> CallReceiver; + fn _ZN2JS14CallArgsFromVpEjPNS_5ValueE(argc: u32, vp: *mut Value) + -> CallArgs; + fn _ZN2JS14CallArgsFromSpEjPNS_5ValueE(argc: u32, sp: *mut Value) + -> CallArgs; + fn _Z7JS_THISP9JSContextPN2JS5ValueE(cx: *mut JSContext, vp: *mut Value) + -> Value; + fn _Z23INTERNED_STRING_TO_JSIDP9JSContextP8JSString(cx: *mut JSContext, + str: *mut JSString) + -> jsid; + fn _ZN2js13ObjectClassIsER8JSObjectNS_12ESClassValueEP9JSContext(obj: + *mut JSObject, + classValue: + ESClassValue, + cx: + *mut JSContext) + -> u8; + fn _ZN2js17IsObjectWithClassERKN2JS5ValueENS_12ESClassValueEP9JSContext(v: + *const Value, + classValue: + ESClassValue, + cx: + *mut JSContext) + -> u8; + fn _ZN2js5UnboxEP9JSContextN2JS6HandleIP8JSObjectEENS2_13MutableHandleINS2_5ValueEEE(cx: + *mut JSContext, + obj: + HandleObject, + vp: + MutableHandleValue) + -> u8; + fn _Z17JS_HoldPrincipalsP12JSPrincipals(principals: *mut JSPrincipals); + fn _Z17JS_DropPrincipalsP9JSRuntimeP12JSPrincipals(rt: *mut JSRuntime, + principals: + *mut JSPrincipals); + fn _Z23JS_SetSecurityCallbacksP9JSRuntimePK19JSSecurityCallbacks(rt: + *mut JSRuntime, + callbacks: + *const JSSecurityCallbacks); + fn _Z23JS_GetSecurityCallbacksP9JSRuntime(rt: *mut JSRuntime) + -> *const JSSecurityCallbacks; + fn _Z23JS_SetTrustedPrincipalsP9JSRuntimePK12JSPrincipals(rt: + *mut JSRuntime, + prin: + *const JSPrincipals); + fn _Z32JS_InitDestroyPrincipalsCallbackP9JSRuntimePFvP12JSPrincipalsE(rt: + *mut JSRuntime, + destroyPrincipals: + JSDestroyPrincipalsOp); + fn _Z24JS_StringHasBeenInternedP9JSContextP8JSString(cx: *mut JSContext, + str: *mut JSString) + -> u8; + fn _Z11JS_CallOnceP14PRCallOnceTypePFbvE(once: *mut JSCallOnceType, + func: JSInitCallback) -> u8; + fn _Z6JS_Nowv() -> i64; + fn _Z14JS_GetNaNValueP9JSContext(cx: *mut JSContext) -> Value; + fn _Z27JS_GetNegativeInfinityValueP9JSContext(cx: *mut JSContext) + -> Value; + fn _Z27JS_GetPositiveInfinityValueP9JSContext(cx: *mut JSContext) + -> Value; + fn _Z22JS_GetEmptyStringValueP9JSContext(cx: *mut JSContext) -> Value; + fn _Z17JS_GetEmptyStringP9JSRuntime(rt: *mut JSRuntime) -> *mut JSString; + fn _Z22JS_GetCompartmentStatsP9JSRuntimeRN2js6VectorI20CompartmentTimeStatsLj0ENS1_17SystemAllocPolicyEEE(rt: + *mut JSRuntime, + stats: + *mut CompartmentStatsVector) + -> u8; + fn _Z16JS_ValueToObjectP9JSContextN2JS6HandleINS1_5ValueEEENS1_13MutableHandleIP8JSObjectEE(cx: + *mut JSContext, + v: + HandleValue, + objp: + MutableHandleObject) + -> u8; + fn _Z18JS_ValueToFunctionP9JSContextN2JS6HandleINS1_5ValueEEE(cx: + *mut JSContext, + v: + HandleValue) + -> *mut JSFunction; + fn _Z21JS_ValueToConstructorP9JSContextN2JS6HandleINS1_5ValueEEE(cx: + *mut JSContext, + v: + HandleValue) + -> *mut JSFunction; + fn _Z16JS_ValueToSourceP9JSContextN2JS6HandleINS1_5ValueEEE(cx: + *mut JSContext, + v: + Handle) + -> *mut JSString; + fn _Z16JS_DoubleIsInt32dPi(d: f64, ip: *mut i32) -> u8; + fn _Z14JS_TypeOfValueP9JSContextN2JS6HandleINS1_5ValueEEE(cx: + *mut JSContext, + v: + Handle) + -> JSType; + fn _Z16JS_StrictlyEqualP9JSContextN2JS6HandleINS1_5ValueEEES4_Pb(cx: + *mut JSContext, + v1: + Handle, + v2: + Handle, + equal: + *mut u8) + -> u8; + fn _Z15JS_LooselyEqualP9JSContextN2JS6HandleINS1_5ValueEEES4_Pb(cx: + *mut JSContext, + v1: + Handle, + v2: + Handle, + equal: + *mut u8) + -> u8; + fn _Z12JS_SameValueP9JSContextN2JS6HandleINS1_5ValueEEES4_Pb(cx: + *mut JSContext, + v1: + Handle, + v2: + Handle, + same: + *mut u8) + -> u8; + fn _Z24JS_IsBuiltinEvalFunctionP10JSFunction(fun: *mut JSFunction) -> u8; + fn _Z31JS_IsBuiltinFunctionConstructorP10JSFunction(fun: *mut JSFunction) + -> u8; + fn _Z7JS_Initv() -> u8; + fn _Z11JS_ShutDownv(); + fn _Z13JS_NewRuntimejjP9JSRuntime(maxbytes: u32, maxNurseryBytes: u32, + parentRuntime: *mut JSRuntime) + -> *mut JSRuntime; + fn _Z17JS_DestroyRuntimeP9JSRuntime(rt: *mut JSRuntime); + fn _Z24JS_SetICUMemoryFunctionsPFPvPKvjEPFS_S1_S_jEPFvS1_S_E(allocFn: + JS_ICUAllocFn, + reallocFn: + JS_ICUReallocFn, + freeFn: + JS_ICUFreeFn) + -> u8; + fn _Z20JS_GetRuntimePrivateP9JSRuntime(rt: *mut JSRuntime) + -> *mut ::libc::c_void; + fn _Z19JS_GetParentRuntimeP9JSContext(cx: *mut JSContext) + -> *mut JSRuntime; + fn _Z20JS_SetRuntimePrivateP9JSRuntimePv(rt: *mut JSRuntime, + data: *mut ::libc::c_void); + fn _Z15JS_BeginRequestP9JSContext(cx: *mut JSContext); + fn _Z13JS_EndRequestP9JSContext(cx: *mut JSContext); + fn _ZN2js16AssertHeapIsIdleEP9JSRuntime(rt: *mut JSRuntime); + fn _ZN2js16AssertHeapIsIdleEP9JSContext(cx: *mut JSContext); + fn _Z21JS_SetContextCallbackP9JSRuntimePFbP9JSContextjPvES3_(rt: + *mut JSRuntime, + cxCallback: + JSContextCallback, + data: + *mut ::libc::c_void); + #[cfg(target_pointer_width = "64")] + fn _Z13JS_NewContextP9JSRuntimem(rt: *mut JSRuntime, stackChunkSize: ::libc::size_t) + -> *mut JSContext; + #[cfg(target_pointer_width = "32")] + fn _Z13JS_NewContextP9JSRuntimej(rt: *mut JSRuntime, stackChunkSize: ::libc::size_t) + -> *mut JSContext; + fn _Z17JS_DestroyContextP9JSContext(cx: *mut JSContext); + fn _Z21JS_DestroyContextNoGCP9JSContext(cx: *mut JSContext); + fn _Z20JS_GetContextPrivateP9JSContext(cx: *mut JSContext) + -> *mut ::libc::c_void; + fn _Z20JS_SetContextPrivateP9JSContextPv(cx: *mut JSContext, + data: *mut ::libc::c_void); + fn _Z26JS_GetSecondContextPrivateP9JSContext(cx: *mut JSContext) + -> *mut ::libc::c_void; + fn _Z26JS_SetSecondContextPrivateP9JSContextPv(cx: *mut JSContext, + data: *mut ::libc::c_void); + fn _Z18JS_ContextIteratorP9JSRuntimePP9JSContext(rt: *mut JSRuntime, + iterp: + *mut *mut JSContext) + -> *mut JSContext; + fn _Z13JS_GetVersionP9JSContext(cx: *mut JSContext) -> JSVersion; + fn _Z27JS_SetVersionForCompartmentP13JSCompartment9JSVersion(compartment: + *mut JSCompartment, + version: + JSVersion); + fn _Z18JS_VersionToString9JSVersion(version: JSVersion) -> *const i8; + fn _Z18JS_StringToVersionPKc(string: *const i8) -> JSVersion; + fn _ZN2JS17RuntimeOptionsRefEP9JSRuntime(rt: *mut JSRuntime) + -> *mut RuntimeOptions; + fn _ZN2JS17RuntimeOptionsRefEP9JSContext(cx: *mut JSContext) + -> *mut RuntimeOptions; + fn _ZN2JS17ContextOptionsRefEP9JSContext(cx: *mut JSContext) + -> *mut ContextOptions; + fn _Z27JS_GetImplementationVersionv() -> *const i8; + fn _Z32JS_SetDestroyCompartmentCallbackP9JSRuntimePFvP8JSFreeOpP13JSCompartmentE(rt: + *mut JSRuntime, + callback: + JSDestroyCompartmentCallback); + fn _Z25JS_SetDestroyZoneCallbackP9JSRuntimePFvPN2JS4ZoneEE(rt: + *mut JSRuntime, + callback: + JSZoneCallback); + fn _Z23JS_SetSweepZoneCallbackP9JSRuntimePFvPN2JS4ZoneEE(rt: + *mut JSRuntime, + callback: + JSZoneCallback); + fn _Z29JS_SetCompartmentNameCallbackP9JSRuntimePFvS0_P13JSCompartmentPcjE(rt: + *mut JSRuntime, + callback: + JSCompartmentNameCallback); + fn _Z25JS_SetWrapObjectCallbacksP9JSRuntimePK21JSWrapObjectCallbacks(rt: + *mut JSRuntime, + callbacks: + *const JSWrapObjectCallbacks); + fn _Z24JS_SetCompartmentPrivateP13JSCompartmentPv(compartment: + *mut JSCompartment, + data: + *mut ::libc::c_void); + fn _Z24JS_GetCompartmentPrivateP13JSCompartment(compartment: + *mut JSCompartment) + -> *mut ::libc::c_void; + fn _Z18JS_SetZoneUserDataPN2JS4ZoneEPv(zone: *mut Zone, + data: *mut ::libc::c_void); + fn _Z18JS_GetZoneUserDataPN2JS4ZoneE(zone: *mut Zone) + -> *mut ::libc::c_void; + fn _Z13JS_WrapObjectP9JSContextN2JS13MutableHandleIP8JSObjectEE(cx: + *mut JSContext, + objp: + MutableHandleObject) + -> u8; + fn _Z12JS_WrapValueP9JSContextN2JS13MutableHandleINS1_5ValueEEE(cx: + *mut JSContext, + vp: + MutableHandleValue) + -> u8; + fn _Z19JS_TransplantObjectP9JSContextN2JS6HandleIP8JSObjectEES5_(cx: + *mut JSContext, + origobj: + HandleObject, + target: + HandleObject) + -> *mut JSObject; + fn _Z34JS_RefreshCrossCompartmentWrappersP9JSContextN2JS6HandleIP8JSObjectEE(cx: + *mut JSContext, + obj: + Handle<*mut JSObject>) + -> u8; + fn _Z19JS_EnterCompartmentP9JSContextP8JSObject(cx: *mut JSContext, + target: *mut JSObject) + -> *mut JSCompartment; + fn _Z19JS_LeaveCompartmentP9JSContextP13JSCompartment(cx: *mut JSContext, + oldCompartment: + *mut JSCompartment); + fn _Z22JS_IterateCompartmentsP9JSRuntimePvPFvS0_S1_P13JSCompartmentE(rt: + *mut JSRuntime, + data: + *mut ::libc::c_void, + compartmentCallback: + JSIterateCompartmentCallback); + fn _Z22JS_InitStandardClassesP9JSContextN2JS6HandleIP8JSObjectEE(cx: + *mut JSContext, + obj: + Handle<*mut JSObject>) + -> u8; + fn _Z23JS_ResolveStandardClassP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEEPb(cx: + *mut JSContext, + obj: + HandleObject, + id: + HandleId, + resolved: + *mut u8) + -> u8; + fn _Z27JS_EnumerateStandardClassesP9JSContextN2JS6HandleIP8JSObjectEE(cx: + *mut JSContext, + obj: + HandleObject) + -> u8; + fn _Z17JS_GetClassObjectP9JSContext10JSProtoKeyN2JS13MutableHandleIP8JSObjectEE(cx: + *mut JSContext, + key: + JSProtoKey, + objp: + MutableHandle<*mut JSObject>) + -> u8; + fn _Z20JS_GetClassPrototypeP9JSContext10JSProtoKeyN2JS13MutableHandleIP8JSObjectEE(cx: + *mut JSContext, + key: + JSProtoKey, + objp: + MutableHandle<*mut JSObject>) + -> u8; + fn _ZN2JS24IdentifyStandardInstanceEP8JSObject(obj: *mut JSObject) + -> JSProtoKey; + fn _ZN2JS25IdentifyStandardPrototypeEP8JSObject(obj: *mut JSObject) + -> JSProtoKey; + fn _ZN2JS35IdentifyStandardInstanceOrPrototypeEP8JSObject(obj: + *mut JSObject) + -> JSProtoKey; + fn _ZN2JS27IdentifyStandardConstructorEP8JSObject(obj: *mut JSObject) + -> JSProtoKey; + fn _ZN2JS12ProtoKeyToIdEP9JSContext10JSProtoKeyNS_13MutableHandleI4jsidEE(cx: + *mut JSContext, + key: + JSProtoKey, + idp: + MutableHandleId); + fn _Z15JS_IdToProtoKeyP9JSContextN2JS6HandleI4jsidEE(cx: *mut JSContext, + id: HandleId) + -> JSProtoKey; + fn _Z23JS_GetFunctionPrototypeP9JSContextN2JS6HandleIP8JSObjectEE(cx: + *mut JSContext, + forObj: + HandleObject) + -> *mut JSObject; + fn _Z21JS_GetObjectPrototypeP9JSContextN2JS6HandleIP8JSObjectEE(cx: + *mut JSContext, + forObj: + HandleObject) + -> *mut JSObject; + fn _Z20JS_GetArrayPrototypeP9JSContextN2JS6HandleIP8JSObjectEE(cx: + *mut JSContext, + forObj: + HandleObject) + -> *mut JSObject; + fn _Z20JS_GetErrorPrototypeP9JSContext(cx: *mut JSContext) + -> *mut JSObject; + fn _Z21JS_GetGlobalForObjectP9JSContextP8JSObject(cx: *mut JSContext, + obj: *mut JSObject) + -> *mut JSObject; + fn _Z17JS_IsGlobalObjectP8JSObject(obj: *mut JSObject) -> u8; + fn _Z32JS_GetGlobalForCompartmentOrNullP9JSContextP13JSCompartment(cx: + *mut JSContext, + c: + *mut JSCompartment) + -> *mut JSObject; + fn _ZN2JS19CurrentGlobalOrNullEP9JSContext(cx: *mut JSContext) + -> *mut JSObject; + fn _Z14JS_InitReflectP9JSContextN2JS6HandleIP8JSObjectEE(cx: + *mut JSContext, + global: + HandleObject) + -> *mut JSObject; + fn _Z27JS_DefineProfilingFunctionsP9JSContextN2JS6HandleIP8JSObjectEE(cx: + *mut JSContext, + obj: + HandleObject) + -> u8; + fn _Z23JS_DefineDebuggerObjectP9JSContextN2JS6HandleIP8JSObjectEE(cx: + *mut JSContext, + obj: + HandleObject) + -> u8; + fn _Z18JS_InitCTypesClassP9JSContextN2JS6HandleIP8JSObjectEE(cx: + *mut JSContext, + global: + HandleObject) + -> u8; + fn _Z21JS_SetCTypesCallbacksP8JSObjectPK17JSCTypesCallbacks(ctypesObj: + *mut JSObject, + callbacks: + *const JSCTypesCallbacks); + fn _Z9JS_mallocP9JSContextj(cx: *mut JSContext, nbytes: u32) + -> *mut ::libc::c_void; + fn _Z10JS_reallocP9JSContextPvjj(cx: *mut JSContext, + p: *mut ::libc::c_void, oldBytes: u32, + newBytes: u32) -> *mut ::libc::c_void; + fn _Z7JS_freeP9JSContextPv(cx: *mut JSContext, p: *mut ::libc::c_void); + fn _Z9JS_freeopP8JSFreeOpPv(fop: *mut JSFreeOp, p: *mut ::libc::c_void); + fn _Z19JS_GetDefaultFreeOpP9JSRuntime(rt: *mut JSRuntime) + -> *mut JSFreeOp; + fn _Z22JS_updateMallocCounterP9JSContextj(cx: *mut JSContext, + nbytes: u32); + fn _Z9JS_strdupP9JSContextPKc(cx: *mut JSContext, s: *const i8) + -> *mut i8; + fn _Z9JS_strdupP9JSRuntimePKc(rt: *mut JSRuntime, s: *const i8) + -> *mut i8; + fn _Z24JS_AddExtraGCRootsTracerP9JSRuntimePFvP8JSTracerPvES3_(rt: + *mut JSRuntime, + traceOp: + JSTraceDataOp, + data: + *mut ::libc::c_void) + -> u8; + fn _Z27JS_RemoveExtraGCRootsTracerP9JSRuntimePFvP8JSTracerPvES3_(rt: + *mut JSRuntime, + traceOp: + JSTraceDataOp, + data: + *mut ::libc::c_void); + fn _Z5JS_GCP9JSRuntime(rt: *mut JSRuntime); + fn _Z10JS_MaybeGCP9JSContext(cx: *mut JSContext); + fn _Z16JS_SetGCCallbackP9JSRuntimePFvS0_10JSGCStatusPvES2_(rt: + *mut JSRuntime, + cb: + JSGCCallback, + data: + *mut ::libc::c_void); + fn _Z22JS_AddFinalizeCallbackP9JSRuntimePFvP8JSFreeOp16JSFinalizeStatusbPvES4_(rt: + *mut JSRuntime, + cb: + JSFinalizeCallback, + data: + *mut ::libc::c_void) + -> u8; + fn _Z25JS_RemoveFinalizeCallbackP9JSRuntimePFvP8JSFreeOp16JSFinalizeStatusbPvE(rt: + *mut JSRuntime, + cb: + JSFinalizeCallback); + fn _Z20JS_IsGCMarkingTracerP8JSTracer(trc: *mut JSTracer) -> u8; + fn _Z25JS_AddWeakPointerCallbackP9JSRuntimePFvS0_PvES1_(rt: + *mut JSRuntime, + cb: + JSWeakPointerCallback, + data: + *mut ::libc::c_void) + -> u8; + fn _Z28JS_RemoveWeakPointerCallbackP9JSRuntimePFvS0_PvE(rt: + *mut JSRuntime, + cb: + JSWeakPointerCallback); + fn _Z27JS_UpdateWeakPointerAfterGCPN2JS4HeapIP8JSObjectEE(objp: + *mut Heap<*mut JSObject>); + fn _Z38JS_UpdateWeakPointerAfterGCUnbarrieredPP8JSObject(objp: + *mut *mut JSObject); + fn _Z17JS_SetGCParameterP9JSRuntime12JSGCParamKeyj(rt: *mut JSRuntime, + key: JSGCParamKey, + value: u32); + fn _Z17JS_GetGCParameterP9JSRuntime12JSGCParamKey(rt: *mut JSRuntime, + key: JSGCParamKey) + -> u32; + fn _Z26JS_SetGCParameterForThreadP9JSContext12JSGCParamKeyj(cx: + *mut JSContext, + key: + JSGCParamKey, + value: u32); + fn _Z26JS_GetGCParameterForThreadP9JSContext12JSGCParamKey(cx: + *mut JSContext, + key: + JSGCParamKey) + -> u32; + fn _Z40JS_SetGCParametersBasedOnAvailableMemoryP9JSRuntimej(rt: + *mut JSRuntime, + availMem: + u32); + fn _Z20JS_NewExternalStringP9JSContextPKDsjPK17JSStringFinalizer(cx: + *mut JSContext, + chars: + *const i16, + length: + u32, + fin: + *const JSStringFinalizer) + -> *mut JSString; + fn _Z19JS_IsExternalStringP8JSString(str: *mut JSString) -> u8; + fn _Z29JS_GetExternalStringFinalizerP8JSString(str: *mut JSString) + -> *const JSStringFinalizer; + fn _Z22JS_SetNativeStackQuotaP9JSRuntimejjj(cx: *mut JSRuntime, + systemCodeStackSize: u32, + trustedScriptStackSize: u32, + untrustedScriptStackSize: + u32); + fn _Z16JS_IdArrayLengthP9JSContextP9JSIdArray(cx: *mut JSContext, + ida: *mut JSIdArray) -> i32; + fn _Z13JS_IdArrayGetP9JSContextP9JSIdArrayj(cx: *mut JSContext, + ida: *mut JSIdArray, + index: u32) -> jsid; + fn _Z17JS_DestroyIdArrayP9JSContextP9JSIdArray(cx: *mut JSContext, + ida: *mut JSIdArray); + fn _Z12JS_ValueToIdP9JSContextN2JS6HandleINS1_5ValueEEENS1_13MutableHandleI4jsidEE(cx: + *mut JSContext, + v: + HandleValue, + idp: + MutableHandleId) + -> u8; + fn _Z13JS_StringToIdP9JSContextN2JS6HandleIP8JSStringEENS1_13MutableHandleI4jsidEE(cx: + *mut JSContext, + s: + HandleString, + idp: + MutableHandleId) + -> u8; + fn _Z12JS_IdToValueP9JSContext4jsidN2JS13MutableHandleINS2_5ValueEEE(cx: + *mut JSContext, + id: + jsid, + vp: + MutableHandle) + -> u8; + fn _Z15JS_DefaultValueP9JSContextN2JS6HandleIP8JSObjectEE6JSTypeNS1_13MutableHandleINS1_5ValueEEE(cx: + *mut JSContext, + obj: + Handle<*mut JSObject>, + hint: + JSType, + vp: + MutableHandle) + -> u8; + fn _Z15JS_PropertyStubP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEENS1_13MutableHandleINS1_5ValueEEE(cx: + *mut JSContext, + obj: + HandleObject, + id: + HandleId, + vp: + MutableHandleValue) + -> u8; + fn _Z21JS_StrictPropertyStubP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEENS1_13MutableHandleINS1_5ValueEEERNS1_14ObjectOpResultE(cx: + *mut JSContext, + obj: + HandleObject, + id: + HandleId, + vp: + MutableHandleValue, + result: + *mut ObjectOpResult) + -> u8; + fn _ZN2JS6detail13CheckIsNativeEPFbP9JSContextjPNS_5ValueEE(native: + JSNative) + -> i32; + fn _ZN2JS6detail15CheckIsGetterOpEPFbP9JSContextNS_6HandleIP8JSObjectEENS3_I4jsidEENS_13MutableHandleINS_5ValueEEEE(op: + JSGetterOp) + -> i32; + fn _ZN2JS6detail15CheckIsSetterOpEPFbP9JSContextNS_6HandleIP8JSObjectEENS3_I4jsidEENS_13MutableHandleINS_5ValueEEERNS_14ObjectOpResultEE(op: + JSSetterOp) + -> i32; + fn _Z12JS_InitClassP9JSContextN2JS6HandleIP8JSObjectEES5_PK7JSClassPFbS0_jPNS1_5ValueEEjPK14JSPropertySpecPK14JSFunctionSpecSF_SI_(cx: + *mut JSContext, + obj: + HandleObject, + parent_proto: + HandleObject, + clasp: + *const JSClass, + constructor: + JSNative, + nargs: + u32, + ps: + *const JSPropertySpec, + fs: + *const JSFunctionSpec, + static_ps: + *const JSPropertySpec, + static_fs: + *const JSFunctionSpec) + -> *mut JSObject; + fn _Z30JS_LinkConstructorAndPrototypeP9JSContextN2JS6HandleIP8JSObjectEES5_(cx: + *mut JSContext, + ctor: + Handle<*mut JSObject>, + proto: + Handle<*mut JSObject>) + -> u8; + fn _Z11JS_GetClassP8JSObject(obj: *mut JSObject) -> *const JSClass; + fn _Z13JS_InstanceOfP9JSContextN2JS6HandleIP8JSObjectEEPK7JSClassPNS1_8CallArgsE(cx: + *mut JSContext, + obj: + Handle<*mut JSObject>, + clasp: + *const JSClass, + args: + *mut CallArgs) + -> u8; + fn _Z14JS_HasInstanceP9JSContextN2JS6HandleIP8JSObjectEENS2_INS1_5ValueEEEPb(cx: + *mut JSContext, + obj: + Handle<*mut JSObject>, + v: + Handle, + bp: + *mut u8) + -> u8; + fn _Z13JS_GetPrivateP8JSObject(obj: *mut JSObject) -> *mut ::libc::c_void; + fn _Z13JS_SetPrivateP8JSObjectPv(obj: *mut JSObject, + data: *mut ::libc::c_void); + fn _Z21JS_GetInstancePrivateP9JSContextN2JS6HandleIP8JSObjectEEPK7JSClassPNS1_8CallArgsE(cx: + *mut JSContext, + obj: + Handle<*mut JSObject>, + clasp: + *const JSClass, + args: + *mut CallArgs) + -> *mut ::libc::c_void; + fn _Z15JS_GetPrototypeP9JSContextN2JS6HandleIP8JSObjectEENS1_13MutableHandleIS4_EE(cx: + *mut JSContext, + obj: + HandleObject, + protop: + MutableHandleObject) + -> u8; + fn _Z15JS_SetPrototypeP9JSContextN2JS6HandleIP8JSObjectEES5_(cx: + *mut JSContext, + obj: + HandleObject, + proto: + HandleObject) + -> u8; + fn _Z17JS_GetConstructorP9JSContextN2JS6HandleIP8JSObjectEE(cx: + *mut JSContext, + proto: + Handle<*mut JSObject>) + -> *mut JSObject; + fn _ZN2JS21CompartmentOptionsRefEP13JSCompartment(compartment: + *mut JSCompartment) + -> *mut CompartmentOptions; + fn _ZN2JS21CompartmentOptionsRefEP8JSObject(obj: *mut JSObject) + -> *mut CompartmentOptions; + fn _ZN2JS21CompartmentOptionsRefEP9JSContext(cx: *mut JSContext) + -> *mut CompartmentOptions; + fn _Z18JS_NewGlobalObjectP9JSContextPK7JSClassP12JSPrincipalsN2JS21OnNewGlobalHookOptionERKNS6_18CompartmentOptionsE(cx: + *mut JSContext, + clasp: + *const JSClass, + principals: + *mut JSPrincipals, + hookOption: + OnNewGlobalHookOption, + options: + *const CompartmentOptions) + -> *mut JSObject; + pub fn _Z24JS_GlobalObjectTraceHookP8JSTracerP8JSObject(trc: *mut JSTracer, + global: + *mut JSObject); + fn _Z24JS_FireOnNewGlobalObjectP9JSContextN2JS6HandleIP8JSObjectEE(cx: + *mut JSContext, + global: + HandleObject); + fn _Z12JS_NewObjectP9JSContextPK7JSClass(cx: *mut JSContext, + clasp: *const JSClass) + -> *mut JSObject; + fn _Z15JS_IsExtensibleP9JSContextN2JS6HandleIP8JSObjectEEPb(cx: + *mut JSContext, + obj: + HandleObject, + extensible: + *mut u8) + -> u8; + fn _Z11JS_IsNativeP8JSObject(obj: *mut JSObject) -> u8; + fn _Z19JS_GetObjectRuntimeP8JSObject(obj: *mut JSObject) + -> *mut JSRuntime; + fn _Z26JS_NewObjectWithGivenProtoP9JSContextPK7JSClassN2JS6HandleIP8JSObjectEE(cx: + *mut JSContext, + clasp: + *const JSClass, + proto: + Handle<*mut JSObject>) + -> *mut JSObject; + fn _Z17JS_NewPlainObjectP9JSContext(cx: *mut JSContext) -> *mut JSObject; + fn _Z19JS_DeepFreezeObjectP9JSContextN2JS6HandleIP8JSObjectEE(cx: + *mut JSContext, + obj: + Handle<*mut JSObject>) + -> u8; + fn _Z15JS_FreezeObjectP9JSContextN2JS6HandleIP8JSObjectEE(cx: + *mut JSContext, + obj: + Handle<*mut JSObject>) + -> u8; + fn _Z20JS_PreventExtensionsP9JSContextN2JS6HandleIP8JSObjectEERNS1_14ObjectOpResultE(cx: + *mut JSContext, + obj: + HandleObject, + result: + *mut ObjectOpResult) + -> u8; + fn _Z6JS_NewP9JSContextN2JS6HandleIP8JSObjectEERKNS1_16HandleValueArrayE(cx: + *mut JSContext, + ctor: + HandleObject, + args: + *const HandleValueArray) + -> *mut JSObject; + fn _ZN2JS34ObjectToCompletePropertyDescriptorEP9JSContextNS_6HandleIP8JSObjectEENS2_INS_5ValueEEENS_13MutableHandleI20JSPropertyDescriptorEE(cx: + *mut JSContext, + obj: + HandleObject, + descriptor: + HandleValue, + desc: + MutableHandle) + -> u8; + fn _Z17JS_DefinePropertyP9JSContextN2JS6HandleIP8JSObjectEEPKcNS2_INS1_5ValueEEEjPFbS0_jPS8_ESC_(cx: + *mut JSContext, + obj: + HandleObject, + name: + *const i8, + value: + HandleValue, + attrs: + u32, + getter: + JSNative, + setter: + JSNative) + -> u8; + fn _Z17JS_DefinePropertyP9JSContextN2JS6HandleIP8JSObjectEEPKcS5_jPFbS0_jPNS1_5ValueEESB_(cx: + *mut JSContext, + obj: + HandleObject, + name: + *const i8, + value: + HandleObject, + attrs: + u32, + getter: + JSNative, + setter: + JSNative) + -> u8; + fn _Z17JS_DefinePropertyP9JSContextN2JS6HandleIP8JSObjectEEPKcNS2_IP8JSStringEEjPFbS0_jPNS1_5ValueEESE_(cx: + *mut JSContext, + obj: + HandleObject, + name: + *const i8, + value: + HandleString, + attrs: + u32, + getter: + JSNative, + setter: + JSNative) + -> u8; + fn _Z17JS_DefinePropertyP9JSContextN2JS6HandleIP8JSObjectEEPKcijPFbS0_jPNS1_5ValueEESB_(cx: + *mut JSContext, + obj: + HandleObject, + name: + *const i8, + value: + i32, + attrs: + u32, + getter: + JSNative, + setter: + JSNative) + -> u8; + fn _Z17JS_DefinePropertyP9JSContextN2JS6HandleIP8JSObjectEEPKcjjPFbS0_jPNS1_5ValueEESB_(cx: + *mut JSContext, + obj: + HandleObject, + name: + *const i8, + value: + u32, + attrs: + u32, + getter: + JSNative, + setter: + JSNative) + -> u8; + fn _Z17JS_DefinePropertyP9JSContextN2JS6HandleIP8JSObjectEEPKcdjPFbS0_jPNS1_5ValueEESB_(cx: + *mut JSContext, + obj: + HandleObject, + name: + *const i8, + value: + f64, + attrs: + u32, + getter: + JSNative, + setter: + JSNative) + -> u8; + fn _Z21JS_DefinePropertyByIdP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEENS2_INS1_5ValueEEEjPFbS0_jPS8_ESC_(cx: + *mut JSContext, + obj: + HandleObject, + id: + HandleId, + value: + HandleValue, + attrs: + u32, + getter: + JSNative, + setter: + JSNative) + -> u8; + fn _Z21JS_DefinePropertyByIdP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEES5_jPFbS0_jPNS1_5ValueEESB_(cx: + *mut JSContext, + obj: + HandleObject, + id: + HandleId, + value: + HandleObject, + attrs: + u32, + getter: + JSNative, + setter: + JSNative) + -> u8; + fn _Z21JS_DefinePropertyByIdP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEENS2_IP8JSStringEEjPFbS0_jPNS1_5ValueEESE_(cx: + *mut JSContext, + obj: + HandleObject, + id: + HandleId, + value: + HandleString, + attrs: + u32, + getter: + JSNative, + setter: + JSNative) + -> u8; + fn _Z21JS_DefinePropertyByIdP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEEijPFbS0_jPNS1_5ValueEESB_(cx: + *mut JSContext, + obj: + HandleObject, + id: + HandleId, + value: + i32, + attrs: + u32, + getter: + JSNative, + setter: + JSNative) + -> u8; + fn _Z21JS_DefinePropertyByIdP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEEjjPFbS0_jPNS1_5ValueEESB_(cx: + *mut JSContext, + obj: + HandleObject, + id: + HandleId, + value: + u32, + attrs: + u32, + getter: + JSNative, + setter: + JSNative) + -> u8; + fn _Z21JS_DefinePropertyByIdP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEEdjPFbS0_jPNS1_5ValueEESB_(cx: + *mut JSContext, + obj: + HandleObject, + id: + HandleId, + value: + f64, + attrs: + u32, + getter: + JSNative, + setter: + JSNative) + -> u8; + fn _Z21JS_DefinePropertyByIdP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEENS2_I20JSPropertyDescriptorEERNS1_14ObjectOpResultE(cx: + *mut JSContext, + obj: + HandleObject, + id: + HandleId, + desc: + Handle, + result: + *mut ObjectOpResult) + -> u8; + fn _Z21JS_DefinePropertyByIdP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEENS2_I20JSPropertyDescriptorEE(cx: + *mut JSContext, + obj: + HandleObject, + id: + HandleId, + desc: + Handle) + -> u8; + fn _Z15JS_DefineObjectP9JSContextN2JS6HandleIP8JSObjectEEPKcPK7JSClassj(cx: + *mut JSContext, + obj: + HandleObject, + name: + *const i8, + clasp: + *const JSClass, + attrs: + u32) + -> *mut JSObject; + fn _Z21JS_DefineConstDoublesP9JSContextN2JS6HandleIP8JSObjectEEPK17JSConstScalarSpecIdE(cx: + *mut JSContext, + obj: + HandleObject, + cds: + *const JSConstDoubleSpec) + -> u8; + fn _Z22JS_DefineConstIntegersP9JSContextN2JS6HandleIP8JSObjectEEPK17JSConstScalarSpecIiE(cx: + *mut JSContext, + obj: + HandleObject, + cis: + *const JSConstIntegerSpec) + -> u8; + fn _Z19JS_DefinePropertiesP9JSContextN2JS6HandleIP8JSObjectEEPK14JSPropertySpec(cx: + *mut JSContext, + obj: + HandleObject, + ps: + *const JSPropertySpec) + -> u8; + fn _Z24JS_AlreadyHasOwnPropertyP9JSContextN2JS6HandleIP8JSObjectEEPKcPb(cx: + *mut JSContext, + obj: + HandleObject, + name: + *const i8, + foundp: + *mut u8) + -> u8; + fn _Z28JS_AlreadyHasOwnPropertyByIdP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEEPb(cx: + *mut JSContext, + obj: + HandleObject, + id: + HandleId, + foundp: + *mut u8) + -> u8; + fn _Z14JS_HasPropertyP9JSContextN2JS6HandleIP8JSObjectEEPKcPb(cx: + *mut JSContext, + obj: + HandleObject, + name: + *const i8, + foundp: + *mut u8) + -> u8; + fn _Z18JS_HasPropertyByIdP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEEPb(cx: + *mut JSContext, + obj: + HandleObject, + id: + HandleId, + foundp: + *mut u8) + -> u8; + fn _Z31JS_GetOwnPropertyDescriptorByIdP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEENS1_13MutableHandleI20JSPropertyDescriptorEE(cx: + *mut JSContext, + obj: + HandleObject, + id: + HandleId, + desc: + MutableHandle) + -> u8; + fn _Z27JS_GetOwnPropertyDescriptorP9JSContextN2JS6HandleIP8JSObjectEEPKcNS1_13MutableHandleI20JSPropertyDescriptorEE(cx: + *mut JSContext, + obj: + HandleObject, + name: + *const i8, + desc: + MutableHandle) + -> u8; + fn _Z29JS_GetOwnUCPropertyDescriptorP9JSContextN2JS6HandleIP8JSObjectEEPKDsNS1_13MutableHandleI20JSPropertyDescriptorEE(cx: + *mut JSContext, + obj: + HandleObject, + name: + *const i16, + desc: + MutableHandle) + -> u8; + fn _Z28JS_GetPropertyDescriptorByIdP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEENS1_13MutableHandleI20JSPropertyDescriptorEE(cx: + *mut JSContext, + obj: + HandleObject, + id: + HandleId, + desc: + MutableHandle) + -> u8; + fn _Z24JS_GetPropertyDescriptorP9JSContextN2JS6HandleIP8JSObjectEEPKcNS1_13MutableHandleI20JSPropertyDescriptorEE(cx: + *mut JSContext, + obj: + HandleObject, + name: + *const i8, + desc: + MutableHandle) + -> u8; + fn _Z14JS_GetPropertyP9JSContextN2JS6HandleIP8JSObjectEEPKcNS1_13MutableHandleINS1_5ValueEEE(cx: + *mut JSContext, + obj: + HandleObject, + name: + *const i8, + vp: + MutableHandleValue) + -> u8; + fn _Z18JS_GetPropertyByIdP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEENS1_13MutableHandleINS1_5ValueEEE(cx: + *mut JSContext, + obj: + HandleObject, + id: + HandleId, + vp: + MutableHandleValue) + -> u8; + fn _Z23JS_ForwardGetPropertyToP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEES5_NS1_13MutableHandleINS1_5ValueEEE(cx: + *mut JSContext, + obj: + HandleObject, + id: + HandleId, + onBehalfOf: + HandleObject, + vp: + MutableHandleValue) + -> u8; + fn _Z14JS_SetPropertyP9JSContextN2JS6HandleIP8JSObjectEEPKcNS2_INS1_5ValueEEE(cx: + *mut JSContext, + obj: + HandleObject, + name: + *const i8, + v: + HandleValue) + -> u8; + fn _Z18JS_SetPropertyByIdP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEENS2_INS1_5ValueEEE(cx: + *mut JSContext, + obj: + HandleObject, + id: + HandleId, + v: + HandleValue) + -> u8; + fn _Z23JS_ForwardSetPropertyToP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEENS2_INS1_5ValueEEES9_RNS1_14ObjectOpResultE(cx: + *mut JSContext, + obj: + HandleObject, + id: + HandleId, + v: + HandleValue, + receiver: + HandleValue, + result: + *mut ObjectOpResult) + -> u8; + fn _Z17JS_DeletePropertyP9JSContextN2JS6HandleIP8JSObjectEEPKc(cx: + *mut JSContext, + obj: + HandleObject, + name: + *const i8) + -> u8; + fn _Z17JS_DeletePropertyP9JSContextN2JS6HandleIP8JSObjectEEPKcRNS1_14ObjectOpResultE(cx: + *mut JSContext, + obj: + HandleObject, + name: + *const i8, + result: + *mut ObjectOpResult) + -> u8; + fn _Z21JS_DeletePropertyByIdP9JSContextN2JS6HandleIP8JSObjectEE4jsid(cx: + *mut JSContext, + obj: + HandleObject, + id: + jsid) + -> u8; + fn _Z21JS_DeletePropertyByIdP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEERNS1_14ObjectOpResultE(cx: + *mut JSContext, + obj: + HandleObject, + id: + HandleId, + result: + *mut ObjectOpResult) + -> u8; + fn _Z19JS_DefineUCPropertyP9JSContextN2JS6HandleIP8JSObjectEEPKDsjNS2_INS1_5ValueEEEjPFbS0_jPS8_ESC_(cx: + *mut JSContext, + obj: + HandleObject, + name: + *const i16, + namelen: + u32, + value: + HandleValue, + attrs: + u32, + getter: + JSNative, + setter: + JSNative) + -> u8; + fn _Z19JS_DefineUCPropertyP9JSContextN2JS6HandleIP8JSObjectEEPKDsjS5_jPFbS0_jPNS1_5ValueEESB_(cx: + *mut JSContext, + obj: + HandleObject, + name: + *const i16, + namelen: + u32, + value: + HandleObject, + attrs: + u32, + getter: + JSNative, + setter: + JSNative) + -> u8; + fn _Z19JS_DefineUCPropertyP9JSContextN2JS6HandleIP8JSObjectEEPKDsjNS2_IP8JSStringEEjPFbS0_jPNS1_5ValueEESE_(cx: + *mut JSContext, + obj: + HandleObject, + name: + *const i16, + namelen: + u32, + value: + HandleString, + attrs: + u32, + getter: + JSNative, + setter: + JSNative) + -> u8; + fn _Z19JS_DefineUCPropertyP9JSContextN2JS6HandleIP8JSObjectEEPKDsjijPFbS0_jPNS1_5ValueEESB_(cx: + *mut JSContext, + obj: + HandleObject, + name: + *const i16, + namelen: + u32, + value: + i32, + attrs: + u32, + getter: + JSNative, + setter: + JSNative) + -> u8; + fn _Z19JS_DefineUCPropertyP9JSContextN2JS6HandleIP8JSObjectEEPKDsjjjPFbS0_jPNS1_5ValueEESB_(cx: + *mut JSContext, + obj: + HandleObject, + name: + *const i16, + namelen: + u32, + value: + u32, + attrs: + u32, + getter: + JSNative, + setter: + JSNative) + -> u8; + fn _Z19JS_DefineUCPropertyP9JSContextN2JS6HandleIP8JSObjectEEPKDsjdjPFbS0_jPNS1_5ValueEESB_(cx: + *mut JSContext, + obj: + HandleObject, + name: + *const i16, + namelen: + u32, + value: + f64, + attrs: + u32, + getter: + JSNative, + setter: + JSNative) + -> u8; + fn _Z19JS_DefineUCPropertyP9JSContextN2JS6HandleIP8JSObjectEEPKDsjNS2_I20JSPropertyDescriptorEERNS1_14ObjectOpResultE(cx: + *mut JSContext, + obj: + HandleObject, + name: + *const i16, + namelen: + u32, + desc: + Handle, + result: + *mut ObjectOpResult) + -> u8; + fn _Z19JS_DefineUCPropertyP9JSContextN2JS6HandleIP8JSObjectEEPKDsjNS2_I20JSPropertyDescriptorEE(cx: + *mut JSContext, + obj: + HandleObject, + name: + *const i16, + namelen: + u32, + desc: + Handle) + -> u8; + fn _Z26JS_AlreadyHasOwnUCPropertyP9JSContextN2JS6HandleIP8JSObjectEEPKDsjPb(cx: + *mut JSContext, + obj: + HandleObject, + name: + *const i16, + namelen: + u32, + foundp: + *mut u8) + -> u8; + fn _Z16JS_HasUCPropertyP9JSContextN2JS6HandleIP8JSObjectEEPKDsjPb(cx: + *mut JSContext, + obj: + HandleObject, + name: + *const i16, + namelen: + u32, + vp: + *mut u8) + -> u8; + fn _Z16JS_GetUCPropertyP9JSContextN2JS6HandleIP8JSObjectEEPKDsjNS1_13MutableHandleINS1_5ValueEEE(cx: + *mut JSContext, + obj: + HandleObject, + name: + *const i16, + namelen: + u32, + vp: + MutableHandleValue) + -> u8; + fn _Z16JS_SetUCPropertyP9JSContextN2JS6HandleIP8JSObjectEEPKDsjNS2_INS1_5ValueEEE(cx: + *mut JSContext, + obj: + HandleObject, + name: + *const i16, + namelen: + u32, + v: + HandleValue) + -> u8; + fn _Z19JS_DeleteUCPropertyP9JSContextN2JS6HandleIP8JSObjectEEPKDsjRNS1_14ObjectOpResultE(cx: + *mut JSContext, + obj: + HandleObject, + name: + *const i16, + namelen: + u32, + result: + *mut ObjectOpResult) + -> u8; + fn _Z17JS_NewArrayObjectP9JSContextRKN2JS16HandleValueArrayE(cx: + *mut JSContext, + contents: + *const HandleValueArray) + -> *mut JSObject; + fn _Z17JS_NewArrayObjectP9JSContextj(cx: *mut JSContext, length: u32) + -> *mut JSObject; + fn _Z16JS_IsArrayObjectP9JSContextN2JS6HandleINS1_5ValueEEE(cx: + *mut JSContext, + value: + HandleValue) + -> u8; + fn _Z16JS_IsArrayObjectP9JSContextN2JS6HandleIP8JSObjectEE(cx: + *mut JSContext, + obj: + HandleObject) + -> u8; + fn _Z17JS_GetArrayLengthP9JSContextN2JS6HandleIP8JSObjectEEPj(cx: + *mut JSContext, + obj: + Handle<*mut JSObject>, + lengthp: + *mut u32) + -> u8; + fn _Z17JS_SetArrayLengthP9JSContextN2JS6HandleIP8JSObjectEEj(cx: + *mut JSContext, + obj: + Handle<*mut JSObject>, + length: u32) + -> u8; + fn _Z16JS_DefineElementP9JSContextN2JS6HandleIP8JSObjectEEjNS2_INS1_5ValueEEEjPFbS0_jPS6_ESA_(cx: + *mut JSContext, + obj: + HandleObject, + index: + u32, + value: + HandleValue, + attrs: + u32, + getter: + JSNative, + setter: + JSNative) + -> u8; + fn _Z16JS_DefineElementP9JSContextN2JS6HandleIP8JSObjectEEjS5_jPFbS0_jPNS1_5ValueEES9_(cx: + *mut JSContext, + obj: + HandleObject, + index: + u32, + value: + HandleObject, + attrs: + u32, + getter: + JSNative, + setter: + JSNative) + -> u8; + fn _Z16JS_DefineElementP9JSContextN2JS6HandleIP8JSObjectEEjNS2_IP8JSStringEEjPFbS0_jPNS1_5ValueEESC_(cx: + *mut JSContext, + obj: + HandleObject, + index: + u32, + value: + HandleString, + attrs: + u32, + getter: + JSNative, + setter: + JSNative) + -> u8; + fn _Z16JS_DefineElementP9JSContextN2JS6HandleIP8JSObjectEEjijPFbS0_jPNS1_5ValueEES9_(cx: + *mut JSContext, + obj: + HandleObject, + index: + u32, + value: + i32, + attrs: + u32, + getter: + JSNative, + setter: + JSNative) + -> u8; + fn _Z16JS_DefineElementP9JSContextN2JS6HandleIP8JSObjectEEjjjPFbS0_jPNS1_5ValueEES9_(cx: + *mut JSContext, + obj: + HandleObject, + index: + u32, + value: + u32, + attrs: + u32, + getter: + JSNative, + setter: + JSNative) + -> u8; + fn _Z16JS_DefineElementP9JSContextN2JS6HandleIP8JSObjectEEjdjPFbS0_jPNS1_5ValueEES9_(cx: + *mut JSContext, + obj: + HandleObject, + index: + u32, + value: + f64, + attrs: + u32, + getter: + JSNative, + setter: + JSNative) + -> u8; + fn _Z23JS_AlreadyHasOwnElementP9JSContextN2JS6HandleIP8JSObjectEEjPb(cx: + *mut JSContext, + obj: + HandleObject, + index: + u32, + foundp: + *mut u8) + -> u8; + fn _Z13JS_HasElementP9JSContextN2JS6HandleIP8JSObjectEEjPb(cx: + *mut JSContext, + obj: + HandleObject, + index: u32, + foundp: + *mut u8) + -> u8; + fn _Z13JS_GetElementP9JSContextN2JS6HandleIP8JSObjectEEjNS1_13MutableHandleINS1_5ValueEEE(cx: + *mut JSContext, + obj: + HandleObject, + index: + u32, + vp: + MutableHandleValue) + -> u8; + fn _Z22JS_ForwardGetElementToP9JSContextN2JS6HandleIP8JSObjectEEjS5_NS1_13MutableHandleINS1_5ValueEEE(cx: + *mut JSContext, + obj: + HandleObject, + index: + u32, + onBehalfOf: + HandleObject, + vp: + MutableHandleValue) + -> u8; + fn _Z13JS_SetElementP9JSContextN2JS6HandleIP8JSObjectEEjNS2_INS1_5ValueEEE(cx: + *mut JSContext, + obj: + HandleObject, + index: + u32, + v: + HandleValue) + -> u8; + fn _Z13JS_SetElementP9JSContextN2JS6HandleIP8JSObjectEEjS5_(cx: + *mut JSContext, + obj: + HandleObject, + index: u32, + v: + HandleObject) + -> u8; + fn _Z13JS_SetElementP9JSContextN2JS6HandleIP8JSObjectEEjNS2_IP8JSStringEE(cx: + *mut JSContext, + obj: + HandleObject, + index: + u32, + v: + HandleString) + -> u8; + fn _Z13JS_SetElementP9JSContextN2JS6HandleIP8JSObjectEEji(cx: + *mut JSContext, + obj: + HandleObject, + index: u32, + v: i32) -> u8; + fn _Z13JS_SetElementP9JSContextN2JS6HandleIP8JSObjectEEjj(cx: + *mut JSContext, + obj: + HandleObject, + index: u32, + v: u32) -> u8; + fn _Z13JS_SetElementP9JSContextN2JS6HandleIP8JSObjectEEjd(cx: + *mut JSContext, + obj: + HandleObject, + index: u32, + v: f64) -> u8; + fn _Z16JS_DeleteElementP9JSContextN2JS6HandleIP8JSObjectEEj(cx: + *mut JSContext, + obj: + HandleObject, + index: u32) + -> u8; + fn _Z16JS_DeleteElementP9JSContextN2JS6HandleIP8JSObjectEEjRNS1_14ObjectOpResultE(cx: + *mut JSContext, + obj: + HandleObject, + index: + u32, + result: + *mut ObjectOpResult) + -> u8; + fn _Z36JS_SetAllNonReservedSlotsToUndefinedP9JSContextP8JSObject(cx: + *mut JSContext, + objArg: + *mut JSObject); + fn _Z29JS_NewArrayBufferWithContentsP9JSContextjPv(cx: *mut JSContext, + nbytes: u32, + contents: + *mut ::libc::c_void) + -> *mut JSObject; + fn _Z27JS_StealArrayBufferContentsP9JSContextN2JS6HandleIP8JSObjectEE(cx: + *mut JSContext, + obj: + HandleObject) + -> *mut ::libc::c_void; + fn _Z35JS_NewMappedArrayBufferWithContentsP9JSContextjPv(cx: + *mut JSContext, + nbytes: u32, + contents: + *mut ::libc::c_void) + -> *mut JSObject; + fn _Z34JS_CreateMappedArrayBufferContentsijj(fd: i32, offset: u32, + length: u32) + -> *mut ::libc::c_void; + fn _Z35JS_ReleaseMappedArrayBufferContentsPvj(contents: + *mut ::libc::c_void, + length: u32); + fn _Z12JS_EnumerateP9JSContextN2JS6HandleIP8JSObjectEE(cx: *mut JSContext, + obj: HandleObject) + -> *mut JSIdArray; + fn _Z18JS_GetReservedSlotP8JSObjectj(obj: *mut JSObject, index: u32) + -> Value; + fn _Z18JS_SetReservedSlotP8JSObjectjN2JS5ValueE(obj: *mut JSObject, + index: u32, v: Value); + fn _Z14JS_NewFunctionP9JSContextPFbS0_jPN2JS5ValueEEjjPKc(cx: + *mut JSContext, + call: JSNative, + nargs: u32, + flags: u32, + name: *const i8) + -> *mut JSFunction; + fn _Z18JS_NewFunctionByIdP9JSContextPFbS0_jPN2JS5ValueEEjjNS1_6HandleI4jsidEE(cx: + *mut JSContext, + call: + JSNative, + nargs: + u32, + flags: + u32, + id: + Handle) + -> *mut JSFunction; + fn _ZN2JS21GetSelfHostedFunctionEP9JSContextPKcNS_6HandleI4jsidEEj(cx: + *mut JSContext, + selfHostedName: + *const i8, + id: + Handle, + nargs: + u32) + -> *mut JSFunction; + fn _Z20JS_GetFunctionObjectP10JSFunction(fun: *mut JSFunction) + -> *mut JSObject; + fn _Z16JS_GetFunctionIdP10JSFunction(fun: *mut JSFunction) + -> *mut JSString; + fn _Z23JS_GetFunctionDisplayIdP10JSFunction(fun: *mut JSFunction) + -> *mut JSString; + fn _Z19JS_GetFunctionArityP10JSFunction(fun: *mut JSFunction) -> u16; + fn _ZN2JS10IsCallableEP8JSObject(obj: *mut JSObject) -> u8; + fn _ZN2JS13IsConstructorEP8JSObject(obj: *mut JSObject) -> u8; + fn _Z19JS_ObjectIsFunctionP9JSContextP8JSObject(cx: *mut JSContext, + obj: *mut JSObject) -> u8; + fn _Z19JS_IsNativeFunctionP8JSObjectPFbP9JSContextjPN2JS5ValueEE(funobj: + *mut JSObject, + call: + JSNative) + -> u8; + fn _Z16JS_IsConstructorP10JSFunction(fun: *mut JSFunction) -> u8; + fn _Z15JS_BindCallableP9JSContextN2JS6HandleIP8JSObjectEES5_(cx: + *mut JSContext, + callable: + Handle<*mut JSObject>, + newThis: + Handle<*mut JSObject>) + -> *mut JSObject; + fn _Z18JS_DefineFunctionsP9JSContextN2JS6HandleIP8JSObjectEEPK14JSFunctionSpec26PropertyDefinitionBehavior(cx: + *mut JSContext, + obj: + Handle<*mut JSObject>, + fs: + *const JSFunctionSpec, + behavior: + PropertyDefinitionBehavior) + -> u8; + fn _Z17JS_DefineFunctionP9JSContextN2JS6HandleIP8JSObjectEEPKcPFbS0_jPNS1_5ValueEEjj(cx: + *mut JSContext, + obj: + Handle<*mut JSObject>, + name: + *const i8, + call: + JSNative, + nargs: + u32, + attrs: + u32) + -> *mut JSFunction; + fn _Z19JS_DefineUCFunctionP9JSContextN2JS6HandleIP8JSObjectEEPKDsjPFbS0_jPNS1_5ValueEEjj(cx: + *mut JSContext, + obj: + Handle<*mut JSObject>, + name: + *const i16, + namelen: + u32, + call: + JSNative, + nargs: + u32, + attrs: + u32) + -> *mut JSFunction; + fn _Z21JS_DefineFunctionByIdP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEEPFbS0_jPNS1_5ValueEEjj(cx: + *mut JSContext, + obj: + Handle<*mut JSObject>, + id: + Handle, + call: + JSNative, + nargs: + u32, + attrs: + u32) + -> *mut JSFunction; + fn _ZN2JS19CloneFunctionObjectEP9JSContextNS_6HandleIP8JSObjectEE(cx: + *mut JSContext, + funobj: + HandleObject) + -> *mut JSObject; + fn _ZN2JS19CloneFunctionObjectEP9JSContextNS_6HandleIP8JSObjectEERNS_16AutoObjectVectorE(cx: + *mut JSContext, + funobj: + HandleObject, + scopeChain: + *mut AutoObjectVector) + -> *mut JSObject; + fn _Z25JS_BufferIsCompilableUnitP9JSContextN2JS6HandleIP8JSObjectEEPKcj(cx: + *mut JSContext, + obj: + Handle<*mut JSObject>, + utf8: + *const i8, + length: + u32) + -> u8; + fn _Z16JS_CompileScriptP9JSContextPKcjRKN2JS14CompileOptionsENS3_13MutableHandleIP8JSScriptEE(cx: + *mut JSContext, + ascii: + *const i8, + length: + u32, + options: + *const CompileOptions, + script: + MutableHandleScript) + -> u8; + fn _Z18JS_CompileUCScriptP9JSContextPKDsjRKN2JS14CompileOptionsENS3_13MutableHandleIP8JSScriptEE(cx: + *mut JSContext, + chars: + *const i16, + length: + u32, + options: + *const CompileOptions, + script: + MutableHandleScript) + -> u8; + fn _Z22JS_GetGlobalFromScriptP8JSScript(script: *mut JSScript) + -> *mut JSObject; + fn _Z20JS_GetScriptFilenameP8JSScript(script: *mut JSScript) -> *const i8; + fn _Z26JS_GetScriptBaseLineNumberP9JSContextP8JSScript(cx: *mut JSContext, + script: + *mut JSScript) + -> u32; + fn _Z20JS_GetFunctionScriptP9JSContextN2JS6HandleIP10JSFunctionEE(cx: + *mut JSContext, + fun: + HandleFunction) + -> *mut JSScript; + fn _ZN2JS7CompileEP9JSContextRKNS_22ReadOnlyCompileOptionsERNS_18SourceBufferHolderENS_13MutableHandleIP8JSScriptEE(cx: + *mut JSContext, + options: + *const ReadOnlyCompileOptions, + srcBuf: + *mut SourceBufferHolder, + script: + MutableHandleScript) + -> u8; + fn _ZN2JS7CompileEP9JSContextRKNS_22ReadOnlyCompileOptionsEPKcjNS_13MutableHandleIP8JSScriptEE(cx: + *mut JSContext, + options: + *const ReadOnlyCompileOptions, + bytes: + *const i8, + length: + u32, + script: + MutableHandleScript) + -> u8; + fn _ZN2JS7CompileEP9JSContextRKNS_22ReadOnlyCompileOptionsEPKDsjNS_13MutableHandleIP8JSScriptEE(cx: + *mut JSContext, + options: + *const ReadOnlyCompileOptions, + chars: + *const i16, + length: + u32, + script: + MutableHandleScript) + -> u8; + fn _ZN2JS7CompileEP9JSContextRKNS_22ReadOnlyCompileOptionsEP8_IO_FILENS_13MutableHandleIP8JSScriptEE(cx: + *mut JSContext, + options: + *const ReadOnlyCompileOptions, + file: + *mut FILE, + script: + MutableHandleScript) + -> u8; + fn _ZN2JS7CompileEP9JSContextRKNS_22ReadOnlyCompileOptionsEPKcNS_13MutableHandleIP8JSScriptEE(cx: + *mut JSContext, + options: + *const ReadOnlyCompileOptions, + filename: + *const i8, + script: + MutableHandleScript) + -> u8; + fn _ZN2JS19CanCompileOffThreadEP9JSContextRKNS_22ReadOnlyCompileOptionsEj(cx: + *mut JSContext, + options: + *const ReadOnlyCompileOptions, + length: + u32) + -> u8; + fn _ZN2JS16CompileOffThreadEP9JSContextRKNS_22ReadOnlyCompileOptionsEPKDsjPFvPvS7_ES7_(cx: + *mut JSContext, + options: + *const ReadOnlyCompileOptions, + chars: + *const i16, + length: + u32, + callback: + OffThreadCompileCallback, + callbackData: + *mut ::libc::c_void) + -> u8; + fn _ZN2JS21FinishOffThreadScriptEP9JSContextP9JSRuntimePv(maybecx: + *mut JSContext, + rt: + *mut JSRuntime, + token: + *mut ::libc::c_void) + -> *mut JSScript; + #[cfg(target_pointer_width = "64")] + fn _ZN2JS15CompileFunctionEP9JSContextRNS_16AutoObjectVectorERKNS_22ReadOnlyCompileOptionsEPKcjPKS8_PKDsmNS_13MutableHandleIP10JSFunctionEE(cx: + *mut JSContext, + scopeChain: + *mut AutoObjectVector, + options: + *const ReadOnlyCompileOptions, + name: + *const i8, + nargs: + u32, + argnames: + *const *const i8, + chars: + *const i16, + length: + ::libc::size_t, + fun: + MutableHandleFunction) + -> u8; + #[cfg(target_pointer_width = "32")] + fn _ZN2JS15CompileFunctionEP9JSContextRNS_16AutoObjectVectorERKNS_22ReadOnlyCompileOptionsEPKcjPKS8_PKDsjNS_13MutableHandleIP10JSFunctionEE(cx: + *mut JSContext, + scopeChain: + *mut AutoObjectVector, + options: + *const ReadOnlyCompileOptions, + name: + *const i8, + nargs: + u32, + argnames: + *const *const i8, + chars: + *const i16, + length: + ::libc::size_t, + fun: + MutableHandleFunction) + -> u8; + fn _ZN2JS15CompileFunctionEP9JSContextRNS_16AutoObjectVectorERKNS_22ReadOnlyCompileOptionsEPKcjPKS8_RNS_18SourceBufferHolderENS_13MutableHandleIP10JSFunctionEE(cx: + *mut JSContext, + scopeChain: + *mut AutoObjectVector, + options: + *const ReadOnlyCompileOptions, + name: + *const i8, + nargs: + u32, + argnames: + *const *const i8, + srcBuf: + *mut SourceBufferHolder, + fun: + MutableHandleFunction) + -> u8; + fn _ZN2JS15CompileFunctionEP9JSContextRNS_16AutoObjectVectorERKNS_22ReadOnlyCompileOptionsEPKcjPKS8_S8_jNS_13MutableHandleIP10JSFunctionEE(cx: + *mut JSContext, + scopeChain: + *mut AutoObjectVector, + options: + *const ReadOnlyCompileOptions, + name: + *const i8, + nargs: + u32, + argnames: + *const *const i8, + bytes: + *const i8, + length: + u32, + fun: + MutableHandleFunction) + -> u8; + fn _Z18JS_DecompileScriptP9JSContextN2JS6HandleIP8JSScriptEEPKcj(cx: + *mut JSContext, + script: + Handle<*mut JSScript>, + name: + *const i8, + indent: + u32) + -> *mut JSString; + fn _Z20JS_DecompileFunctionP9JSContextN2JS6HandleIP10JSFunctionEEj(cx: + *mut JSContext, + fun: + Handle<*mut JSFunction>, + indent: + u32) + -> *mut JSString; + fn _Z24JS_DecompileFunctionBodyP9JSContextN2JS6HandleIP10JSFunctionEEj(cx: + *mut JSContext, + fun: + Handle<*mut JSFunction>, + indent: + u32) + -> *mut JSString; + fn _Z16JS_ExecuteScriptP9JSContextN2JS6HandleIP8JSScriptEENS1_13MutableHandleINS1_5ValueEEE(cx: + *mut JSContext, + script: + HandleScript, + rval: + MutableHandleValue) + -> u8; + fn _Z16JS_ExecuteScriptP9JSContextN2JS6HandleIP8JSScriptEE(cx: + *mut JSContext, + script: + HandleScript) + -> u8; + fn _Z16JS_ExecuteScriptP9JSContextRN2JS16AutoObjectVectorENS1_6HandleIP8JSScriptEENS1_13MutableHandleINS1_5ValueEEE(cx: + *mut JSContext, + scopeChain: + *mut AutoObjectVector, + script: + HandleScript, + rval: + MutableHandleValue) + -> u8; + fn _Z16JS_ExecuteScriptP9JSContextRN2JS16AutoObjectVectorENS1_6HandleIP8JSScriptEE(cx: + *mut JSContext, + scopeChain: + *mut AutoObjectVector, + script: + HandleScript) + -> u8; + fn _ZN2JS21CloneAndExecuteScriptEP9JSContextNS_6HandleIP8JSScriptEE(cx: + *mut JSContext, + script: + Handle<*mut JSScript>) + -> u8; + fn _ZN2JS8EvaluateEP9JSContextRKNS_22ReadOnlyCompileOptionsERNS_18SourceBufferHolderENS_13MutableHandleINS_5ValueEEE(cx: + *mut JSContext, + options: + *const ReadOnlyCompileOptions, + srcBuf: + *mut SourceBufferHolder, + rval: + MutableHandleValue) + -> u8; + fn _ZN2JS8EvaluateEP9JSContextRNS_16AutoObjectVectorERKNS_22ReadOnlyCompileOptionsERNS_18SourceBufferHolderENS_13MutableHandleINS_5ValueEEE(cx: + *mut JSContext, + scopeChain: + *mut AutoObjectVector, + options: + *const ReadOnlyCompileOptions, + srcBuf: + *mut SourceBufferHolder, + rval: + MutableHandleValue) + -> u8; + #[cfg(target_pointer_width = "64")] + fn _ZN2JS8EvaluateEP9JSContextRKNS_22ReadOnlyCompileOptionsEPKDsmNS_13MutableHandleINS_5ValueEEE(cx: + *mut JSContext, + options: + *const ReadOnlyCompileOptions, + chars: + *const i16, + length: + ::libc::size_t, + rval: + MutableHandleValue) + -> u8; + #[cfg(target_pointer_width = "32")] + fn _ZN2JS8EvaluateEP9JSContextRKNS_22ReadOnlyCompileOptionsEPKDsjNS_13MutableHandleINS_5ValueEEE(cx: + *mut JSContext, + options: + *const ReadOnlyCompileOptions, + chars: + *const i16, + length: + ::libc::size_t, + rval: + MutableHandleValue) + -> u8; + #[cfg(target_pointer_width = "64")] + fn _ZN2JS8EvaluateEP9JSContextRNS_16AutoObjectVectorERKNS_22ReadOnlyCompileOptionsEPKDsmNS_13MutableHandleINS_5ValueEEE(cx: + *mut JSContext, + scopeChain: + *mut AutoObjectVector, + options: + *const ReadOnlyCompileOptions, + chars: + *const i16, + length: + ::libc::size_t, + rval: + MutableHandleValue) + -> u8; + #[cfg(target_pointer_width = "32")] + fn _ZN2JS8EvaluateEP9JSContextRNS_16AutoObjectVectorERKNS_22ReadOnlyCompileOptionsEPKDsjNS_13MutableHandleINS_5ValueEEE(cx: + *mut JSContext, + scopeChain: + *mut AutoObjectVector, + options: + *const ReadOnlyCompileOptions, + chars: + *const i16, + length: + ::libc::size_t, + rval: + MutableHandleValue) + -> u8; + fn _ZN2JS8EvaluateEP9JSContextRKNS_22ReadOnlyCompileOptionsEPKcjNS_13MutableHandleINS_5ValueEEE(cx: + *mut JSContext, + options: + *const ReadOnlyCompileOptions, + bytes: + *const i8, + length: + u32, + rval: + MutableHandleValue) + -> u8; + fn _ZN2JS8EvaluateEP9JSContextRKNS_22ReadOnlyCompileOptionsEPKcNS_13MutableHandleINS_5ValueEEE(cx: + *mut JSContext, + options: + *const ReadOnlyCompileOptions, + filename: + *const i8, + rval: + MutableHandleValue) + -> u8; + fn _Z15JS_CallFunctionP9JSContextN2JS6HandleIP8JSObjectEENS2_IP10JSFunctionEERKNS1_16HandleValueArrayENS1_13MutableHandleINS1_5ValueEEE(cx: + *mut JSContext, + obj: + HandleObject, + fun: + HandleFunction, + args: + *const HandleValueArray, + rval: + MutableHandleValue) + -> u8; + fn _Z19JS_CallFunctionNameP9JSContextN2JS6HandleIP8JSObjectEEPKcRKNS1_16HandleValueArrayENS1_13MutableHandleINS1_5ValueEEE(cx: + *mut JSContext, + obj: + HandleObject, + name: + *const i8, + args: + *const HandleValueArray, + rval: + MutableHandleValue) + -> u8; + fn _Z20JS_CallFunctionValueP9JSContextN2JS6HandleIP8JSObjectEENS2_INS1_5ValueEEERKNS1_16HandleValueArrayENS1_13MutableHandleIS6_EE(cx: + *mut JSContext, + obj: + HandleObject, + fval: + HandleValue, + args: + *const HandleValueArray, + rval: + MutableHandleValue) + -> u8; + fn _ZN2JS4CallEP9JSContextNS_6HandleINS_5ValueEEES4_RKNS_16HandleValueArrayENS_13MutableHandleIS3_EE(cx: + *mut JSContext, + thisv: + HandleValue, + fun: + HandleValue, + args: + *const HandleValueArray, + rval: + MutableHandleValue) + -> u8; + fn _ZN2JS9ConstructEP9JSContextNS_6HandleINS_5ValueEEERKNS_16HandleValueArrayENS_13MutableHandleIS3_EE(cx: + *mut JSContext, + fun: + HandleValue, + args: + *const HandleValueArray, + rval: + MutableHandleValue) + -> u8; + fn _Z23JS_SetInterruptCallbackP9JSRuntimePFbP9JSContextE(rt: + *mut JSRuntime, + callback: + JSInterruptCallback) + -> JSInterruptCallback; + fn _Z23JS_GetInterruptCallbackP9JSRuntime(rt: *mut JSRuntime) + -> JSInterruptCallback; + fn _Z27JS_RequestInterruptCallbackP9JSRuntime(rt: *mut JSRuntime); + fn _Z12JS_IsRunningP9JSContext(cx: *mut JSContext) -> u8; + fn _Z17JS_SaveFrameChainP9JSContext(cx: *mut JSContext) -> u8; + fn _Z20JS_RestoreFrameChainP9JSContext(cx: *mut JSContext); + #[cfg(target_pointer_width = "64")] + fn _Z17JS_NewStringCopyNP9JSContextPKcm(cx: *mut JSContext, s: *const i8, + n: ::libc::size_t) -> *mut JSString; + #[cfg(target_pointer_width = "32")] + fn _Z17JS_NewStringCopyNP9JSContextPKcj(cx: *mut JSContext, s: *const i8, + n: ::libc::size_t) -> *mut JSString; + fn _Z17JS_NewStringCopyZP9JSContextPKc(cx: *mut JSContext, s: *const i8) + -> *mut JSString; + fn _Z17JS_InternJSStringP9JSContextN2JS6HandleIP8JSStringEE(cx: + *mut JSContext, + str: + HandleString) + -> *mut JSString; + fn _Z16JS_InternStringNP9JSContextPKcj(cx: *mut JSContext, s: *const i8, + length: u32) -> *mut JSString; + fn _Z15JS_InternStringP9JSContextPKc(cx: *mut JSContext, s: *const i8) + -> *mut JSString; + fn _Z14JS_NewUCStringP9JSContextPDsj(cx: *mut JSContext, chars: *mut i16, + length: u32) -> *mut JSString; + #[cfg(target_pointer_width = "64")] + fn _Z19JS_NewUCStringCopyNP9JSContextPKDsm(cx: *mut JSContext, + s: *const i16, n: ::libc::size_t) + -> *mut JSString; + #[cfg(target_pointer_width = "32")] + fn _Z19JS_NewUCStringCopyNP9JSContextPKDsj(cx: *mut JSContext, + s: *const i16, n: ::libc::size_t) + -> *mut JSString; + fn _Z19JS_NewUCStringCopyZP9JSContextPKDs(cx: *mut JSContext, + s: *const i16) -> *mut JSString; + fn _Z18JS_InternUCStringNP9JSContextPKDsj(cx: *mut JSContext, + s: *const i16, length: u32) + -> *mut JSString; + fn _Z17JS_InternUCStringP9JSContextPKDs(cx: *mut JSContext, s: *const i16) + -> *mut JSString; + fn _Z17JS_CompareStringsP9JSContextP8JSStringS2_Pi(cx: *mut JSContext, + str1: *mut JSString, + str2: *mut JSString, + result: *mut i32) + -> u8; + fn _Z20JS_StringEqualsAsciiP9JSContextP8JSStringPKcPb(cx: *mut JSContext, + str: *mut JSString, + asciiBytes: + *const i8, + _match: *mut u8) + -> u8; + fn _Z19JS_PutEscapedStringP9JSContextPcjP8JSStringc(cx: *mut JSContext, + buffer: *mut i8, + size: u32, + str: *mut JSString, + quote: i8) -> u32; + fn _Z20JS_FileEscapedStringP8_IO_FILEP8JSStringc(fp: *mut FILE, + str: *mut JSString, + quote: i8) -> u8; + fn _Z18JS_GetStringLengthP8JSString(str: *mut JSString) -> u32; + fn _Z15JS_StringIsFlatP8JSString(str: *mut JSString) -> u8; + fn _Z23JS_StringHasLatin1CharsP8JSString(str: *mut JSString) -> u8; + #[cfg(target_pointer_width = "64")] + fn _Z32JS_GetLatin1StringCharsAndLengthP9JSContextRKN2JS17AutoCheckCannotGCEP8JSStringPm(cx: + *mut JSContext, + nogc: + *const AutoCheckCannotGC, + str: + *mut JSString, + length: + *mut ::libc::size_t) + -> *const Latin1Char; + #[cfg(target_pointer_width = "32")] + fn _Z32JS_GetLatin1StringCharsAndLengthP9JSContextRKN2JS17AutoCheckCannotGCEP8JSStringPj(cx: + *mut JSContext, + nogc: + *const AutoCheckCannotGC, + str: + *mut JSString, + length: + *mut ::libc::size_t) + -> *const Latin1Char; + #[cfg(target_pointer_width = "64")] + fn _Z33JS_GetTwoByteStringCharsAndLengthP9JSContextRKN2JS17AutoCheckCannotGCEP8JSStringPm(cx: + *mut JSContext, + nogc: + *const AutoCheckCannotGC, + str: + *mut JSString, + length: + *mut ::libc::size_t) + -> *const i16; + #[cfg(target_pointer_width = "32")] + fn _Z33JS_GetTwoByteStringCharsAndLengthP9JSContextRKN2JS17AutoCheckCannotGCEP8JSStringPj(cx: + *mut JSContext, + nogc: + *const AutoCheckCannotGC, + str: + *mut JSString, + length: + *mut ::libc::size_t) + -> *const i16; + fn _Z18JS_GetStringCharAtP9JSContextP8JSStringjPDs(cx: *mut JSContext, + str: *mut JSString, + index: u32, + res: *mut i16) -> u8; + fn _Z22JS_GetFlatStringCharAtP12JSFlatStringj(str: *mut JSFlatString, + index: u32) -> i16; + fn _Z32JS_GetTwoByteExternalStringCharsP8JSString(str: *mut JSString) + -> *const i16; + fn _Z18JS_CopyStringCharsP9JSContextN7mozilla5RangeIDsEEP8JSString(cx: + *mut JSContext, + dest: + Range, + str: + *mut JSString) + -> u8; + fn _Z31JS_GetLatin1InternedStringCharsRKN2JS17AutoCheckCannotGCEP8JSString(nogc: + *const AutoCheckCannotGC, + str: + *mut JSString) + -> *const Latin1Char; + fn _Z32JS_GetTwoByteInternedStringCharsRKN2JS17AutoCheckCannotGCEP8JSString(nogc: + *const AutoCheckCannotGC, + str: + *mut JSString) + -> *const i16; + fn _Z16JS_FlattenStringP9JSContextP8JSString(cx: *mut JSContext, + str: *mut JSString) + -> *mut JSFlatString; + fn _Z27JS_GetLatin1FlatStringCharsRKN2JS17AutoCheckCannotGCEP12JSFlatString(nogc: + *const AutoCheckCannotGC, + str: + *mut JSFlatString) + -> *const Latin1Char; + fn _Z28JS_GetTwoByteFlatStringCharsRKN2JS17AutoCheckCannotGCEP12JSFlatString(nogc: + *const AutoCheckCannotGC, + str: + *mut JSFlatString) + -> *const i16; + fn _Z24JS_FlatStringEqualsAsciiP12JSFlatStringPKc(str: *mut JSFlatString, + asciiBytes: *const i8) + -> u8; + fn _Z23JS_PutEscapedFlatStringPcjP12JSFlatStringc(buffer: *mut i8, + size: u32, + str: *mut JSFlatString, + quote: i8) -> u32; + fn _Z21JS_NewDependentStringP9JSContextN2JS6HandleIP8JSStringEEjj(cx: + *mut JSContext, + str: + HandleString, + start: + u32, + length: + u32) + -> *mut JSString; + fn _Z16JS_ConcatStringsP9JSContextN2JS6HandleIP8JSStringEES5_(cx: + *mut JSContext, + left: + HandleString, + right: + HandleString) + -> *mut JSString; + fn _Z14JS_DecodeBytesP9JSContextPKcjPDsPj(cx: *mut JSContext, + src: *const i8, srclen: u32, + dst: *mut i16, + dstlenp: *mut u32) -> u8; + fn _Z15JS_EncodeStringP9JSContextP8JSString(cx: *mut JSContext, + str: *mut JSString) + -> *mut i8; + fn _Z21JS_EncodeStringToUTF8P9JSContextN2JS6HandleIP8JSStringEE(cx: + *mut JSContext, + str: + HandleString) + -> *mut i8; + fn _Z26JS_GetStringEncodingLengthP9JSContextP8JSString(cx: *mut JSContext, + str: *mut JSString) + -> u32; + fn _Z23JS_EncodeStringToBufferP9JSContextP8JSStringPcj(cx: *mut JSContext, + str: *mut JSString, + buffer: *mut i8, + length: u32) + -> u32; + fn _ZN2JS10NewAddonIdEP9JSContextNS_6HandleIP8JSStringEE(cx: + *mut JSContext, + str: + HandleString) + -> *mut JSAddonId; + fn _ZN2JS15StringOfAddonIdEP9JSAddonId(id: *mut JSAddonId) + -> *mut JSString; + fn _ZN2JS15AddonIdOfObjectEP8JSObject(obj: *mut JSObject) + -> *mut JSAddonId; + fn _ZN2JS9NewSymbolEP9JSContextNS_6HandleIP8JSStringEE(cx: *mut JSContext, + description: + HandleString) + -> *mut Symbol; + fn _ZN2JS12GetSymbolForEP9JSContextNS_6HandleIP8JSStringEE(cx: + *mut JSContext, + key: + HandleString) + -> *mut Symbol; + fn _ZN2JS20GetSymbolDescriptionENS_6HandleIPNS_6SymbolEEE(symbol: + HandleSymbol) + -> *mut JSString; + fn _ZN2JS13GetSymbolCodeENS_6HandleIPNS_6SymbolEEE(symbol: + Handle<*mut Symbol>) + -> SymbolCode; + fn _ZN2JS18GetWellKnownSymbolEP9JSContextNS_10SymbolCodeE(cx: + *mut JSContext, + which: + SymbolCode) + -> *mut Symbol; + fn _ZN2JS24PropertySpecNameIsSymbolEPKc(name: *const i8) -> u8; + fn _ZN2JS24PropertySpecNameEqualsIdEPKcNS_6HandleI4jsidEE(name: *const i8, + id: HandleId) + -> u8; + fn _ZN2JS29PropertySpecNameToPermanentIdEP9JSContextPKcP4jsid(cx: + *mut JSContext, + name: + *const i8, + idp: + *mut jsid) + -> u8; + fn _Z12JS_StringifyP9JSContextN2JS13MutableHandleINS1_5ValueEEENS1_6HandleIP8JSObjectEENS5_IS3_EEPFbPKDsjPvESC_(cx: + *mut JSContext, + value: + MutableHandleValue, + replacer: + HandleObject, + space: + HandleValue, + callback: + JSONWriteCallback, + data: + *mut ::libc::c_void) + -> u8; + fn _Z12JS_ParseJSONP9JSContextPKDsjN2JS13MutableHandleINS3_5ValueEEE(cx: + *mut JSContext, + chars: + *const i16, + len: + u32, + vp: + MutableHandleValue) + -> u8; + fn _Z12JS_ParseJSONP9JSContextN2JS6HandleIP8JSStringEENS1_13MutableHandleINS1_5ValueEEE(cx: + *mut JSContext, + str: + HandleString, + vp: + MutableHandleValue) + -> u8; + fn _Z23JS_ParseJSONWithReviverP9JSContextPKDsjN2JS6HandleINS3_5ValueEEENS3_13MutableHandleIS5_EE(cx: + *mut JSContext, + chars: + *const i16, + len: + u32, + reviver: + HandleValue, + vp: + MutableHandleValue) + -> u8; + fn _Z23JS_ParseJSONWithReviverP9JSContextN2JS6HandleIP8JSStringEENS2_INS1_5ValueEEENS1_13MutableHandleIS6_EE(cx: + *mut JSContext, + str: + HandleString, + reviver: + HandleValue, + vp: + MutableHandleValue) + -> u8; + fn _Z19JS_SetDefaultLocaleP9JSRuntimePKc(rt: *mut JSRuntime, + locale: *const i8) -> u8; + fn _Z21JS_ResetDefaultLocaleP9JSRuntime(rt: *mut JSRuntime); + fn _Z21JS_SetLocaleCallbacksP9JSRuntimePK17JSLocaleCallbacks(rt: + *mut JSRuntime, + callbacks: + *const JSLocaleCallbacks); + fn _Z21JS_GetLocaleCallbacksP9JSRuntime(rt: *mut JSRuntime) + -> *const JSLocaleCallbacks; + fn _Z14JS_ReportErrorP9JSContextPKcz(cx: *mut JSContext, + format: *const i8, ...); + fn _Z20JS_ReportErrorNumberP9JSContextPFPK19JSErrorFormatStringPvjES4_jz(cx: + *mut JSContext, + errorCallback: + JSErrorCallback, + userRef: + *mut ::libc::c_void, + errorNumber: + u32, ...); + fn _Z22JS_ReportErrorNumberVAP9JSContextPFPK19JSErrorFormatStringPvjES4_jPc(cx: + *mut JSContext, + errorCallback: + JSErrorCallback, + userRef: + *mut ::libc::c_void, + errorNumber: + u32, + ap: + va_list); + fn _Z22JS_ReportErrorNumberUCP9JSContextPFPK19JSErrorFormatStringPvjES4_jz(cx: + *mut JSContext, + errorCallback: + JSErrorCallback, + userRef: + *mut ::libc::c_void, + errorNumber: + u32, ...); + fn _Z27JS_ReportErrorNumberUCArrayP9JSContextPFPK19JSErrorFormatStringPvjES4_jPPKDs(cx: + *mut JSContext, + errorCallback: + JSErrorCallback, + userRef: + *mut ::libc::c_void, + errorNumber: + u32, + args: + *mut *const i16); + fn _Z16JS_ReportWarningP9JSContextPKcz(cx: *mut JSContext, + format: *const i8, ...) -> u8; + fn _Z28JS_ReportErrorFlagsAndNumberP9JSContextjPFPK19JSErrorFormatStringPvjES4_jz(cx: + *mut JSContext, + flags: + u32, + errorCallback: + JSErrorCallback, + userRef: + *mut ::libc::c_void, + errorNumber: + u32, ...) + -> u8; + fn _Z30JS_ReportErrorFlagsAndNumberUCP9JSContextjPFPK19JSErrorFormatStringPvjES4_jz(cx: + *mut JSContext, + flags: + u32, + errorCallback: + JSErrorCallback, + userRef: + *mut ::libc::c_void, + errorNumber: + u32, ...) + -> u8; + fn _Z20JS_ReportOutOfMemoryP9JSContext(cx: *mut JSContext); + fn _Z27JS_ReportAllocationOverflowP9JSContext(cx: *mut JSContext); + fn _Z19JS_GetErrorReporterP9JSRuntime(rt: *mut JSRuntime) + -> JSErrorReporter; + fn _Z19JS_SetErrorReporterP9JSRuntimePFvP9JSContextPKcP13JSErrorReportE(rt: + *mut JSRuntime, + er: + JSErrorReporter) + -> JSErrorReporter; + fn _ZN2JS11CreateErrorEP9JSContext9JSExnTypeNS_6HandleIP8JSStringEES6_jjP13JSErrorReportS6_NS_13MutableHandleINS_5ValueEEE(cx: + *mut JSContext, + _type: + JSExnType, + stack: + HandleString, + fileName: + HandleString, + lineNumber: + u32, + columnNumber: + u32, + report: + *mut JSErrorReport, + message: + HandleString, + rval: + MutableHandleValue) + -> u8; + fn _ZN2JS16NewWeakMapObjectEP9JSContext(cx: *mut JSContext) + -> *mut JSObject; + fn _ZN2JS15IsWeakMapObjectEP8JSObject(obj: *mut JSObject) -> u8; + fn _ZN2JS15GetWeakMapEntryEP9JSContextNS_6HandleIP8JSObjectEES5_NS_13MutableHandleINS_5ValueEEE(cx: + *mut JSContext, + mapObj: + HandleObject, + key: + HandleObject, + val: + MutableHandleValue) + -> u8; + fn _ZN2JS15SetWeakMapEntryEP9JSContextNS_6HandleIP8JSObjectEES5_NS2_INS_5ValueEEE(cx: + *mut JSContext, + mapObj: + HandleObject, + key: + HandleObject, + val: + HandleValue) + -> u8; + fn _ZN2JS12NewMapObjectEP9JSContext(cx: *mut JSContext) -> *mut JSObject; + fn _ZN2JS7MapSizeEP9JSContextNS_6HandleIP8JSObjectEE(cx: *mut JSContext, + obj: HandleObject) + -> u32; + fn _ZN2JS6MapGetEP9JSContextNS_6HandleIP8JSObjectEENS2_INS_5ValueEEENS_13MutableHandleIS6_EE(cx: + *mut JSContext, + obj: + HandleObject, + key: + HandleValue, + rval: + MutableHandleValue) + -> u8; + fn _ZN2JS6MapHasEP9JSContextNS_6HandleIP8JSObjectEENS2_INS_5ValueEEEPb(cx: + *mut JSContext, + obj: + HandleObject, + key: + HandleValue, + rval: + *mut u8) + -> u8; + fn _ZN2JS6MapSetEP9JSContextNS_6HandleIP8JSObjectEENS2_INS_5ValueEEES7_(cx: + *mut JSContext, + obj: + HandleObject, + key: + HandleValue, + val: + HandleValue) + -> u8; + fn _ZN2JS8MapClearEP9JSContextNS_6HandleIP8JSObjectEE(cx: *mut JSContext, + obj: HandleObject) + -> u8; + fn _ZN2JS7MapKeysEP9JSContextNS_6HandleIP8JSObjectEENS_13MutableHandleINS_5ValueEEE(cx: + *mut JSContext, + obj: + HandleObject, + rval: + MutableHandleValue) + -> u8; + fn _ZN2JS9MapValuesEP9JSContextNS_6HandleIP8JSObjectEENS_13MutableHandleINS_5ValueEEE(cx: + *mut JSContext, + obj: + HandleObject, + rval: + MutableHandleValue) + -> u8; + fn _ZN2JS10MapEntriesEP9JSContextNS_6HandleIP8JSObjectEENS_13MutableHandleINS_5ValueEEE(cx: + *mut JSContext, + obj: + HandleObject, + rval: + MutableHandleValue) + -> u8; + fn _Z16JS_NewDateObjectP9JSContextiiiiii(cx: *mut JSContext, year: i32, + mon: i32, mday: i32, hour: i32, + min: i32, sec: i32) + -> *mut JSObject; + fn _Z20JS_NewDateObjectMsecP9JSContextd(cx: *mut JSContext, msec: f64) + -> *mut JSObject; + fn _Z15JS_ObjectIsDateP9JSContextN2JS6HandleIP8JSObjectEE(cx: + *mut JSContext, + obj: + HandleObject) + -> u8; + fn _Z18JS_ClearDateCachesP9JSContext(cx: *mut JSContext); + fn _Z18JS_NewRegExpObjectP9JSContextN2JS6HandleIP8JSObjectEEPKcjj(cx: + *mut JSContext, + obj: + HandleObject, + bytes: + *const i8, + length: + u32, + flags: + u32) + -> *mut JSObject; + fn _Z20JS_NewUCRegExpObjectP9JSContextN2JS6HandleIP8JSObjectEEPKDsjj(cx: + *mut JSContext, + obj: + HandleObject, + chars: + *const i16, + length: + u32, + flags: + u32) + -> *mut JSObject; + fn _Z17JS_SetRegExpInputP9JSContextN2JS6HandleIP8JSObjectEENS2_IP8JSStringEEb(cx: + *mut JSContext, + obj: + HandleObject, + input: + HandleString, + multiline: + u8) + -> u8; + fn _Z21JS_ClearRegExpStaticsP9JSContextN2JS6HandleIP8JSObjectEE(cx: + *mut JSContext, + obj: + HandleObject) + -> u8; + fn _Z16JS_ExecuteRegExpP9JSContextN2JS6HandleIP8JSObjectEES5_PDsjPjbNS1_13MutableHandleINS1_5ValueEEE(cx: + *mut JSContext, + obj: + HandleObject, + reobj: + HandleObject, + chars: + *mut i16, + length: + u32, + indexp: + *mut u32, + test: + u8, + rval: + MutableHandleValue) + -> u8; + fn _Z27JS_NewRegExpObjectNoStaticsP9JSContextPcjj(cx: *mut JSContext, + bytes: *mut i8, + length: u32, flags: u32) + -> *mut JSObject; + fn _Z29JS_NewUCRegExpObjectNoStaticsP9JSContextPDsjj(cx: *mut JSContext, + chars: *mut i16, + length: u32, + flags: u32) + -> *mut JSObject; + fn _Z25JS_ExecuteRegExpNoStaticsP9JSContextN2JS6HandleIP8JSObjectEEPDsjPjbNS1_13MutableHandleINS1_5ValueEEE(cx: + *mut JSContext, + reobj: + HandleObject, + chars: + *mut i16, + length: + u32, + indexp: + *mut u32, + test: + u8, + rval: + MutableHandleValue) + -> u8; + fn _Z17JS_ObjectIsRegExpP9JSContextN2JS6HandleIP8JSObjectEE(cx: + *mut JSContext, + obj: + HandleObject) + -> u8; + fn _Z17JS_GetRegExpFlagsP9JSContextN2JS6HandleIP8JSObjectEE(cx: + *mut JSContext, + obj: + HandleObject) + -> u32; + fn _Z18JS_GetRegExpSourceP9JSContextN2JS6HandleIP8JSObjectEE(cx: + *mut JSContext, + obj: + HandleObject) + -> *mut JSString; + fn _Z21JS_IsExceptionPendingP9JSContext(cx: *mut JSContext) -> u8; + fn _Z22JS_GetPendingExceptionP9JSContextN2JS13MutableHandleINS1_5ValueEEE(cx: + *mut JSContext, + vp: + MutableHandleValue) + -> u8; + fn _Z22JS_SetPendingExceptionP9JSContextN2JS6HandleINS1_5ValueEEE(cx: + *mut JSContext, + v: + HandleValue); + fn _Z24JS_ClearPendingExceptionP9JSContext(cx: *mut JSContext); + fn _Z25JS_ReportPendingExceptionP9JSContext(cx: *mut JSContext) -> u8; + fn _Z21JS_SaveExceptionStateP9JSContext(cx: *mut JSContext) + -> *mut JSExceptionState; + fn _Z24JS_RestoreExceptionStateP9JSContextP16JSExceptionState(cx: + *mut JSContext, + state: + *mut JSExceptionState); + fn _Z21JS_DropExceptionStateP9JSContextP16JSExceptionState(cx: + *mut JSContext, + state: + *mut JSExceptionState); + fn _Z21JS_ErrorFromExceptionP9JSContextN2JS6HandleIP8JSObjectEE(cx: + *mut JSContext, + obj: + HandleObject) + -> *mut JSErrorReport; + fn _Z21JS_ThrowStopIterationP9JSContext(cx: *mut JSContext) -> u8; + fn _Z18JS_IsStopIterationN2JS5ValueE(v: Value) -> u8; + fn _Z19JS_GetCurrentThreadv() -> i32; + fn _Z21JS_AbortIfWrongThreadP9JSRuntime(rt: *mut JSRuntime); + fn _Z26JS_NewObjectForConstructorP9JSContextPK7JSClassRKN2JS8CallArgsE(cx: + *mut JSContext, + clasp: + *const JSClass, + args: + *const CallArgs) + -> *mut JSObject; + fn _Z12JS_GetGCZealP9JSContextPhPjS2_(cx: *mut JSContext, zeal: *mut u8, + frequency: *mut u32, + nextScheduled: *mut u32); + fn _Z12JS_SetGCZealP9JSContexthj(cx: *mut JSContext, zeal: u8, + frequency: u32); + fn _Z13JS_ScheduleGCP9JSContextj(cx: *mut JSContext, count: u32); + fn _Z28JS_SetParallelParsingEnabledP9JSRuntimeb(rt: *mut JSRuntime, + enabled: u8); + fn _Z36JS_SetOffthreadIonCompilationEnabledP9JSRuntimeb(rt: + *mut JSRuntime, + enabled: u8); + fn _Z29JS_SetGlobalJitCompilerOptionP9JSRuntime19JSJitCompilerOptionj(rt: + *mut JSRuntime, + opt: + JSJitCompilerOption, + value: + u32); + fn _Z29JS_GetGlobalJitCompilerOptionP9JSRuntime19JSJitCompilerOption(rt: + *mut JSRuntime, + opt: + JSJitCompilerOption) + -> i32; + fn _Z12JS_IndexToIdP9JSContextjN2JS13MutableHandleI4jsidEE(cx: + *mut JSContext, + index: u32, + arg1: + MutableHandleId) + -> u8; + fn _Z12JS_CharsToIdP9JSContextN2JS12TwoByteCharsENS1_13MutableHandleI4jsidEE(cx: + *mut JSContext, + chars: + TwoByteChars, + arg1: + MutableHandleId) + -> u8; + fn _Z15JS_IsIdentifierP9JSContextN2JS6HandleIP8JSStringEEPb(cx: + *mut JSContext, + str: + HandleString, + isIdentifier: + *mut u8) + -> u8; + fn _Z15JS_IsIdentifierPKDsj(chars: *const i16, length: u32) -> u8; + fn _ZN2JS22DescribeScriptedCallerEP9JSContextPNS_12AutoFilenameEPj(cx: + *mut JSContext, + filename: + *mut AutoFilename, + lineno: + *mut u32) + -> u8; + fn _ZN2JS23GetScriptedCallerGlobalEP9JSContext(cx: *mut JSContext) + -> *mut JSObject; + fn _ZN2JS18HideScriptedCallerEP9JSContext(cx: *mut JSContext); + fn _ZN2JS20UnhideScriptedCallerEP9JSContext(cx: *mut JSContext); + fn _Z15JS_EncodeScriptP9JSContextN2JS6HandleIP8JSScriptEEPj(cx: + *mut JSContext, + script: + HandleScript, + lengthp: + *mut u32) + -> *mut ::libc::c_void; + fn _Z28JS_EncodeInterpretedFunctionP9JSContextN2JS6HandleIP8JSObjectEEPj(cx: + *mut JSContext, + funobj: + HandleObject, + lengthp: + *mut u32) + -> *mut ::libc::c_void; + fn _Z15JS_DecodeScriptP9JSContextPKvj(cx: *mut JSContext, + data: *const ::libc::c_void, + length: u32) -> *mut JSScript; + fn _Z28JS_DecodeInterpretedFunctionP9JSContextPKvj(cx: *mut JSContext, + data: + *const ::libc::c_void, + length: u32) + -> *mut JSObject; + fn _ZN2JS16SetAsmJSCacheOpsEP9JSRuntimePKNS_13AsmJSCacheOpsE(rt: + *mut JSRuntime, + callbacks: + *const AsmJSCacheOps); + fn _ZN2JS33SetLargeAllocationFailureCallbackEP9JSRuntimePFvPvES2_(rt: + *mut JSRuntime, + afc: + LargeAllocationFailureCallback, + data: + *mut ::libc::c_void); + fn _ZN2JS22SetOutOfMemoryCallbackEP9JSRuntimePFvP9JSContextPvES4_(rt: + *mut JSRuntime, + cb: + OutOfMemoryCallback, + data: + *mut ::libc::c_void); + fn _ZN2JS19CaptureCurrentStackEP9JSContextNS_13MutableHandleIP8JSObjectEEj(cx: + *mut JSContext, + stackp: + MutableHandleObject, + maxFrameCount: + u32) + -> u8; + fn _ZN2JS19GetSavedFrameSourceEP9JSContextNS_6HandleIP8JSObjectEENS_13MutableHandleIP8JSStringEE(cx: + *mut JSContext, + savedFrame: + HandleObject, + sourcep: + MutableHandleString) + -> SavedFrameResult; + fn _ZN2JS17GetSavedFrameLineEP9JSContextNS_6HandleIP8JSObjectEEPj(cx: + *mut JSContext, + savedFrame: + HandleObject, + linep: + *mut u32) + -> SavedFrameResult; + fn _ZN2JS19GetSavedFrameColumnEP9JSContextNS_6HandleIP8JSObjectEEPj(cx: + *mut JSContext, + savedFrame: + HandleObject, + columnp: + *mut u32) + -> SavedFrameResult; + fn _ZN2JS32GetSavedFrameFunctionDisplayNameEP9JSContextNS_6HandleIP8JSObjectEENS_13MutableHandleIP8JSStringEE(cx: + *mut JSContext, + savedFrame: + HandleObject, + namep: + MutableHandleString) + -> SavedFrameResult; + fn _ZN2JS23GetSavedFrameAsyncCauseEP9JSContextNS_6HandleIP8JSObjectEENS_13MutableHandleIP8JSStringEE(cx: + *mut JSContext, + savedFrame: + HandleObject, + asyncCausep: + MutableHandleString) + -> SavedFrameResult; + fn _ZN2JS24GetSavedFrameAsyncParentEP9JSContextNS_6HandleIP8JSObjectEENS_13MutableHandleIS4_EE(cx: + *mut JSContext, + savedFrame: + HandleObject, + asyncParentp: + MutableHandleObject) + -> SavedFrameResult; + fn _ZN2JS19GetSavedFrameParentEP9JSContextNS_6HandleIP8JSObjectEENS_13MutableHandleIS4_EE(cx: + *mut JSContext, + savedFrame: + HandleObject, + parentp: + MutableHandleObject) + -> SavedFrameResult; + fn _ZN2JS24StringifySavedFrameStackEP9JSContextNS_6HandleIP8JSObjectEENS_13MutableHandleIP8JSStringEE(cx: + *mut JSContext, + stack: + HandleObject, + stringp: + MutableHandleString) + -> u8; + fn _ZN2JS6detail19CallMethodIfWrappedEP9JSContextPFbNS_6HandleINS_5ValueEEEEPFbS2_NS_8CallArgsEES8_(cx: + *mut JSContext, + test: + IsAcceptableThis, + _impl: + NativeImpl, + args: + CallArgs) + -> u8; + fn _ZN2JS20CallNonGenericMethodEP9JSContextPFbNS_6HandleINS_5ValueEEEEPFbS1_NS_8CallArgsEES7_(cx: + *mut JSContext, + Test: + IsAcceptableThis, + Impl: + NativeImpl, + args: + CallArgs) + -> u8; + fn _Z23JS_SetGrayGCRootsTracerP9JSRuntimePFvP8JSTracerPvES3_(rt: + *mut JSRuntime, + traceOp: + JSTraceDataOp, + data: + *mut ::libc::c_void); + fn _Z21JS_GetAnonymousStringP9JSRuntime(rt: *mut JSRuntime) + -> *mut JSString; + fn _Z23JS_FindCompilationScopeP9JSContextN2JS6HandleIP8JSObjectEE(cx: + *mut JSContext, + obj: + HandleObject) + -> *mut JSObject; + fn _Z20JS_GetObjectFunctionP8JSObject(obj: *mut JSObject) + -> *mut JSFunction; + fn _Z18JS_SplicePrototypeP9JSContextN2JS6HandleIP8JSObjectEES5_(cx: + *mut JSContext, + obj: + HandleObject, + proto: + HandleObject) + -> u8; + fn _Z26JS_NewObjectWithUniqueTypeP9JSContextPK7JSClassN2JS6HandleIP8JSObjectEE(cx: + *mut JSContext, + clasp: + *const JSClass, + proto: + HandleObject) + -> *mut JSObject; + fn _Z27JS_NewObjectWithoutMetadataP9JSContextPK7JSClassN2JS6HandleIP8JSObjectEE(cx: + *mut JSContext, + clasp: + *const JSClass, + proto: + Handle<*mut JSObject>) + -> *mut JSObject; + fn _Z26JS_ObjectCountDynamicSlotsN2JS6HandleIP8JSObjectEE(obj: + HandleObject) + -> u32; + fn _Z17JS_SetProtoCalledP9JSContext(cx: *mut JSContext) -> u32; + fn _Z25JS_GetCustomIteratorCountP9JSContext(cx: *mut JSContext) -> u32; + fn _Z33JS_NondeterministicGetWeakMapKeysP9JSContextN2JS6HandleIP8JSObjectEENS1_13MutableHandleIS4_EE(cx: + *mut JSContext, + obj: + HandleObject, + ret: + MutableHandleObject) + -> u8; + fn _Z17JS_PCToLineNumberP8JSScriptPhPj(script: *mut JSScript, pc: *mut u8, + columnp: *mut u32) -> u32; + fn _Z16JS_IsDeadWrapperP8JSObject(obj: *mut JSObject) -> u8; + fn _Z35JS_TraceShapeCycleCollectorChildrenP8JSTracerN2JS9GCCellPtrE(trc: + *mut JSTracer, + shape: + GCCellPtr); + fn _Z33JS_SetAccumulateTelemetryCallbackP9JSRuntimePFvijPKcE(rt: + *mut JSRuntime, + callback: + JSAccumulateTelemetryDataCallback); + fn _Z27JS_GetCompartmentPrincipalsP13JSCompartment(compartment: + *mut JSCompartment) + -> *mut JSPrincipals; + fn _Z27JS_SetCompartmentPrincipalsP13JSCompartmentP12JSPrincipals(compartment: + *mut JSCompartment, + principals: + *mut JSPrincipals); + fn _Z22JS_GetScriptPrincipalsP8JSScript(script: *mut JSScript) + -> *mut JSPrincipals; + fn _Z23JS_ScriptHasMutedErrorsP8JSScript(script: *mut JSScript) -> u8; + fn _Z22JS_ObjectToInnerObjectP9JSContextN2JS6HandleIP8JSObjectEE(cx: + *mut JSContext, + obj: + HandleObject) + -> *mut JSObject; + fn _Z22JS_ObjectToOuterObjectP9JSContextN2JS6HandleIP8JSObjectEE(cx: + *mut JSContext, + obj: + HandleObject) + -> *mut JSObject; + fn _Z14JS_CloneObjectP9JSContextN2JS6HandleIP8JSObjectEES5_(cx: + *mut JSContext, + obj: + HandleObject, + proto: + HandleObject) + -> *mut JSObject; + fn _Z49JS_InitializePropertiesFromCompatibleNativeObjectP9JSContextN2JS6HandleIP8JSObjectEES5_(cx: + *mut JSContext, + dst: + HandleObject, + src: + HandleObject) + -> u8; + fn _Z22JS_BasicObjectToStringP9JSContextN2JS6HandleIP8JSObjectEE(cx: + *mut JSContext, + obj: + HandleObject) + -> *mut JSString; + fn _ZN2js13ObjectClassIsEP9JSContextN2JS6HandleIP8JSObjectEENS_12ESClassValueE(cx: + *mut JSContext, + obj: + HandleObject, + classValue: + ESClassValue) + -> u8; + fn _ZN2js15ObjectClassNameEP9JSContextN2JS6HandleIP8JSObjectEE(cx: + *mut JSContext, + obj: + HandleObject) + -> *const i8; + fn _ZN2js18ReportOverRecursedEP9JSContext(maybecx: *mut JSContext); + fn _ZN2js15AddRawValueRootEP9JSContextPN2JS5ValueEPKc(cx: *mut JSContext, + vp: *mut Value, + name: *const i8) + -> u8; + fn _ZN2js18RemoveRawValueRootEP9JSContextPN2JS5ValueE(cx: *mut JSContext, + vp: *mut Value); + fn _ZN2js13DumpBacktraceEP9JSContext(cx: *mut JSContext); + fn _ZN2JS15FormatStackDumpEP9JSContextPcbbb(cx: *mut JSContext, + buf: *mut i8, showArgs: u8, + showLocals: u8, + showThisProps: u8) -> *mut i8; + fn _Z21JS_CopyPropertiesFromP9JSContextN2JS6HandleIP8JSObjectEES5_(cx: + *mut JSContext, + target: + HandleObject, + obj: + HandleObject) + -> u8; + fn _Z19JS_CopyPropertyFromP9JSContextN2JS6HandleI4jsidEENS2_IP8JSObjectEES7_20PropertyCopyBehavior(cx: + *mut JSContext, + id: + HandleId, + target: + HandleObject, + obj: + HandleObject, + copyBehavior: + PropertyCopyBehavior) + -> u8; + fn _Z25JS_WrapPropertyDescriptorP9JSContextN2JS13MutableHandleI20JSPropertyDescriptorEE(cx: + *mut JSContext, + desc: + MutableHandle) + -> u8; + fn _Z26JS_DefineFunctionsWithHelpP9JSContextN2JS6HandleIP8JSObjectEEPK22JSFunctionSpecWithHelp(cx: + *mut JSContext, + obj: + HandleObject, + fs: + *const JSFunctionSpecWithHelp) + -> u8; + fn _ZN2js20proxy_LookupPropertyEP9JSContextN2JS6HandleIP8JSObjectEENS3_I4jsidEENS2_13MutableHandleIS5_EENS9_IPNS_5ShapeEEE(cx: + *mut JSContext, + obj: + HandleObject, + id: + HandleId, + objp: + MutableHandleObject, + propp: + MutableHandle<*mut Shape>) + -> u8; + fn _ZN2js20proxy_DefinePropertyEP9JSContextN2JS6HandleIP8JSObjectEENS3_I4jsidEENS3_INS2_5ValueEEEPFbS1_S6_S8_NS2_13MutableHandleIS9_EEEPFbS1_S6_S8_SC_RNS2_14ObjectOpResultEEjSG_(cx: + *mut JSContext, + obj: + HandleObject, + id: + HandleId, + value: + HandleValue, + getter: + JSGetterOp, + setter: + JSSetterOp, + attrs: + u32, + result: + *mut ObjectOpResult) + -> u8; + fn _ZN2js17proxy_HasPropertyEP9JSContextN2JS6HandleIP8JSObjectEENS3_I4jsidEEPb(cx: + *mut JSContext, + obj: + HandleObject, + id: + HandleId, + foundp: + *mut u8) + -> u8; + fn _ZN2js17proxy_GetPropertyEP9JSContextN2JS6HandleIP8JSObjectEES6_NS3_I4jsidEENS2_13MutableHandleINS2_5ValueEEE(cx: + *mut JSContext, + obj: + HandleObject, + receiver: + HandleObject, + id: + HandleId, + vp: + MutableHandleValue) + -> u8; + fn _ZN2js17proxy_SetPropertyEP9JSContextN2JS6HandleIP8JSObjectEES6_NS3_I4jsidEENS2_13MutableHandleINS2_5ValueEEERNS2_14ObjectOpResultE(cx: + *mut JSContext, + obj: + HandleObject, + receiver: + HandleObject, + id: + HandleId, + bp: + MutableHandleValue, + result: + *mut ObjectOpResult) + -> u8; + fn _ZN2js30proxy_GetOwnPropertyDescriptorEP9JSContextN2JS6HandleIP8JSObjectEENS3_I4jsidEENS2_13MutableHandleI20JSPropertyDescriptorEE(cx: + *mut JSContext, + obj: + HandleObject, + id: + HandleId, + desc: + MutableHandle) + -> u8; + fn _ZN2js20proxy_DeletePropertyEP9JSContextN2JS6HandleIP8JSObjectEENS3_I4jsidEERNS2_14ObjectOpResultE(cx: + *mut JSContext, + obj: + HandleObject, + id: + HandleId, + result: + *mut ObjectOpResult) + -> u8; + fn _ZN2js11proxy_TraceEP8JSTracerP8JSObject(trc: *mut JSTracer, + obj: *mut JSObject); + fn _ZN2js24proxy_WeakmapKeyDelegateEP8JSObject(obj: *mut JSObject) + -> *mut JSObject; + fn _ZN2js13proxy_ConvertEP9JSContextN2JS6HandleIP8JSObjectEE6JSTypeNS2_13MutableHandleINS2_5ValueEEE(cx: + *mut JSContext, + proxy: + HandleObject, + hint: + JSType, + vp: + MutableHandleValue) + -> u8; + fn _ZN2js14proxy_FinalizeEPNS_6FreeOpEP8JSObject(fop: *mut FreeOp, + obj: *mut JSObject); + fn _ZN2js17proxy_ObjectMovedEP8JSObjectPKS0_(obj: *mut JSObject, + old: *const JSObject); + fn _ZN2js17proxy_HasInstanceEP9JSContextN2JS6HandleIP8JSObjectEENS2_13MutableHandleINS2_5ValueEEEPb(cx: + *mut JSContext, + proxy: + HandleObject, + v: + MutableHandleValue, + bp: + *mut u8) + -> u8; + fn _ZN2js10proxy_CallEP9JSContextjPN2JS5ValueE(cx: *mut JSContext, + argc: u32, vp: *mut Value) + -> u8; + fn _ZN2js15proxy_ConstructEP9JSContextjPN2JS5ValueE(cx: *mut JSContext, + argc: u32, + vp: *mut Value) -> u8; + fn _ZN2js17proxy_innerObjectEP8JSObject(obj: *mut JSObject) + -> *mut JSObject; + fn _ZN2js11proxy_WatchEP9JSContextN2JS6HandleIP8JSObjectEENS3_I4jsidEES6_(cx: + *mut JSContext, + obj: + HandleObject, + id: + HandleId, + callable: + HandleObject) + -> u8; + fn _ZN2js13proxy_UnwatchEP9JSContextN2JS6HandleIP8JSObjectEENS3_I4jsidEE(cx: + *mut JSContext, + obj: + HandleObject, + id: + HandleId) + -> u8; + fn _ZN2js17proxy_GetElementsEP9JSContextN2JS6HandleIP8JSObjectEEjjPNS_12ElementAdderE(cx: + *mut JSContext, + proxy: + HandleObject, + begin: + u32, + end: + u32, + adder: + *mut ElementAdder) + -> u8; + fn _ZN2js13SetSourceHookEP9JSRuntimeN7mozilla9UniquePtrINS_10SourceHookENS2_13DefaultDeleteIS4_EEEE(rt: + *mut JSRuntime, + hook: + UniquePtr); + fn _ZN2js16ForgetSourceHookEP9JSRuntime(rt: *mut JSRuntime) + -> UniquePtr; + fn _ZN2js18GetCompartmentZoneEP13JSCompartment(comp: *mut JSCompartment) + -> *mut Zone; + fn _ZN2js16DumpHeapCompleteEP9JSRuntimeP8_IO_FILENS_24DumpHeapNurseryBehaviourE(rt: + *mut JSRuntime, + fp: + *mut FILE, + nurseryBehaviour: + DumpHeapNurseryBehaviour); + fn _ZN2js16obj_defineGetterEP9JSContextjPN2JS5ValueE(cx: *mut JSContext, + argc: u32, + vp: *mut Value) + -> u8; + fn _ZN2js16obj_defineSetterEP9JSContextjPN2JS5ValueE(cx: *mut JSContext, + argc: u32, + vp: *mut Value) + -> u8; + fn _ZN2js19IsSystemCompartmentEP13JSCompartment(comp: *mut JSCompartment) + -> u8; + fn _ZN2js12IsSystemZoneEPN2JS4ZoneE(zone: *mut Zone) -> u8; + fn _ZN2js18IsAtomsCompartmentEP13JSCompartment(comp: *mut JSCompartment) + -> u8; + fn _ZN2js24IsInNonStrictPropertySetEP9JSContext(cx: *mut JSContext) -> u8; + fn _ZN2js13TraceWeakMapsEPNS_13WeakMapTracerE(trc: *mut WeakMapTracer); + fn _ZN2js18AreGCGrayBitsValidEP9JSRuntime(rt: *mut JSRuntime) -> u8; + fn _ZN2js21ZoneGlobalsAreAllGrayEPN2JS4ZoneE(zone: *mut Zone) -> u8; + fn _ZN2js23VisitGrayWrapperTargetsEPN2JS4ZoneEPFvPvNS0_9GCCellPtrEES3_(zone: + *mut Zone, + callback: + GCThingCallback, + closure: + *mut ::libc::c_void); + fn _ZN2js21GetWeakmapKeyDelegateEP8JSObject(key: *mut JSObject) + -> *mut JSObject; + fn _ZN2js16GCThingTraceKindEPv(thing: *mut ::libc::c_void) + -> JSGCTraceKind; + fn _ZN2js18IterateGrayObjectsEPN2JS4ZoneEPFvPvNS0_9GCCellPtrEES3_(zone: + *mut Zone, + cellCallback: + GCThingCallback, + data: + *mut ::libc::c_void); + fn _ZN2js23SizeOfDataIfCDataObjectEPFjPKvEP8JSObject(mallocSizeOf: + MallocSizeOf, + obj: *mut JSObject) + -> u32; + fn _ZN2js23GetAnyCompartmentInZoneEPN2JS4ZoneE(zone: *mut Zone) + -> *mut JSCompartment; + fn _ZN2js14GetObjectClassEP8JSObject(obj: *mut JSObject) -> *const Class; + fn _ZN2js16GetObjectJSClassEP8JSObject(obj: *mut JSObject) + -> *const JSClass; + fn _ZN2js15ProtoKeyToClassE10JSProtoKey(key: JSProtoKey) -> *const Class; + fn _ZN2js24StandardClassIsDependentE10JSProtoKey(key: JSProtoKey) -> u8; + fn _ZN2js25ParentKeyForStandardClassE10JSProtoKey(key: JSProtoKey) + -> JSProtoKey; + fn _ZN2js13IsInnerObjectEP8JSObject(obj: *mut JSObject) -> u8; + fn _ZN2js13IsOuterObjectEP8JSObject(obj: *mut JSObject) -> u8; + fn _ZN2js16IsFunctionObjectEP8JSObject(obj: *mut JSObject) -> u8; + fn _ZN2js13IsScopeObjectEP8JSObject(obj: *mut JSObject) -> u8; + fn _ZN2js12IsCallObjectEP8JSObject(obj: *mut JSObject) -> u8; + fn _ZN2js20CanAccessObjectShapeEP8JSObject(obj: *mut JSObject) -> u8; + fn _ZN2js34GetGlobalForObjectCrossCompartmentEP8JSObject(obj: + *mut JSObject) + -> *mut JSObject; + fn _ZN2js19GetPrototypeNoProxyEP8JSObject(obj: *mut JSObject) + -> *mut JSObject; + fn _ZN2js31SetPendingExceptionCrossContextEP9JSContextN2JS6HandleINS2_5ValueEEE(cx: + *mut JSContext, + v: + HandleValue); + fn _ZN2js21AssertSameCompartmentEP9JSContextP8JSObject(cx: *mut JSContext, + obj: + *mut JSObject); + fn _ZN2js21AssertSameCompartmentEP8JSObjectS1_(objA: *mut JSObject, + objB: *mut JSObject); + fn _ZN2js23NotifyAnimationActivityEP8JSObject(obj: *mut JSObject); + fn _ZN2js45GetOutermostEnclosingFunctionOfScriptedCallerEP9JSContext(cx: + *mut JSContext) + -> *mut JSFunction; + fn _ZN2js26DefineFunctionWithReservedEP9JSContextP8JSObjectPKcPFbS1_jPN2JS5ValueEEjj(cx: + *mut JSContext, + obj: + *mut JSObject, + name: + *const i8, + call: + JSNative, + nargs: + u32, + attrs: + u32) + -> *mut JSFunction; + fn _ZN2js23NewFunctionWithReservedEP9JSContextPFbS1_jPN2JS5ValueEEjjPKc(cx: + *mut JSContext, + call: + JSNative, + nargs: + u32, + flags: + u32, + name: + *const i8) + -> *mut JSFunction; + fn _ZN2js27NewFunctionByIdWithReservedEP9JSContextPFbS1_jPN2JS5ValueEEjj4jsid(cx: + *mut JSContext, + native: + JSNative, + nargs: + u32, + flags: + u32, + id: + jsid) + -> *mut JSFunction; + fn _ZN2js25GetFunctionNativeReservedEP8JSObjectj(fun: *mut JSObject, + which: u32) + -> *const Value; + fn _ZN2js25SetFunctionNativeReservedEP8JSObjectjRKN2JS5ValueE(fun: + *mut JSObject, + which: u32, + val: + *const Value); + fn _ZN2js25FunctionHasNativeReservedEP8JSObject(fun: *mut JSObject) -> u8; + fn _ZN2js14GetObjectProtoEP9JSContextN2JS6HandleIP8JSObjectEENS2_13MutableHandleIS5_EE(cx: + *mut JSContext, + obj: + HandleObject, + proto: + MutableHandleObject) + -> u8; + fn _ZN2js15GetOriginalEvalEP9JSContextN2JS6HandleIP8JSObjectEENS2_13MutableHandleIS5_EE(cx: + *mut JSContext, + scope: + HandleObject, + eval: + MutableHandleObject) + -> u8; + fn _ZN2js16GetObjectPrivateEP8JSObject(obj: *mut JSObject) + -> *mut ::libc::c_void; + fn _ZN2js15GetReservedSlotEP8JSObjectj(obj: *mut JSObject, slot: u32) + -> *const Value; + fn _ZN2js40SetReservedOrProxyPrivateSlotWithBarrierEP8JSObjectjRKN2JS5ValueE(obj: + *mut JSObject, + slot: + u32, + value: + *const Value); + fn _ZN2js15SetReservedSlotEP8JSObjectjRKN2JS5ValueE(obj: *mut JSObject, + slot: u32, + value: *const Value); + fn _ZN2js17GetObjectSlotSpanEP8JSObject(obj: *mut JSObject) -> u32; + fn _ZN2js13GetObjectSlotEP8JSObjectj(obj: *mut JSObject, slot: u32) + -> *const Value; + fn _ZN2js13GetAtomLengthEP6JSAtom(atom: *mut JSAtom) -> u32; + fn _ZN2js15GetStringLengthEP8JSString(s: *mut JSString) -> u32; + fn _ZN2js19GetFlatStringLengthEP12JSFlatString(s: *mut JSFlatString) + -> u32; + fn _ZN2js21GetLinearStringLengthEP14JSLinearString(s: *mut JSLinearString) + -> u32; + fn _ZN2js26LinearStringHasLatin1CharsEP14JSLinearString(s: + *mut JSLinearString) + -> u8; + fn _ZN2js18AtomHasLatin1CharsEP6JSAtom(atom: *mut JSAtom) -> u8; + fn _ZN2js20StringHasLatin1CharsEP8JSString(s: *mut JSString) -> u8; + fn _ZN2js26GetLatin1LinearStringCharsERKN2JS17AutoCheckCannotGCEP14JSLinearString(nogc: + *const AutoCheckCannotGC, + linear: + *mut JSLinearString) + -> *const Latin1Char; + fn _ZN2js27GetTwoByteLinearStringCharsERKN2JS17AutoCheckCannotGCEP14JSLinearString(nogc: + *const AutoCheckCannotGC, + linear: + *mut JSLinearString) + -> *const i16; + fn _ZN2js18AtomToLinearStringEP6JSAtom(atom: *mut JSAtom) + -> *mut JSLinearString; + fn _ZN2js24FlatStringToLinearStringEP12JSFlatString(s: *mut JSFlatString) + -> *mut JSLinearString; + fn _ZN2js18GetLatin1AtomCharsERKN2JS17AutoCheckCannotGCEP6JSAtom(nogc: + *const AutoCheckCannotGC, + atom: + *mut JSAtom) + -> *const Latin1Char; + fn _ZN2js19GetTwoByteAtomCharsERKN2JS17AutoCheckCannotGCEP6JSAtom(nogc: + *const AutoCheckCannotGC, + atom: + *mut JSAtom) + -> *const i16; + fn _ZN2js24StringToLinearStringSlowEP9JSContextP8JSString(cx: + *mut JSContext, + str: + *mut JSString) + -> *mut JSLinearString; + fn _ZN2js20StringToLinearStringEP9JSContextP8JSString(cx: *mut JSContext, + str: *mut JSString) + -> *mut JSLinearString; + fn _ZN2js21CopyLinearStringCharsEPDsP14JSLinearStringj(dest: *mut i16, + s: + *mut JSLinearString, + len: u32); + fn _ZN2js15CopyStringCharsEP9JSContextPDsP8JSStringj(cx: *mut JSContext, + dest: *mut i16, + s: *mut JSString, + len: u32) -> u8; + fn _ZN2js19CopyFlatStringCharsEPDsP12JSFlatStringj(dest: *mut i16, + s: *mut JSFlatString, + len: u32); + fn _ZN2js15GetPropertyKeysEP9JSContextN2JS6HandleIP8JSObjectEEjPNS2_12AutoIdVectorE(cx: + *mut JSContext, + obj: + HandleObject, + flags: + u32, + props: + *mut AutoIdVector) + -> u8; + fn _ZN2js12AppendUniqueEP9JSContextRN2JS12AutoIdVectorES4_(cx: + *mut JSContext, + base: + *mut AutoIdVector, + others: + *mut AutoIdVector) + -> u8; + fn _ZN2js10GetGenericEP9JSContextP8JSObjectS3_4jsidPN2JS5ValueE(cx: + *mut JSContext, + obj: + *mut JSObject, + receiver: + *mut JSObject, + id: jsid, + vp: + *mut Value) + -> u8; + fn _ZN2js18StringIsArrayIndexEP14JSLinearStringPj(str: + *mut JSLinearString, + indexp: *mut u32) -> u8; + fn _ZN2js26SetPreserveWrapperCallbackEP9JSRuntimePFbP9JSContextP8JSObjectE(rt: + *mut JSRuntime, + callback: + PreserveWrapperCallback); + fn _ZN2js28IsObjectInContextCompartmentEP8JSObjectPK9JSContext(obj: + *mut JSObject, + cx: + *const JSContext) + -> u8; + fn _ZN2js28RunningWithTrustedPrincipalsEP9JSContext(cx: *mut JSContext) + -> u8; + fn _ZN2js19GetNativeStackLimitEP9JSContextNS_9StackKindEi(cx: + *mut JSContext, + kind: StackKind, + extraAllowance: + i32) -> u32; + fn _ZN2js19GetNativeStackLimitEP9JSContexti(cx: *mut JSContext, + extraAllowance: i32) -> u32; + fn _ZN2js21StartPCCountProfilingEP9JSContext(cx: *mut JSContext); + fn _ZN2js20StopPCCountProfilingEP9JSContext(cx: *mut JSContext); + fn _ZN2js13PurgePCCountsEP9JSContext(cx: *mut JSContext); + fn _ZN2js21GetPCCountScriptCountEP9JSContext(cx: *mut JSContext) -> u32; + fn _ZN2js23GetPCCountScriptSummaryEP9JSContextj(cx: *mut JSContext, + script: u32) + -> *mut JSString; + fn _ZN2js24GetPCCountScriptContentsEP9JSContextj(cx: *mut JSContext, + script: u32) + -> *mut JSString; + fn _ZN2js29ContextHasOutstandingRequestsEPK9JSContext(cx: + *const JSContext) + -> u8; + fn _ZN2js19SetActivityCallbackEP9JSRuntimePFvPvbES2_(rt: *mut JSRuntime, + cb: ActivityCallback, + arg: + *mut ::libc::c_void); + fn _ZN2js34GetContextStructuredCloneCallbacksEP9JSContext(cx: + *mut JSContext) + -> *const JSStructuredCloneCallbacks; + fn _ZN2js18IsContextRunningJSEP9JSContext(cx: *mut JSContext) -> u8; + fn _ZN2js15SetDOMCallbacksEP9JSRuntimePKNS_14JSDOMCallbacksE(rt: + *mut JSRuntime, + callbacks: + *const DOMCallbacks); + fn _ZN2js15GetDOMCallbacksEP9JSRuntime(rt: *mut JSRuntime) + -> *const DOMCallbacks; + fn _ZN2js19GetTestingFunctionsEP9JSContext(cx: *mut JSContext) + -> *mut JSObject; + fn _ZN2js14CastToJSFreeOpEPNS_6FreeOpE(fop: *mut FreeOp) -> *mut JSFreeOp; + fn _ZN2js16GetErrorTypeNameEP9JSRuntimes(rt: *mut JSRuntime, exnType: i16) + -> *mut JSFlatString; + fn _ZN2js23RegExpToSharedNonInlineEP9JSContextN2JS6HandleIP8JSObjectEEPNS_11RegExpGuardE(cx: + *mut JSContext, + regexp: + HandleObject, + shared: + *mut RegExpGuard) + -> u8; + fn _ZN2js28NukeCrossCompartmentWrappersEP9JSContextRKNS_17CompartmentFilterES4_NS_22NukeReferencesToWindowE(cx: + *mut JSContext, + sourceFilter: + *const CompartmentFilter, + targetFilter: + *const CompartmentFilter, + nukeReferencesToWindow: + NukeReferencesToWindow) + -> u8; + fn _ZN2js22SetDOMProxyInformationEPKvjPFNS_21DOMProxyShadowsResultEP9JSContextN2JS6HandleIP8JSObjectEENS6_I4jsidEEE(domProxyHandlerFamily: + *const ::libc::c_void, + domProxyExpandoSlot: + u32, + domProxyShadowsCheck: + DOMProxyShadowsCheck); + fn _ZN2js24GetDOMProxyHandlerFamilyEv() -> *const ::libc::c_void; + fn _ZN2js22GetDOMProxyExpandoSlotEv() -> u32; + fn _ZN2js23GetDOMProxyShadowsCheckEv() -> DOMProxyShadowsCheck; + fn _ZN2js19DOMProxyIsShadowingENS_21DOMProxyShadowsResultE(result: + DOMProxyShadowsResult) + -> u8; + fn _ZN2js11DateIsValidEP9JSContextP8JSObject(cx: *mut JSContext, + obj: *mut JSObject) -> u8; + fn _ZN2js21DateGetMsecSinceEpochEP9JSContextP8JSObject(cx: *mut JSContext, + obj: *mut JSObject) + -> f64; + fn _ZN2js15GetErrorMessageEPvj(userRef: *mut ::libc::c_void, + errorNumber: u32) + -> *const JSErrorFormatString; + fn _ZN2js19ErrorReportToStringEP9JSContextP13JSErrorReport(cx: + *mut JSContext, + reportp: + *mut JSErrorReport) + -> *mut JSString; + fn _ZN2js11GetSCOffsetEP23JSStructuredCloneWriter(writer: + *mut JSStructuredCloneWriter) + -> u64; + fn _Z15JS_NewInt8ArrayP9JSContextj(cx: *mut JSContext, nelements: u32) + -> *mut JSObject; + fn _Z16JS_NewUint8ArrayP9JSContextj(cx: *mut JSContext, nelements: u32) + -> *mut JSObject; + fn _Z23JS_NewUint8ClampedArrayP9JSContextj(cx: *mut JSContext, + nelements: u32) + -> *mut JSObject; + fn _Z16JS_NewInt16ArrayP9JSContextj(cx: *mut JSContext, nelements: u32) + -> *mut JSObject; + fn _Z17JS_NewUint16ArrayP9JSContextj(cx: *mut JSContext, nelements: u32) + -> *mut JSObject; + fn _Z16JS_NewInt32ArrayP9JSContextj(cx: *mut JSContext, nelements: u32) + -> *mut JSObject; + fn _Z17JS_NewUint32ArrayP9JSContextj(cx: *mut JSContext, nelements: u32) + -> *mut JSObject; + fn _Z18JS_NewFloat32ArrayP9JSContextj(cx: *mut JSContext, nelements: u32) + -> *mut JSObject; + fn _Z18JS_NewFloat64ArrayP9JSContextj(cx: *mut JSContext, nelements: u32) + -> *mut JSObject; + fn _Z21JS_NewSharedInt8ArrayP9JSContextj(cx: *mut JSContext, + nelements: u32) -> *mut JSObject; + fn _Z22JS_NewSharedUint8ArrayP9JSContextj(cx: *mut JSContext, + nelements: u32) + -> *mut JSObject; + fn _Z29JS_NewSharedUint8ClampedArrayP9JSContextj(cx: *mut JSContext, + nelements: u32) + -> *mut JSObject; + fn _Z22JS_NewSharedInt16ArrayP9JSContextj(cx: *mut JSContext, + nelements: u32) + -> *mut JSObject; + fn _Z23JS_NewSharedUint16ArrayP9JSContextj(cx: *mut JSContext, + nelements: u32) + -> *mut JSObject; + fn _Z22JS_NewSharedInt32ArrayP9JSContextj(cx: *mut JSContext, + nelements: u32) + -> *mut JSObject; + fn _Z23JS_NewSharedUint32ArrayP9JSContextj(cx: *mut JSContext, + nelements: u32) + -> *mut JSObject; + fn _Z24JS_NewSharedFloat32ArrayP9JSContextj(cx: *mut JSContext, + nelements: u32) + -> *mut JSObject; + fn _Z24JS_NewSharedFloat64ArrayP9JSContextj(cx: *mut JSContext, + nelements: u32) + -> *mut JSObject; + fn _Z24JS_NewInt8ArrayFromArrayP9JSContextN2JS6HandleIP8JSObjectEE(cx: + *mut JSContext, + array: + HandleObject) + -> *mut JSObject; + fn _Z25JS_NewUint8ArrayFromArrayP9JSContextN2JS6HandleIP8JSObjectEE(cx: + *mut JSContext, + array: + HandleObject) + -> *mut JSObject; + fn _Z32JS_NewUint8ClampedArrayFromArrayP9JSContextN2JS6HandleIP8JSObjectEE(cx: + *mut JSContext, + array: + HandleObject) + -> *mut JSObject; + fn _Z25JS_NewInt16ArrayFromArrayP9JSContextN2JS6HandleIP8JSObjectEE(cx: + *mut JSContext, + array: + HandleObject) + -> *mut JSObject; + fn _Z26JS_NewUint16ArrayFromArrayP9JSContextN2JS6HandleIP8JSObjectEE(cx: + *mut JSContext, + array: + HandleObject) + -> *mut JSObject; + fn _Z25JS_NewInt32ArrayFromArrayP9JSContextN2JS6HandleIP8JSObjectEE(cx: + *mut JSContext, + array: + HandleObject) + -> *mut JSObject; + fn _Z26JS_NewUint32ArrayFromArrayP9JSContextN2JS6HandleIP8JSObjectEE(cx: + *mut JSContext, + array: + HandleObject) + -> *mut JSObject; + fn _Z27JS_NewFloat32ArrayFromArrayP9JSContextN2JS6HandleIP8JSObjectEE(cx: + *mut JSContext, + array: + HandleObject) + -> *mut JSObject; + fn _Z27JS_NewFloat64ArrayFromArrayP9JSContextN2JS6HandleIP8JSObjectEE(cx: + *mut JSContext, + array: + HandleObject) + -> *mut JSObject; + fn _Z25JS_NewInt8ArrayWithBufferP9JSContextN2JS6HandleIP8JSObjectEEji(cx: + *mut JSContext, + arrayBuffer: + HandleObject, + byteOffset: + u32, + length: + i32) + -> *mut JSObject; + fn _Z26JS_NewUint8ArrayWithBufferP9JSContextN2JS6HandleIP8JSObjectEEji(cx: + *mut JSContext, + arrayBuffer: + HandleObject, + byteOffset: + u32, + length: + i32) + -> *mut JSObject; + fn _Z33JS_NewUint8ClampedArrayWithBufferP9JSContextN2JS6HandleIP8JSObjectEEji(cx: + *mut JSContext, + arrayBuffer: + HandleObject, + byteOffset: + u32, + length: + i32) + -> *mut JSObject; + fn _Z26JS_NewInt16ArrayWithBufferP9JSContextN2JS6HandleIP8JSObjectEEji(cx: + *mut JSContext, + arrayBuffer: + HandleObject, + byteOffset: + u32, + length: + i32) + -> *mut JSObject; + fn _Z27JS_NewUint16ArrayWithBufferP9JSContextN2JS6HandleIP8JSObjectEEji(cx: + *mut JSContext, + arrayBuffer: + HandleObject, + byteOffset: + u32, + length: + i32) + -> *mut JSObject; + fn _Z26JS_NewInt32ArrayWithBufferP9JSContextN2JS6HandleIP8JSObjectEEji(cx: + *mut JSContext, + arrayBuffer: + HandleObject, + byteOffset: + u32, + length: + i32) + -> *mut JSObject; + fn _Z27JS_NewUint32ArrayWithBufferP9JSContextN2JS6HandleIP8JSObjectEEji(cx: + *mut JSContext, + arrayBuffer: + HandleObject, + byteOffset: + u32, + length: + i32) + -> *mut JSObject; + fn _Z28JS_NewFloat32ArrayWithBufferP9JSContextN2JS6HandleIP8JSObjectEEji(cx: + *mut JSContext, + arrayBuffer: + HandleObject, + byteOffset: + u32, + length: + i32) + -> *mut JSObject; + fn _Z28JS_NewFloat64ArrayWithBufferP9JSContextN2JS6HandleIP8JSObjectEEji(cx: + *mut JSContext, + arrayBuffer: + HandleObject, + byteOffset: + u32, + length: + i32) + -> *mut JSObject; + fn _Z31JS_NewSharedInt8ArrayWithBufferP9JSContextN2JS6HandleIP8JSObjectEEjj(cx: + *mut JSContext, + arrayBuffer: + HandleObject, + byteOffset: + u32, + length: + u32) + -> *mut JSObject; + fn _Z32JS_NewSharedUint8ArrayWithBufferP9JSContextN2JS6HandleIP8JSObjectEEjj(cx: + *mut JSContext, + arrayBuffer: + HandleObject, + byteOffset: + u32, + length: + u32) + -> *mut JSObject; + fn _Z39JS_NewSharedUint8ClampedArrayWithBufferP9JSContextN2JS6HandleIP8JSObjectEEjj(cx: + *mut JSContext, + arrayBuffer: + HandleObject, + byteOffset: + u32, + length: + u32) + -> *mut JSObject; + fn _Z32JS_NewSharedInt16ArrayWithBufferP9JSContextN2JS6HandleIP8JSObjectEEjj(cx: + *mut JSContext, + arrayBuffer: + HandleObject, + byteOffset: + u32, + length: + u32) + -> *mut JSObject; + fn _Z33JS_NewSharedUint16ArrayWithBufferP9JSContextN2JS6HandleIP8JSObjectEEjj(cx: + *mut JSContext, + arrayBuffer: + HandleObject, + byteOffset: + u32, + length: + u32) + -> *mut JSObject; + fn _Z32JS_NewSharedInt32ArrayWithBufferP9JSContextN2JS6HandleIP8JSObjectEEjj(cx: + *mut JSContext, + arrayBuffer: + HandleObject, + byteOffset: + u32, + length: + u32) + -> *mut JSObject; + fn _Z33JS_NewSharedUint32ArrayWithBufferP9JSContextN2JS6HandleIP8JSObjectEEjj(cx: + *mut JSContext, + arrayBuffer: + HandleObject, + byteOffset: + u32, + length: + u32) + -> *mut JSObject; + fn _Z34JS_NewSharedFloat32ArrayWithBufferP9JSContextN2JS6HandleIP8JSObjectEEjj(cx: + *mut JSContext, + arrayBuffer: + HandleObject, + byteOffset: + u32, + length: + u32) + -> *mut JSObject; + fn _Z34JS_NewSharedFloat64ArrayWithBufferP9JSContextN2JS6HandleIP8JSObjectEEjj(cx: + *mut JSContext, + arrayBuffer: + HandleObject, + byteOffset: + u32, + length: + u32) + -> *mut JSObject; + fn _Z17JS_NewArrayBufferP9JSContextj(cx: *mut JSContext, nbytes: u32) + -> *mut JSObject; + fn _Z21JS_IsTypedArrayObjectP8JSObject(obj: *mut JSObject) -> u8; + fn _Z27JS_IsSharedTypedArrayObjectP8JSObject(obj: *mut JSObject) -> u8; + fn _Z14JS_IsInt8ArrayP8JSObject(obj: *mut JSObject) -> u8; + fn _Z15JS_IsUint8ArrayP8JSObject(obj: *mut JSObject) -> u8; + fn _Z22JS_IsUint8ClampedArrayP8JSObject(obj: *mut JSObject) -> u8; + fn _Z15JS_IsInt16ArrayP8JSObject(obj: *mut JSObject) -> u8; + fn _Z16JS_IsUint16ArrayP8JSObject(obj: *mut JSObject) -> u8; + fn _Z15JS_IsInt32ArrayP8JSObject(obj: *mut JSObject) -> u8; + fn _Z16JS_IsUint32ArrayP8JSObject(obj: *mut JSObject) -> u8; + fn _Z17JS_IsFloat32ArrayP8JSObject(obj: *mut JSObject) -> u8; + fn _Z17JS_IsFloat64ArrayP8JSObject(obj: *mut JSObject) -> u8; + fn _Z20JS_IsSharedInt8ArrayP8JSObject(obj: *mut JSObject) -> u8; + fn _Z21JS_IsSharedUint8ArrayP8JSObject(obj: *mut JSObject) -> u8; + fn _Z28JS_IsSharedUint8ClampedArrayP8JSObject(obj: *mut JSObject) -> u8; + fn _Z21JS_IsSharedInt16ArrayP8JSObject(obj: *mut JSObject) -> u8; + fn _Z22JS_IsSharedUint16ArrayP8JSObject(obj: *mut JSObject) -> u8; + fn _Z21JS_IsSharedInt32ArrayP8JSObject(obj: *mut JSObject) -> u8; + fn _Z22JS_IsSharedUint32ArrayP8JSObject(obj: *mut JSObject) -> u8; + fn _Z23JS_IsSharedFloat32ArrayP8JSObject(obj: *mut JSObject) -> u8; + fn _Z23JS_IsSharedFloat64ArrayP8JSObject(obj: *mut JSObject) -> u8; + fn _ZN2js15UnwrapInt8ArrayEP8JSObject(obj: *mut JSObject) + -> *mut JSObject; + fn _ZN2js16UnwrapUint8ArrayEP8JSObject(obj: *mut JSObject) + -> *mut JSObject; + fn _ZN2js23UnwrapUint8ClampedArrayEP8JSObject(obj: *mut JSObject) + -> *mut JSObject; + fn _ZN2js16UnwrapInt16ArrayEP8JSObject(obj: *mut JSObject) + -> *mut JSObject; + fn _ZN2js17UnwrapUint16ArrayEP8JSObject(obj: *mut JSObject) + -> *mut JSObject; + fn _ZN2js16UnwrapInt32ArrayEP8JSObject(obj: *mut JSObject) + -> *mut JSObject; + fn _ZN2js17UnwrapUint32ArrayEP8JSObject(obj: *mut JSObject) + -> *mut JSObject; + fn _ZN2js18UnwrapFloat32ArrayEP8JSObject(obj: *mut JSObject) + -> *mut JSObject; + fn _ZN2js18UnwrapFloat64ArrayEP8JSObject(obj: *mut JSObject) + -> *mut JSObject; + fn _ZN2js17UnwrapArrayBufferEP8JSObject(obj: *mut JSObject) + -> *mut JSObject; + fn _ZN2js21UnwrapArrayBufferViewEP8JSObject(obj: *mut JSObject) + -> *mut JSObject; + fn _ZN2js21UnwrapSharedInt8ArrayEP8JSObject(obj: *mut JSObject) + -> *mut JSObject; + fn _ZN2js22UnwrapSharedUint8ArrayEP8JSObject(obj: *mut JSObject) + -> *mut JSObject; + fn _ZN2js29UnwrapSharedUint8ClampedArrayEP8JSObject(obj: *mut JSObject) + -> *mut JSObject; + fn _ZN2js22UnwrapSharedInt16ArrayEP8JSObject(obj: *mut JSObject) + -> *mut JSObject; + fn _ZN2js23UnwrapSharedUint16ArrayEP8JSObject(obj: *mut JSObject) + -> *mut JSObject; + fn _ZN2js22UnwrapSharedInt32ArrayEP8JSObject(obj: *mut JSObject) + -> *mut JSObject; + fn _ZN2js23UnwrapSharedUint32ArrayEP8JSObject(obj: *mut JSObject) + -> *mut JSObject; + fn _ZN2js24UnwrapSharedFloat32ArrayEP8JSObject(obj: *mut JSObject) + -> *mut JSObject; + fn _ZN2js24UnwrapSharedFloat64ArrayEP8JSObject(obj: *mut JSObject) + -> *mut JSObject; + fn _ZN2js25GetInt8ArrayLengthAndDataEP8JSObjectPjPPa(obj: *mut JSObject, + length: *mut u32, + data: *mut *mut i8); + fn _ZN2js26GetUint8ArrayLengthAndDataEP8JSObjectPjPPh(obj: *mut JSObject, + length: *mut u32, + data: *mut *mut u8); + fn _ZN2js33GetUint8ClampedArrayLengthAndDataEP8JSObjectPjPPh(obj: + *mut JSObject, + length: + *mut u32, + data: + *mut *mut u8); + fn _ZN2js26GetInt16ArrayLengthAndDataEP8JSObjectPjPPs(obj: *mut JSObject, + length: *mut u32, + data: + *mut *mut i16); + fn _ZN2js27GetUint16ArrayLengthAndDataEP8JSObjectPjPPt(obj: *mut JSObject, + length: *mut u32, + data: + *mut *mut u16); + fn _ZN2js26GetInt32ArrayLengthAndDataEP8JSObjectPjPPi(obj: *mut JSObject, + length: *mut u32, + data: + *mut *mut i32); + fn _ZN2js27GetUint32ArrayLengthAndDataEP8JSObjectPjPS2_(obj: + *mut JSObject, + length: *mut u32, + data: + *mut *mut u32); + fn _ZN2js28GetFloat32ArrayLengthAndDataEP8JSObjectPjPPf(obj: + *mut JSObject, + length: *mut u32, + data: + *mut *mut f32); + fn _ZN2js28GetFloat64ArrayLengthAndDataEP8JSObjectPjPPd(obj: + *mut JSObject, + length: *mut u32, + data: + *mut *mut f64); + fn _ZN2js31GetArrayBufferViewLengthAndDataEP8JSObjectPjPPh(obj: + *mut JSObject, + length: + *mut u32, + data: + *mut *mut u8); + fn _ZN2js27GetArrayBufferLengthAndDataEP8JSObjectPjPPh(obj: *mut JSObject, + length: *mut u32, + data: + *mut *mut u8); + fn _Z23JS_GetObjectAsInt8ArrayP8JSObjectPjPPa(obj: *mut JSObject, + length: *mut u32, + data: *mut *mut i8) + -> *mut JSObject; + fn _Z24JS_GetObjectAsUint8ArrayP8JSObjectPjPPh(obj: *mut JSObject, + length: *mut u32, + data: *mut *mut u8) + -> *mut JSObject; + fn _Z31JS_GetObjectAsUint8ClampedArrayP8JSObjectPjPPh(obj: *mut JSObject, + length: *mut u32, + data: *mut *mut u8) + -> *mut JSObject; + fn _Z24JS_GetObjectAsInt16ArrayP8JSObjectPjPPs(obj: *mut JSObject, + length: *mut u32, + data: *mut *mut i16) + -> *mut JSObject; + fn _Z25JS_GetObjectAsUint16ArrayP8JSObjectPjPPt(obj: *mut JSObject, + length: *mut u32, + data: *mut *mut u16) + -> *mut JSObject; + fn _Z24JS_GetObjectAsInt32ArrayP8JSObjectPjPPi(obj: *mut JSObject, + length: *mut u32, + data: *mut *mut i32) + -> *mut JSObject; + fn _Z25JS_GetObjectAsUint32ArrayP8JSObjectPjPS1_(obj: *mut JSObject, + length: *mut u32, + data: *mut *mut u32) + -> *mut JSObject; + fn _Z26JS_GetObjectAsFloat32ArrayP8JSObjectPjPPf(obj: *mut JSObject, + length: *mut u32, + data: *mut *mut f32) + -> *mut JSObject; + fn _Z26JS_GetObjectAsFloat64ArrayP8JSObjectPjPPd(obj: *mut JSObject, + length: *mut u32, + data: *mut *mut f64) + -> *mut JSObject; + fn _Z29JS_GetObjectAsArrayBufferViewP8JSObjectPjPPh(obj: *mut JSObject, + length: *mut u32, + data: *mut *mut u8) + -> *mut JSObject; + fn _Z25JS_GetObjectAsArrayBufferP8JSObjectPjPPh(obj: *mut JSObject, + length: *mut u32, + data: *mut *mut u8) + -> *mut JSObject; + fn _Z25JS_GetArrayBufferViewTypeP8JSObject(obj: *mut JSObject) -> Type; + fn _Z22JS_IsArrayBufferObjectP8JSObject(obj: *mut JSObject) -> u8; + fn _Z28JS_IsSharedArrayBufferObjectP8JSObject(obj: *mut JSObject) -> u8; + fn _Z27JS_GetArrayBufferByteLengthP8JSObject(obj: *mut JSObject) -> u32; + fn _Z21JS_ArrayBufferHasDataP8JSObject(obj: *mut JSObject) -> u8; + fn _Z28JS_IsMappedArrayBufferObjectP8JSObject(obj: *mut JSObject) -> u8; + fn _Z22JS_GetTypedArrayLengthP8JSObject(obj: *mut JSObject) -> u32; + fn _Z26JS_GetTypedArrayByteOffsetP8JSObject(obj: *mut JSObject) -> u32; + fn _Z26JS_GetTypedArrayByteLengthP8JSObject(obj: *mut JSObject) -> u32; + fn _Z31JS_GetArrayBufferViewByteLengthP8JSObject(obj: *mut JSObject) + -> u32; + fn _Z21JS_GetArrayBufferDataP8JSObjectRKN2JS17AutoCheckCannotGCE(obj: + *mut JSObject, + arg1: + *const AutoCheckCannotGC) + -> *mut u8; + fn _Z19JS_GetInt8ArrayDataP8JSObjectRKN2JS17AutoCheckCannotGCE(obj: + *mut JSObject, + arg1: + *const AutoCheckCannotGC) + -> *mut i8; + fn _Z20JS_GetUint8ArrayDataP8JSObjectRKN2JS17AutoCheckCannotGCE(obj: + *mut JSObject, + arg1: + *const AutoCheckCannotGC) + -> *mut u8; + fn _Z27JS_GetUint8ClampedArrayDataP8JSObjectRKN2JS17AutoCheckCannotGCE(obj: + *mut JSObject, + arg1: + *const AutoCheckCannotGC) + -> *mut u8; + fn _Z20JS_GetInt16ArrayDataP8JSObjectRKN2JS17AutoCheckCannotGCE(obj: + *mut JSObject, + arg1: + *const AutoCheckCannotGC) + -> *mut i16; + fn _Z21JS_GetUint16ArrayDataP8JSObjectRKN2JS17AutoCheckCannotGCE(obj: + *mut JSObject, + arg1: + *const AutoCheckCannotGC) + -> *mut u16; + fn _Z20JS_GetInt32ArrayDataP8JSObjectRKN2JS17AutoCheckCannotGCE(obj: + *mut JSObject, + arg1: + *const AutoCheckCannotGC) + -> *mut i32; + fn _Z21JS_GetUint32ArrayDataP8JSObjectRKN2JS17AutoCheckCannotGCE(obj: + *mut JSObject, + arg1: + *const AutoCheckCannotGC) + -> *mut u32; + fn _Z22JS_GetFloat32ArrayDataP8JSObjectRKN2JS17AutoCheckCannotGCE(obj: + *mut JSObject, + arg1: + *const AutoCheckCannotGC) + -> *mut f32; + fn _Z22JS_GetFloat64ArrayDataP8JSObjectRKN2JS17AutoCheckCannotGCE(obj: + *mut JSObject, + arg1: + *const AutoCheckCannotGC) + -> *mut f64; + fn _Z25JS_GetArrayBufferViewDataP8JSObjectRKN2JS17AutoCheckCannotGCE(obj: + *mut JSObject, + arg1: + *const AutoCheckCannotGC) + -> *mut ::libc::c_void; + fn _Z27JS_GetArrayBufferViewBufferP9JSContextN2JS6HandleIP8JSObjectEE(cx: + *mut JSContext, + obj: + HandleObject) + -> *mut JSObject; + fn _Z20JS_NeuterArrayBufferP9JSContextN2JS6HandleIP8JSObjectEE21NeuterDataDisposition(cx: + *mut JSContext, + obj: + HandleObject, + changeData: + NeuterDataDisposition) + -> u8; + fn _Z30JS_IsNeuteredArrayBufferObjectP8JSObject(obj: *mut JSObject) -> u8; + fn _Z19JS_IsDataViewObjectP8JSObject(obj: *mut JSObject) -> u8; + fn _Z24JS_GetDataViewByteOffsetP8JSObject(obj: *mut JSObject) -> u32; + fn _Z24JS_GetDataViewByteLengthP8JSObject(obj: *mut JSObject) -> u32; + fn _Z18JS_GetDataViewDataP8JSObjectRKN2JS17AutoCheckCannotGCE(obj: + *mut JSObject, + arg1: + *const AutoCheckCannotGC) + -> *mut ::libc::c_void; + fn _ZN2js9WatchGutsEP9JSContextN2JS6HandleIP8JSObjectEENS3_I4jsidEES6_(cx: + *mut JSContext, + obj: + HandleObject, + id: + HandleId, + callable: + HandleObject) + -> u8; + fn _ZN2js11UnwatchGutsEP9JSContextN2JS6HandleIP8JSObjectEENS3_I4jsidEE(cx: + *mut JSContext, + obj: + HandleObject, + id: + HandleId) + -> u8; + fn _ZN2js6detail13IdMatchesAtomE4jsidP6JSAtom(id: jsid, atom: *mut JSAtom) + -> u8; + fn _ZN2js16DefaultJSContextEP9JSRuntime(rt: *mut JSRuntime) + -> *mut JSContext; + fn _ZN2js27SetDefaultJSContextCallbackEP9JSRuntimePFP9JSContextS1_E(rt: + *mut JSRuntime, + cb: + DefaultJSContextCallback); + fn _ZN2js24Debug_SetActiveJSContextEP9JSRuntimeP9JSContext(rt: + *mut JSRuntime, + cx: + *mut JSContext); + fn _ZN2js25SetCTypesActivityCallbackEP9JSRuntimePFvP9JSContextNS_18CTypesActivityTypeEE(rt: + *mut JSRuntime, + cb: + CTypesActivityCallback); + fn _ZN2js25SetObjectMetadataCallbackEP9JSContextPFbS1_PP8JSObjectE(cx: + *mut JSContext, + callback: + ObjectMetadataCallback); + fn _ZN2js17SetObjectMetadataEP9JSContextN2JS6HandleIP8JSObjectEES6_(cx: + *mut JSContext, + obj: + HandleObject, + metadata: + HandleObject) + -> u8; + fn _ZN2js17GetObjectMetadataEP8JSObject(obj: *mut JSObject) + -> *mut JSObject; + fn _ZN2js20GetElementsWithAdderEP9JSContextN2JS6HandleIP8JSObjectEES6_jjPNS_12ElementAdderE(cx: + *mut JSContext, + obj: + HandleObject, + receiver: + HandleObject, + begin: + u32, + end: + u32, + adder: + *mut ElementAdder) + -> u8; + fn _ZN2js15ForwardToNativeEP9JSContextPFbS1_jPN2JS5ValueEERKNS2_8CallArgsE(cx: + *mut JSContext, + native: + JSNative, + args: + *const CallArgs) + -> u8; + fn _ZN2js30SetPropertyIgnoringNamedGetterEP9JSContextN2JS6HandleIP8JSObjectEENS3_I4jsidEENS2_13MutableHandleINS2_5ValueEEES6_NS9_I20JSPropertyDescriptorEERNS2_14ObjectOpResultE(cx: + *mut JSContext, + obj: + HandleObject, + id: + HandleId, + vp: + MutableHandleValue, + receiver: + HandleObject, + ownDesc: + MutableHandle, + result: + *mut ObjectOpResult) + -> u8; + fn _ZN2js17ReportErrorWithIdEP9JSContextPKcN2JS6HandleI4jsidEE(cx: + *mut JSContext, + msg: + *const i8, + id: + HandleId); + fn _ZN2js29ExecuteInGlobalAndReturnScopeEP9JSContextN2JS6HandleIP8JSObjectEENS3_IP8JSScriptEENS2_13MutableHandleIS5_EE(cx: + *mut JSContext, + obj: + HandleObject, + script: + HandleScript, + scope: + MutableHandleObject) + -> u8; + fn _ZN2js37GetObjectEnvironmentObjectForFunctionEP10JSFunction(fun: + *mut JSFunction) + -> *mut JSObject; + fn _ZN2js23GetSavedFramePrincipalsEN2JS6HandleIP8JSObjectEE(savedFrame: + HandleObject) + -> *mut JSPrincipals; + fn _ZN2js26GetFirstSubsumedSavedFrameEP9JSContextN2JS6HandleIP8JSObjectEE(cx: + *mut JSContext, + savedFrame: + HandleObject) + -> *mut JSObject; + fn _ZN2js19ReportIsNotFunctionEP9JSContextN2JS6HandleINS2_5ValueEEE(cx: + *mut JSContext, + v: + HandleValue) + -> u8; + fn _ZN2js17DefineOwnPropertyEP9JSContextP8JSObject4jsidN2JS6HandleI20JSPropertyDescriptorEERNS5_14ObjectOpResultE(cx: + *mut JSContext, + objArg: + *mut JSObject, + idArg: + jsid, + descriptor: + Handle, + result: + *mut ObjectOpResult) + -> u8; + fn _Z33JS_StoreObjectPostBarrierCallbackP9JSContextPFvP8JSTracerP8JSObjectPvES4_S5_(cx: + *mut JSContext, + callback: + ::std::option::Option, + key: + *mut JSObject, + data: + *mut ::libc::c_void); + fn _Z33JS_StoreStringPostBarrierCallbackP9JSContextPFvP8JSTracerP8JSStringPvES4_S5_(cx: + *mut JSContext, + callback: + ::std::option::Option, + key: + *mut JSString, + data: + *mut ::libc::c_void); +} +pub unsafe extern "C" fn JS_Assert(s: *const i8, file: *const i8, ln: i32) { + _Z9JS_AssertPKcS0_i(s, file, ln) +} +pub unsafe extern "C" fn ScrambleHashCode(h: u32) -> u32 { + _ZN2js6detail16ScrambleHashCodeEj(h) +} +pub unsafe extern "C" fn FinishGC(rt: *mut JSRuntime) { + _ZN2js8FinishGCEP9JSRuntime(rt) +} +pub unsafe extern "C" fn MarkPersistentRootedChains(arg1: *mut JSTracer) { + _ZN2js2gc26MarkPersistentRootedChainsEP8JSTracer(arg1) +} +pub unsafe extern "C" fn FinishPersistentRootedChains(arg1: *mut JSRuntime) { + _ZN2js2gc28FinishPersistentRootedChainsEP9JSRuntime(arg1) +} +pub unsafe extern "C" fn GetRuntime(cx: *const JSContext) -> *mut JSRuntime { + _ZN2js10GetRuntimeEPK9JSContext(cx) +} +pub unsafe extern "C" fn JS_GetRuntime(cx: *mut JSContext) -> *mut JSRuntime { + _Z13JS_GetRuntimeP9JSContext(cx) +} +pub unsafe extern "C" fn GetContextCompartment(cx: *const JSContext) + -> *mut JSCompartment { + _ZN2js21GetContextCompartmentEPK9JSContext(cx) +} +pub unsafe extern "C" fn GetContextZone(cx: *const JSContext) -> *mut Zone { + _ZN2js14GetContextZoneEPK9JSContext(cx) +} +pub unsafe extern "C" fn GCTraceKindToAscii(kind: JSGCTraceKind) + -> *const i8 { + _ZN2JS18GCTraceKindToAsciiE13JSGCTraceKind(kind) +} +pub unsafe extern "C" fn JS_CallValueTracer(trc: *mut JSTracer, + valuep: *mut Heap, + name: *const i8) { + _Z18JS_CallValueTracerP8JSTracerPN2JS4HeapINS1_5ValueEEEPKc(trc, valuep, + name) +} +pub unsafe extern "C" fn JS_CallIdTracer(trc: *mut JSTracer, + idp: *mut Heap, + name: *const i8) { + _Z15JS_CallIdTracerP8JSTracerPN2JS4HeapI4jsidEEPKc(trc, idp, name) +} +pub unsafe extern "C" fn JS_CallObjectTracer(trc: *mut JSTracer, + objp: *mut Heap<*mut JSObject>, + name: *const i8) { + _Z19JS_CallObjectTracerP8JSTracerPN2JS4HeapIP8JSObjectEEPKc(trc, objp, + name) +} +pub unsafe extern "C" fn JS_CallStringTracer(trc: *mut JSTracer, + strp: *mut Heap<*mut JSString>, + name: *const i8) { + _Z19JS_CallStringTracerP8JSTracerPN2JS4HeapIP8JSStringEEPKc(trc, strp, + name) +} +pub unsafe extern "C" fn JS_CallScriptTracer(trc: *mut JSTracer, + scriptp: + *mut Heap<*mut JSScript>, + name: *const i8) { + _Z19JS_CallScriptTracerP8JSTracerPN2JS4HeapIP8JSScriptEEPKc(trc, scriptp, + name) +} +pub unsafe extern "C" fn JS_CallFunctionTracer(trc: *mut JSTracer, + funp: + *mut Heap<*mut JSFunction>, + name: *const i8) { + _Z21JS_CallFunctionTracerP8JSTracerPN2JS4HeapIP10JSFunctionEEPKc(trc, + funp, + name) +} +pub unsafe extern "C" fn JS_CallUnbarrieredValueTracer(trc: *mut JSTracer, + valuep: *mut Value, + name: *const i8) { + _Z29JS_CallUnbarrieredValueTracerP8JSTracerPN2JS5ValueEPKc(trc, valuep, + name) +} +pub unsafe extern "C" fn JS_CallUnbarrieredIdTracer(trc: *mut JSTracer, + idp: *mut jsid, + name: *const i8) { + _Z26JS_CallUnbarrieredIdTracerP8JSTracerP4jsidPKc(trc, idp, name) +} +pub unsafe extern "C" fn JS_CallUnbarrieredObjectTracer(trc: *mut JSTracer, + objp: + *mut *mut JSObject, + name: *const i8) { + _Z30JS_CallUnbarrieredObjectTracerP8JSTracerPP8JSObjectPKc(trc, objp, + name) +} +pub unsafe extern "C" fn JS_CallUnbarrieredStringTracer(trc: *mut JSTracer, + strp: + *mut *mut JSString, + name: *const i8) { + _Z30JS_CallUnbarrieredStringTracerP8JSTracerPP8JSStringPKc(trc, strp, + name) +} +pub unsafe extern "C" fn JS_CallUnbarrieredScriptTracer(trc: *mut JSTracer, + scriptp: + *mut *mut JSScript, + name: *const i8) { + _Z30JS_CallUnbarrieredScriptTracerP8JSTracerPP8JSScriptPKc(trc, scriptp, + name) +} +pub unsafe extern "C" fn JS_CallTenuredObjectTracer(trc: *mut JSTracer, + objp: + *mut TenuredHeap<*mut JSObject>, + name: *const i8) { + _Z26JS_CallTenuredObjectTracerP8JSTracerPN2JS11TenuredHeapIP8JSObjectEEPKc(trc, + objp, + name) +} +pub unsafe extern "C" fn JS_TraceChildren(trc: *mut JSTracer, + thing: *mut ::libc::c_void, + kind: JSGCTraceKind) { + _Z16JS_TraceChildrenP8JSTracerPv13JSGCTraceKind(trc, thing, kind) +} +pub unsafe extern "C" fn JS_TraceRuntime(trc: *mut JSTracer) { + _Z15JS_TraceRuntimeP8JSTracer(trc) +} +pub unsafe extern "C" fn JS_TraceIncomingCCWs(trc: *mut JSTracer, + zones: *const ZoneSet) { + _Z20JS_TraceIncomingCCWsP8JSTracerRKN2js7HashSetIPN2JS4ZoneENS1_13DefaultHasherIS5_EENS1_17SystemAllocPolicyEEE(trc, + zones) +} +pub unsafe extern "C" fn JS_GetTraceThingInfo(buf: *mut i8, bufsize: u32, + trc: *mut JSTracer, + thing: *mut ::libc::c_void, + kind: JSGCTraceKind, + includeDetails: u8) { + _Z20JS_GetTraceThingInfoPcjP8JSTracerPv13JSGCTraceKindb(buf, bufsize, trc, + thing, kind, + includeDetails) +} +pub unsafe extern "C" fn CurrentThreadCanAccessRuntime(rt: *mut JSRuntime) + -> u8 { + _ZN2js29CurrentThreadCanAccessRuntimeEP9JSRuntime(rt) +} +pub unsafe extern "C" fn CurrentThreadCanAccessZone(zone: *mut Zone) -> u8 { + _ZN2js26CurrentThreadCanAccessZoneEPN2JS4ZoneE(zone) +} +pub unsafe extern "C" fn AssertGCThingHasType(cell: *mut Cell, + kind: JSGCTraceKind) { + _ZN2js2gc20AssertGCThingHasTypeEPNS0_4CellE13JSGCTraceKind(cell, kind) +} +pub unsafe extern "C" fn GetObjectZone(obj: *mut JSObject) -> *mut Zone { + _ZN2JS13GetObjectZoneEP8JSObject(obj) +} +pub unsafe extern "C" fn PrepareZoneForGC(zone: *mut Zone) { + _ZN2JS16PrepareZoneForGCEPNS_4ZoneE(zone) +} +pub unsafe extern "C" fn PrepareForFullGC(rt: *mut JSRuntime) { + _ZN2JS16PrepareForFullGCEP9JSRuntime(rt) +} +pub unsafe extern "C" fn PrepareForIncrementalGC(rt: *mut JSRuntime) { + _ZN2JS23PrepareForIncrementalGCEP9JSRuntime(rt) +} +pub unsafe extern "C" fn IsGCScheduled(rt: *mut JSRuntime) -> u8 { + _ZN2JS13IsGCScheduledEP9JSRuntime(rt) +} +pub unsafe extern "C" fn SkipZoneForGC(zone: *mut Zone) { + _ZN2JS13SkipZoneForGCEPNS_4ZoneE(zone) +} +pub unsafe extern "C" fn GCForReason(rt: *mut JSRuntime, + gckind: JSGCInvocationKind, + reason: Reason) { + _ZN2JS11GCForReasonEP9JSRuntime18JSGCInvocationKindNS_8gcreason6ReasonE(rt, + gckind, + reason) +} +pub unsafe extern "C" fn StartIncrementalGC(rt: *mut JSRuntime, + gckind: JSGCInvocationKind, + reason: Reason, millis: i64) { + _ZN2JS18StartIncrementalGCEP9JSRuntime18JSGCInvocationKindNS_8gcreason6ReasonEx(rt, + gckind, + reason, + millis) +} +pub unsafe extern "C" fn IncrementalGCSlice(rt: *mut JSRuntime, + reason: Reason, millis: i64) { + _ZN2JS18IncrementalGCSliceEP9JSRuntimeNS_8gcreason6ReasonEx(rt, reason, + millis) +} +pub unsafe extern "C" fn FinishIncrementalGC(rt: *mut JSRuntime, + reason: Reason) { + _ZN2JS19FinishIncrementalGCEP9JSRuntimeNS_8gcreason6ReasonE(rt, reason) +} +pub unsafe extern "C" fn SetGCSliceCallback(rt: *mut JSRuntime, + callback: GCSliceCallback) + -> GCSliceCallback { + _ZN2JS18SetGCSliceCallbackEP9JSRuntimePFvS1_NS_10GCProgressERKNS_13GCDescriptionEE(rt, + callback) +} +pub unsafe extern "C" fn DisableIncrementalGC(rt: *mut JSRuntime) { + _ZN2JS20DisableIncrementalGCEP9JSRuntime(rt) +} +pub unsafe extern "C" fn IsIncrementalGCEnabled(rt: *mut JSRuntime) -> u8 { + _ZN2JS22IsIncrementalGCEnabledEP9JSRuntime(rt) +} +pub unsafe extern "C" fn IsIncrementalGCInProgress(rt: *mut JSRuntime) -> u8 { + _ZN2JS25IsIncrementalGCInProgressEP9JSRuntime(rt) +} +pub unsafe extern "C" fn IsIncrementalBarrierNeeded(rt: *mut JSRuntime) + -> u8 { + _ZN2JS26IsIncrementalBarrierNeededEP9JSRuntime(rt) +} +pub unsafe extern "C" fn IsIncrementalBarrierNeeded1(cx: *mut JSContext) + -> u8 { + _ZN2JS26IsIncrementalBarrierNeededEP9JSContext(cx) +} +pub unsafe extern "C" fn IncrementalReferenceBarrier(thing: GCCellPtr) { + _ZN2JS27IncrementalReferenceBarrierENS_9GCCellPtrE(thing) +} +pub unsafe extern "C" fn IncrementalValueBarrier(v: *const Value) { + _ZN2JS23IncrementalValueBarrierERKNS_5ValueE(v) +} +pub unsafe extern "C" fn IncrementalObjectBarrier(obj: *mut JSObject) { + _ZN2JS24IncrementalObjectBarrierEP8JSObject(obj) +} +pub unsafe extern "C" fn WasIncrementalGC(rt: *mut JSRuntime) -> u8 { + _ZN2JS16WasIncrementalGCEP9JSRuntime(rt) +} +pub unsafe extern "C" fn IsGenerationalGCEnabled(rt: *mut JSRuntime) -> u8 { + _ZN2JS23IsGenerationalGCEnabledEP9JSRuntime(rt) +} +pub unsafe extern "C" fn GetGCNumber() -> u32 { _ZN2JS11GetGCNumberEv() } +pub unsafe extern "C" fn ShrinkGCBuffers(rt: *mut JSRuntime) { + _ZN2JS15ShrinkGCBuffersEP9JSRuntime(rt) +} +pub unsafe extern "C" fn UnmarkGrayGCThingRecursively(thing: GCCellPtr) + -> u8 { + _ZN2JS28UnmarkGrayGCThingRecursivelyENS_9GCCellPtrE(thing) +} +pub unsafe extern "C" fn PokeGC(rt: *mut JSRuntime) { + _ZN2JS6PokeGCEP9JSRuntime(rt) +} +pub unsafe extern "C" fn NotifyDidPaint(rt: *mut JSRuntime) { + _ZN2JS14NotifyDidPaintEP9JSRuntime(rt) +} +pub unsafe extern "C" fn isGCEnabled() -> u8 { _ZN2JS11isGCEnabledEv() } +pub unsafe extern "C" fn HeapCellPostBarrier(cellp: *mut *mut Cell) { + _ZN2JS19HeapCellPostBarrierEPPN2js2gc4CellE(cellp) +} +pub unsafe extern "C" fn HeapCellRelocate(cellp: *mut *mut Cell) { + _ZN2JS16HeapCellRelocateEPPN2js2gc4CellE(cellp) +} +pub unsafe extern "C" fn AssertGCThingMustBeTenured(obj: *mut JSObject) { + _ZN2JS26AssertGCThingMustBeTenuredEP8JSObject(obj) +} +pub unsafe extern "C" fn IsOptimizedPlaceholderMagicValue(v: *const Value) + -> u8 { + _ZN2JS32IsOptimizedPlaceholderMagicValueERKNS_5ValueE(v) +} +pub unsafe extern "C" fn SameType(lhs: *const Value, rhs: *const Value) + -> u8 { + _ZN2JS8SameTypeERKNS_5ValueES2_(lhs, rhs) +} +pub unsafe extern "C" fn HeapValuePostBarrier(valuep: *mut Value) { + _ZN2JS20HeapValuePostBarrierEPNS_5ValueE(valuep) +} +pub unsafe extern "C" fn HeapValueRelocate(valuep: *mut Value) { + _ZN2JS17HeapValueRelocateEPNS_5ValueE(valuep) +} +pub unsafe extern "C" fn JS_ComputeThis(cx: *mut JSContext, vp: *mut Value) + -> Value { + _Z14JS_ComputeThisP9JSContextPN2JS5ValueE(cx, vp) +} +pub unsafe extern "C" fn CallReceiverFromArgv(argv: *mut Value) + -> CallReceiver { + _ZN2JS20CallReceiverFromArgvEPNS_5ValueE(argv) +} +pub unsafe extern "C" fn CallReceiverFromVp(vp: *mut Value) -> CallReceiver { + _ZN2JS18CallReceiverFromVpEPNS_5ValueE(vp) +} +pub unsafe extern "C" fn CallArgsFromVp(argc: u32, vp: *mut Value) + -> CallArgs { + _ZN2JS14CallArgsFromVpEjPNS_5ValueE(argc, vp) +} +pub unsafe extern "C" fn CallArgsFromSp(argc: u32, sp: *mut Value) + -> CallArgs { + _ZN2JS14CallArgsFromSpEjPNS_5ValueE(argc, sp) +} +pub unsafe extern "C" fn JS_THIS(cx: *mut JSContext, vp: *mut Value) + -> Value { + _Z7JS_THISP9JSContextPN2JS5ValueE(cx, vp) +} +pub unsafe extern "C" fn INTERNED_STRING_TO_JSID(cx: *mut JSContext, + str: *mut JSString) -> jsid { + _Z23INTERNED_STRING_TO_JSIDP9JSContextP8JSString(cx, str) +} +pub unsafe extern "C" fn ObjectClassIs(obj: *mut JSObject, + classValue: ESClassValue, + cx: *mut JSContext) -> u8 { + _ZN2js13ObjectClassIsER8JSObjectNS_12ESClassValueEP9JSContext(obj, + classValue, + cx) +} +pub unsafe extern "C" fn IsObjectWithClass(v: *const Value, + classValue: ESClassValue, + cx: *mut JSContext) -> u8 { + _ZN2js17IsObjectWithClassERKN2JS5ValueENS_12ESClassValueEP9JSContext(v, + classValue, + cx) +} +pub unsafe extern "C" fn Unbox(cx: *mut JSContext, obj: HandleObject, + vp: MutableHandleValue) -> u8 { + _ZN2js5UnboxEP9JSContextN2JS6HandleIP8JSObjectEENS2_13MutableHandleINS2_5ValueEEE(cx, + obj, + vp) +} +pub unsafe extern "C" fn JS_HoldPrincipals(principals: *mut JSPrincipals) { + _Z17JS_HoldPrincipalsP12JSPrincipals(principals) +} +pub unsafe extern "C" fn JS_DropPrincipals(rt: *mut JSRuntime, + principals: *mut JSPrincipals) { + _Z17JS_DropPrincipalsP9JSRuntimeP12JSPrincipals(rt, principals) +} +pub unsafe extern "C" fn JS_SetSecurityCallbacks(rt: *mut JSRuntime, + callbacks: + *const JSSecurityCallbacks) { + _Z23JS_SetSecurityCallbacksP9JSRuntimePK19JSSecurityCallbacks(rt, + callbacks) +} +pub unsafe extern "C" fn JS_GetSecurityCallbacks(rt: *mut JSRuntime) + -> *const JSSecurityCallbacks { + _Z23JS_GetSecurityCallbacksP9JSRuntime(rt) +} +pub unsafe extern "C" fn JS_SetTrustedPrincipals(rt: *mut JSRuntime, + prin: *const JSPrincipals) { + _Z23JS_SetTrustedPrincipalsP9JSRuntimePK12JSPrincipals(rt, prin) +} +pub unsafe extern "C" fn JS_InitDestroyPrincipalsCallback(rt: *mut JSRuntime, + destroyPrincipals: + JSDestroyPrincipalsOp) { + _Z32JS_InitDestroyPrincipalsCallbackP9JSRuntimePFvP12JSPrincipalsE(rt, + destroyPrincipals) +} +pub unsafe extern "C" fn JS_StringHasBeenInterned(cx: *mut JSContext, + str: *mut JSString) -> u8 { + _Z24JS_StringHasBeenInternedP9JSContextP8JSString(cx, str) +} +pub unsafe extern "C" fn JS_CallOnce(once: *mut JSCallOnceType, + func: JSInitCallback) -> u8 { + _Z11JS_CallOnceP14PRCallOnceTypePFbvE(once, func) +} +pub unsafe extern "C" fn JS_Now() -> i64 { _Z6JS_Nowv() } +pub unsafe extern "C" fn JS_GetNaNValue(cx: *mut JSContext) -> Value { + _Z14JS_GetNaNValueP9JSContext(cx) +} +pub unsafe extern "C" fn JS_GetNegativeInfinityValue(cx: *mut JSContext) + -> Value { + _Z27JS_GetNegativeInfinityValueP9JSContext(cx) +} +pub unsafe extern "C" fn JS_GetPositiveInfinityValue(cx: *mut JSContext) + -> Value { + _Z27JS_GetPositiveInfinityValueP9JSContext(cx) +} +pub unsafe extern "C" fn JS_GetEmptyStringValue(cx: *mut JSContext) -> Value { + _Z22JS_GetEmptyStringValueP9JSContext(cx) +} +pub unsafe extern "C" fn JS_GetEmptyString(rt: *mut JSRuntime) + -> *mut JSString { + _Z17JS_GetEmptyStringP9JSRuntime(rt) +} +pub unsafe extern "C" fn JS_GetCompartmentStats(rt: *mut JSRuntime, + stats: + *mut CompartmentStatsVector) + -> u8 { + _Z22JS_GetCompartmentStatsP9JSRuntimeRN2js6VectorI20CompartmentTimeStatsLj0ENS1_17SystemAllocPolicyEEE(rt, + stats) +} +pub unsafe extern "C" fn JS_ValueToObject(cx: *mut JSContext, v: HandleValue, + objp: MutableHandleObject) -> u8 { + _Z16JS_ValueToObjectP9JSContextN2JS6HandleINS1_5ValueEEENS1_13MutableHandleIP8JSObjectEE(cx, + v, + objp) +} +pub unsafe extern "C" fn JS_ValueToFunction(cx: *mut JSContext, + v: HandleValue) + -> *mut JSFunction { + _Z18JS_ValueToFunctionP9JSContextN2JS6HandleINS1_5ValueEEE(cx, v) +} +pub unsafe extern "C" fn JS_ValueToConstructor(cx: *mut JSContext, + v: HandleValue) + -> *mut JSFunction { + _Z21JS_ValueToConstructorP9JSContextN2JS6HandleINS1_5ValueEEE(cx, v) +} +pub unsafe extern "C" fn JS_ValueToSource(cx: *mut JSContext, + v: Handle) -> *mut JSString { + _Z16JS_ValueToSourceP9JSContextN2JS6HandleINS1_5ValueEEE(cx, v) +} +pub unsafe extern "C" fn JS_DoubleIsInt32(d: f64, ip: *mut i32) -> u8 { + _Z16JS_DoubleIsInt32dPi(d, ip) +} +pub unsafe extern "C" fn JS_TypeOfValue(cx: *mut JSContext, v: Handle) + -> JSType { + _Z14JS_TypeOfValueP9JSContextN2JS6HandleINS1_5ValueEEE(cx, v) +} +pub unsafe extern "C" fn JS_StrictlyEqual(cx: *mut JSContext, + v1: Handle, + v2: Handle, equal: *mut u8) + -> u8 { + _Z16JS_StrictlyEqualP9JSContextN2JS6HandleINS1_5ValueEEES4_Pb(cx, v1, v2, + equal) +} +pub unsafe extern "C" fn JS_LooselyEqual(cx: *mut JSContext, + v1: Handle, v2: Handle, + equal: *mut u8) -> u8 { + _Z15JS_LooselyEqualP9JSContextN2JS6HandleINS1_5ValueEEES4_Pb(cx, v1, v2, + equal) +} +pub unsafe extern "C" fn JS_SameValue(cx: *mut JSContext, v1: Handle, + v2: Handle, same: *mut u8) + -> u8 { + _Z12JS_SameValueP9JSContextN2JS6HandleINS1_5ValueEEES4_Pb(cx, v1, v2, + same) +} +pub unsafe extern "C" fn JS_IsBuiltinEvalFunction(fun: *mut JSFunction) + -> u8 { + _Z24JS_IsBuiltinEvalFunctionP10JSFunction(fun) +} +pub unsafe extern "C" fn JS_IsBuiltinFunctionConstructor(fun: *mut JSFunction) + -> u8 { + _Z31JS_IsBuiltinFunctionConstructorP10JSFunction(fun) +} +pub unsafe extern "C" fn JS_Init() -> u8 { _Z7JS_Initv() } +pub unsafe extern "C" fn JS_ShutDown() { _Z11JS_ShutDownv() } +pub unsafe extern "C" fn JS_NewRuntime(maxbytes: u32, maxNurseryBytes: u32, + parentRuntime: *mut JSRuntime) + -> *mut JSRuntime { + _Z13JS_NewRuntimejjP9JSRuntime(maxbytes, maxNurseryBytes, parentRuntime) +} +pub unsafe extern "C" fn JS_DestroyRuntime(rt: *mut JSRuntime) { + _Z17JS_DestroyRuntimeP9JSRuntime(rt) +} +pub unsafe extern "C" fn JS_SetICUMemoryFunctions(allocFn: JS_ICUAllocFn, + reallocFn: JS_ICUReallocFn, + freeFn: JS_ICUFreeFn) + -> u8 { + _Z24JS_SetICUMemoryFunctionsPFPvPKvjEPFS_S1_S_jEPFvS1_S_E(allocFn, + reallocFn, + freeFn) +} +pub unsafe extern "C" fn JS_GetRuntimePrivate(rt: *mut JSRuntime) + -> *mut ::libc::c_void { + _Z20JS_GetRuntimePrivateP9JSRuntime(rt) +} +pub unsafe extern "C" fn JS_GetParentRuntime(cx: *mut JSContext) + -> *mut JSRuntime { + _Z19JS_GetParentRuntimeP9JSContext(cx) +} +pub unsafe extern "C" fn JS_SetRuntimePrivate(rt: *mut JSRuntime, + data: *mut ::libc::c_void) { + _Z20JS_SetRuntimePrivateP9JSRuntimePv(rt, data) +} +pub unsafe extern "C" fn JS_BeginRequest(cx: *mut JSContext) { + _Z15JS_BeginRequestP9JSContext(cx) +} +pub unsafe extern "C" fn JS_EndRequest(cx: *mut JSContext) { + _Z13JS_EndRequestP9JSContext(cx) +} +pub unsafe extern "C" fn AssertHeapIsIdle(rt: *mut JSRuntime) { + _ZN2js16AssertHeapIsIdleEP9JSRuntime(rt) +} +pub unsafe extern "C" fn AssertHeapIsIdle1(cx: *mut JSContext) { + _ZN2js16AssertHeapIsIdleEP9JSContext(cx) +} +pub unsafe extern "C" fn JS_SetContextCallback(rt: *mut JSRuntime, + cxCallback: JSContextCallback, + data: *mut ::libc::c_void) { + _Z21JS_SetContextCallbackP9JSRuntimePFbP9JSContextjPvES3_(rt, cxCallback, + data) +} +#[cfg(target_pointer_width = "64")] +pub unsafe extern "C" fn JS_NewContext(rt: *mut JSRuntime, + stackChunkSize: ::libc::size_t) + -> *mut JSContext { + _Z13JS_NewContextP9JSRuntimem(rt, stackChunkSize) +} +#[cfg(target_pointer_width = "32")] +pub unsafe extern "C" fn JS_NewContext(rt: *mut JSRuntime, + stackChunkSize: ::libc::size_t) + -> *mut JSContext { + _Z13JS_NewContextP9JSRuntimej(rt, stackChunkSize) +} +pub unsafe extern "C" fn JS_DestroyContext(cx: *mut JSContext) { + _Z17JS_DestroyContextP9JSContext(cx) +} +pub unsafe extern "C" fn JS_DestroyContextNoGC(cx: *mut JSContext) { + _Z21JS_DestroyContextNoGCP9JSContext(cx) +} +pub unsafe extern "C" fn JS_GetContextPrivate(cx: *mut JSContext) + -> *mut ::libc::c_void { + _Z20JS_GetContextPrivateP9JSContext(cx) +} +pub unsafe extern "C" fn JS_SetContextPrivate(cx: *mut JSContext, + data: *mut ::libc::c_void) { + _Z20JS_SetContextPrivateP9JSContextPv(cx, data) +} +pub unsafe extern "C" fn JS_GetSecondContextPrivate(cx: *mut JSContext) + -> *mut ::libc::c_void { + _Z26JS_GetSecondContextPrivateP9JSContext(cx) +} +pub unsafe extern "C" fn JS_SetSecondContextPrivate(cx: *mut JSContext, + data: + *mut ::libc::c_void) { + _Z26JS_SetSecondContextPrivateP9JSContextPv(cx, data) +} +pub unsafe extern "C" fn JS_ContextIterator(rt: *mut JSRuntime, + iterp: *mut *mut JSContext) + -> *mut JSContext { + _Z18JS_ContextIteratorP9JSRuntimePP9JSContext(rt, iterp) +} +pub unsafe extern "C" fn JS_GetVersion(cx: *mut JSContext) -> JSVersion { + _Z13JS_GetVersionP9JSContext(cx) +} +pub unsafe extern "C" fn JS_SetVersionForCompartment(compartment: + *mut JSCompartment, + version: JSVersion) { + _Z27JS_SetVersionForCompartmentP13JSCompartment9JSVersion(compartment, + version) +} +pub unsafe extern "C" fn JS_VersionToString(version: JSVersion) -> *const i8 { + _Z18JS_VersionToString9JSVersion(version) +} +pub unsafe extern "C" fn JS_StringToVersion(string: *const i8) -> JSVersion { + _Z18JS_StringToVersionPKc(string) +} +pub unsafe extern "C" fn RuntimeOptionsRef(rt: *mut JSRuntime) + -> *mut RuntimeOptions { + _ZN2JS17RuntimeOptionsRefEP9JSRuntime(rt) +} +pub unsafe extern "C" fn RuntimeOptionsRef1(cx: *mut JSContext) + -> *mut RuntimeOptions { + _ZN2JS17RuntimeOptionsRefEP9JSContext(cx) +} +pub unsafe extern "C" fn ContextOptionsRef(cx: *mut JSContext) + -> *mut ContextOptions { + _ZN2JS17ContextOptionsRefEP9JSContext(cx) +} +pub unsafe extern "C" fn JS_GetImplementationVersion() -> *const i8 { + _Z27JS_GetImplementationVersionv() +} +pub unsafe extern "C" fn JS_SetDestroyCompartmentCallback(rt: *mut JSRuntime, + callback: + JSDestroyCompartmentCallback) { + _Z32JS_SetDestroyCompartmentCallbackP9JSRuntimePFvP8JSFreeOpP13JSCompartmentE(rt, + callback) +} +pub unsafe extern "C" fn JS_SetDestroyZoneCallback(rt: *mut JSRuntime, + callback: JSZoneCallback) { + _Z25JS_SetDestroyZoneCallbackP9JSRuntimePFvPN2JS4ZoneEE(rt, callback) +} +pub unsafe extern "C" fn JS_SetSweepZoneCallback(rt: *mut JSRuntime, + callback: JSZoneCallback) { + _Z23JS_SetSweepZoneCallbackP9JSRuntimePFvPN2JS4ZoneEE(rt, callback) +} +pub unsafe extern "C" fn JS_SetCompartmentNameCallback(rt: *mut JSRuntime, + callback: + JSCompartmentNameCallback) { + _Z29JS_SetCompartmentNameCallbackP9JSRuntimePFvS0_P13JSCompartmentPcjE(rt, + callback) +} +pub unsafe extern "C" fn JS_SetWrapObjectCallbacks(rt: *mut JSRuntime, + callbacks: + *const JSWrapObjectCallbacks) { + _Z25JS_SetWrapObjectCallbacksP9JSRuntimePK21JSWrapObjectCallbacks(rt, + callbacks) +} +pub unsafe extern "C" fn JS_SetCompartmentPrivate(compartment: + *mut JSCompartment, + data: *mut ::libc::c_void) { + _Z24JS_SetCompartmentPrivateP13JSCompartmentPv(compartment, data) +} +pub unsafe extern "C" fn JS_GetCompartmentPrivate(compartment: + *mut JSCompartment) + -> *mut ::libc::c_void { + _Z24JS_GetCompartmentPrivateP13JSCompartment(compartment) +} +pub unsafe extern "C" fn JS_SetZoneUserData(zone: *mut Zone, + data: *mut ::libc::c_void) { + _Z18JS_SetZoneUserDataPN2JS4ZoneEPv(zone, data) +} +pub unsafe extern "C" fn JS_GetZoneUserData(zone: *mut Zone) + -> *mut ::libc::c_void { + _Z18JS_GetZoneUserDataPN2JS4ZoneE(zone) +} +pub unsafe extern "C" fn JS_WrapObject(cx: *mut JSContext, + objp: MutableHandleObject) -> u8 { + _Z13JS_WrapObjectP9JSContextN2JS13MutableHandleIP8JSObjectEE(cx, objp) +} +pub unsafe extern "C" fn JS_WrapValue(cx: *mut JSContext, + vp: MutableHandleValue) -> u8 { + _Z12JS_WrapValueP9JSContextN2JS13MutableHandleINS1_5ValueEEE(cx, vp) +} +pub unsafe extern "C" fn JS_TransplantObject(cx: *mut JSContext, + origobj: HandleObject, + target: HandleObject) + -> *mut JSObject { + _Z19JS_TransplantObjectP9JSContextN2JS6HandleIP8JSObjectEES5_(cx, origobj, + target) +} +pub unsafe extern "C" fn JS_RefreshCrossCompartmentWrappers(cx: + *mut JSContext, + obj: + Handle<*mut JSObject>) + -> u8 { + _Z34JS_RefreshCrossCompartmentWrappersP9JSContextN2JS6HandleIP8JSObjectEE(cx, + obj) +} +pub unsafe extern "C" fn JS_EnterCompartment(cx: *mut JSContext, + target: *mut JSObject) + -> *mut JSCompartment { + _Z19JS_EnterCompartmentP9JSContextP8JSObject(cx, target) +} +pub unsafe extern "C" fn JS_LeaveCompartment(cx: *mut JSContext, + oldCompartment: + *mut JSCompartment) { + _Z19JS_LeaveCompartmentP9JSContextP13JSCompartment(cx, oldCompartment) +} +pub unsafe extern "C" fn JS_IterateCompartments(rt: *mut JSRuntime, + data: *mut ::libc::c_void, + compartmentCallback: + JSIterateCompartmentCallback) { + _Z22JS_IterateCompartmentsP9JSRuntimePvPFvS0_S1_P13JSCompartmentE(rt, + data, + compartmentCallback) +} +pub unsafe extern "C" fn JS_InitStandardClasses(cx: *mut JSContext, + obj: Handle<*mut JSObject>) + -> u8 { + _Z22JS_InitStandardClassesP9JSContextN2JS6HandleIP8JSObjectEE(cx, obj) +} +pub unsafe extern "C" fn JS_ResolveStandardClass(cx: *mut JSContext, + obj: HandleObject, + id: HandleId, + resolved: *mut u8) -> u8 { + _Z23JS_ResolveStandardClassP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEEPb(cx, + obj, + id, + resolved) +} +pub unsafe extern "C" fn JS_EnumerateStandardClasses(cx: *mut JSContext, + obj: HandleObject) + -> u8 { + _Z27JS_EnumerateStandardClassesP9JSContextN2JS6HandleIP8JSObjectEE(cx, + obj) +} +pub unsafe extern "C" fn JS_GetClassObject(cx: *mut JSContext, + key: JSProtoKey, + objp: MutableHandle<*mut JSObject>) + -> u8 { + _Z17JS_GetClassObjectP9JSContext10JSProtoKeyN2JS13MutableHandleIP8JSObjectEE(cx, + key, + objp) +} +pub unsafe extern "C" fn JS_GetClassPrototype(cx: *mut JSContext, + key: JSProtoKey, + objp: + MutableHandle<*mut JSObject>) + -> u8 { + _Z20JS_GetClassPrototypeP9JSContext10JSProtoKeyN2JS13MutableHandleIP8JSObjectEE(cx, + key, + objp) +} +pub unsafe extern "C" fn IdentifyStandardInstance(obj: *mut JSObject) + -> JSProtoKey { + _ZN2JS24IdentifyStandardInstanceEP8JSObject(obj) +} +pub unsafe extern "C" fn IdentifyStandardPrototype(obj: *mut JSObject) + -> JSProtoKey { + _ZN2JS25IdentifyStandardPrototypeEP8JSObject(obj) +} +pub unsafe extern "C" fn IdentifyStandardInstanceOrPrototype(obj: + *mut JSObject) + -> JSProtoKey { + _ZN2JS35IdentifyStandardInstanceOrPrototypeEP8JSObject(obj) +} +pub unsafe extern "C" fn IdentifyStandardConstructor(obj: *mut JSObject) + -> JSProtoKey { + _ZN2JS27IdentifyStandardConstructorEP8JSObject(obj) +} +pub unsafe extern "C" fn ProtoKeyToId(cx: *mut JSContext, key: JSProtoKey, + idp: MutableHandleId) { + _ZN2JS12ProtoKeyToIdEP9JSContext10JSProtoKeyNS_13MutableHandleI4jsidEE(cx, + key, + idp) +} +pub unsafe extern "C" fn JS_IdToProtoKey(cx: *mut JSContext, id: HandleId) + -> JSProtoKey { + _Z15JS_IdToProtoKeyP9JSContextN2JS6HandleI4jsidEE(cx, id) +} +pub unsafe extern "C" fn JS_GetFunctionPrototype(cx: *mut JSContext, + forObj: HandleObject) + -> *mut JSObject { + _Z23JS_GetFunctionPrototypeP9JSContextN2JS6HandleIP8JSObjectEE(cx, forObj) +} +pub unsafe extern "C" fn JS_GetObjectPrototype(cx: *mut JSContext, + forObj: HandleObject) + -> *mut JSObject { + _Z21JS_GetObjectPrototypeP9JSContextN2JS6HandleIP8JSObjectEE(cx, forObj) +} +pub unsafe extern "C" fn JS_GetArrayPrototype(cx: *mut JSContext, + forObj: HandleObject) + -> *mut JSObject { + _Z20JS_GetArrayPrototypeP9JSContextN2JS6HandleIP8JSObjectEE(cx, forObj) +} +pub unsafe extern "C" fn JS_GetErrorPrototype(cx: *mut JSContext) + -> *mut JSObject { + _Z20JS_GetErrorPrototypeP9JSContext(cx) +} +pub unsafe extern "C" fn JS_GetGlobalForObject(cx: *mut JSContext, + obj: *mut JSObject) + -> *mut JSObject { + _Z21JS_GetGlobalForObjectP9JSContextP8JSObject(cx, obj) +} +pub unsafe extern "C" fn JS_IsGlobalObject(obj: *mut JSObject) -> u8 { + _Z17JS_IsGlobalObjectP8JSObject(obj) +} +pub unsafe extern "C" fn JS_GetGlobalForCompartmentOrNull(cx: *mut JSContext, + c: + *mut JSCompartment) + -> *mut JSObject { + _Z32JS_GetGlobalForCompartmentOrNullP9JSContextP13JSCompartment(cx, c) +} +pub unsafe extern "C" fn CurrentGlobalOrNull(cx: *mut JSContext) + -> *mut JSObject { + _ZN2JS19CurrentGlobalOrNullEP9JSContext(cx) +} +pub unsafe extern "C" fn JS_InitReflect(cx: *mut JSContext, + global: HandleObject) + -> *mut JSObject { + _Z14JS_InitReflectP9JSContextN2JS6HandleIP8JSObjectEE(cx, global) +} +pub unsafe extern "C" fn JS_DefineProfilingFunctions(cx: *mut JSContext, + obj: HandleObject) + -> u8 { + _Z27JS_DefineProfilingFunctionsP9JSContextN2JS6HandleIP8JSObjectEE(cx, + obj) +} +pub unsafe extern "C" fn JS_DefineDebuggerObject(cx: *mut JSContext, + obj: HandleObject) -> u8 { + _Z23JS_DefineDebuggerObjectP9JSContextN2JS6HandleIP8JSObjectEE(cx, obj) +} +pub unsafe extern "C" fn JS_InitCTypesClass(cx: *mut JSContext, + global: HandleObject) -> u8 { + _Z18JS_InitCTypesClassP9JSContextN2JS6HandleIP8JSObjectEE(cx, global) +} +pub unsafe extern "C" fn JS_SetCTypesCallbacks(ctypesObj: *mut JSObject, + callbacks: + *const JSCTypesCallbacks) { + _Z21JS_SetCTypesCallbacksP8JSObjectPK17JSCTypesCallbacks(ctypesObj, + callbacks) +} +pub unsafe extern "C" fn JS_malloc(cx: *mut JSContext, nbytes: u32) + -> *mut ::libc::c_void { + _Z9JS_mallocP9JSContextj(cx, nbytes) +} +pub unsafe extern "C" fn JS_realloc(cx: *mut JSContext, + p: *mut ::libc::c_void, oldBytes: u32, + newBytes: u32) -> *mut ::libc::c_void { + _Z10JS_reallocP9JSContextPvjj(cx, p, oldBytes, newBytes) +} +pub unsafe extern "C" fn JS_free(cx: *mut JSContext, p: *mut ::libc::c_void) { + _Z7JS_freeP9JSContextPv(cx, p) +} +pub unsafe extern "C" fn JS_freeop(fop: *mut JSFreeOp, + p: *mut ::libc::c_void) { + _Z9JS_freeopP8JSFreeOpPv(fop, p) +} +pub unsafe extern "C" fn JS_GetDefaultFreeOp(rt: *mut JSRuntime) + -> *mut JSFreeOp { + _Z19JS_GetDefaultFreeOpP9JSRuntime(rt) +} +pub unsafe extern "C" fn JS_updateMallocCounter(cx: *mut JSContext, + nbytes: u32) { + _Z22JS_updateMallocCounterP9JSContextj(cx, nbytes) +} +pub unsafe extern "C" fn JS_strdup(cx: *mut JSContext, s: *const i8) + -> *mut i8 { + _Z9JS_strdupP9JSContextPKc(cx, s) +} +pub unsafe extern "C" fn JS_strdup1(rt: *mut JSRuntime, s: *const i8) + -> *mut i8 { + _Z9JS_strdupP9JSRuntimePKc(rt, s) +} +pub unsafe extern "C" fn JS_AddExtraGCRootsTracer(rt: *mut JSRuntime, + traceOp: JSTraceDataOp, + data: *mut ::libc::c_void) + -> u8 { + _Z24JS_AddExtraGCRootsTracerP9JSRuntimePFvP8JSTracerPvES3_(rt, traceOp, + data) +} +pub unsafe extern "C" fn JS_RemoveExtraGCRootsTracer(rt: *mut JSRuntime, + traceOp: JSTraceDataOp, + data: + *mut ::libc::c_void) { + _Z27JS_RemoveExtraGCRootsTracerP9JSRuntimePFvP8JSTracerPvES3_(rt, traceOp, + data) +} +pub unsafe extern "C" fn JS_GC(rt: *mut JSRuntime) { _Z5JS_GCP9JSRuntime(rt) } +pub unsafe extern "C" fn JS_MaybeGC(cx: *mut JSContext) { + _Z10JS_MaybeGCP9JSContext(cx) +} +pub unsafe extern "C" fn JS_SetGCCallback(rt: *mut JSRuntime, + cb: JSGCCallback, + data: *mut ::libc::c_void) { + _Z16JS_SetGCCallbackP9JSRuntimePFvS0_10JSGCStatusPvES2_(rt, cb, data) +} +pub unsafe extern "C" fn JS_AddFinalizeCallback(rt: *mut JSRuntime, + cb: JSFinalizeCallback, + data: *mut ::libc::c_void) + -> u8 { + _Z22JS_AddFinalizeCallbackP9JSRuntimePFvP8JSFreeOp16JSFinalizeStatusbPvES4_(rt, + cb, + data) +} +pub unsafe extern "C" fn JS_RemoveFinalizeCallback(rt: *mut JSRuntime, + cb: JSFinalizeCallback) { + _Z25JS_RemoveFinalizeCallbackP9JSRuntimePFvP8JSFreeOp16JSFinalizeStatusbPvE(rt, + cb) +} +pub unsafe extern "C" fn JS_IsGCMarkingTracer(trc: *mut JSTracer) -> u8 { + _Z20JS_IsGCMarkingTracerP8JSTracer(trc) +} +pub unsafe extern "C" fn JS_AddWeakPointerCallback(rt: *mut JSRuntime, + cb: JSWeakPointerCallback, + data: *mut ::libc::c_void) + -> u8 { + _Z25JS_AddWeakPointerCallbackP9JSRuntimePFvS0_PvES1_(rt, cb, data) +} +pub unsafe extern "C" fn JS_RemoveWeakPointerCallback(rt: *mut JSRuntime, + cb: + JSWeakPointerCallback) { + _Z28JS_RemoveWeakPointerCallbackP9JSRuntimePFvS0_PvE(rt, cb) +} +pub unsafe extern "C" fn JS_UpdateWeakPointerAfterGC(objp: + *mut Heap<*mut JSObject>) { + _Z27JS_UpdateWeakPointerAfterGCPN2JS4HeapIP8JSObjectEE(objp) +} +pub unsafe extern "C" fn JS_UpdateWeakPointerAfterGCUnbarriered(objp: + *mut *mut JSObject) { + _Z38JS_UpdateWeakPointerAfterGCUnbarrieredPP8JSObject(objp) +} +pub unsafe extern "C" fn JS_SetGCParameter(rt: *mut JSRuntime, + key: JSGCParamKey, value: u32) { + _Z17JS_SetGCParameterP9JSRuntime12JSGCParamKeyj(rt, key, value) +} +pub unsafe extern "C" fn JS_GetGCParameter(rt: *mut JSRuntime, + key: JSGCParamKey) -> u32 { + _Z17JS_GetGCParameterP9JSRuntime12JSGCParamKey(rt, key) +} +pub unsafe extern "C" fn JS_SetGCParameterForThread(cx: *mut JSContext, + key: JSGCParamKey, + value: u32) { + _Z26JS_SetGCParameterForThreadP9JSContext12JSGCParamKeyj(cx, key, value) +} +pub unsafe extern "C" fn JS_GetGCParameterForThread(cx: *mut JSContext, + key: JSGCParamKey) + -> u32 { + _Z26JS_GetGCParameterForThreadP9JSContext12JSGCParamKey(cx, key) +} +pub unsafe extern "C" fn JS_SetGCParametersBasedOnAvailableMemory(rt: + *mut JSRuntime, + availMem: + u32) { + _Z40JS_SetGCParametersBasedOnAvailableMemoryP9JSRuntimej(rt, availMem) +} +pub unsafe extern "C" fn JS_NewExternalString(cx: *mut JSContext, + chars: *const i16, length: u32, + fin: *const JSStringFinalizer) + -> *mut JSString { + _Z20JS_NewExternalStringP9JSContextPKDsjPK17JSStringFinalizer(cx, chars, + length, fin) +} +pub unsafe extern "C" fn JS_IsExternalString(str: *mut JSString) -> u8 { + _Z19JS_IsExternalStringP8JSString(str) +} +pub unsafe extern "C" fn JS_GetExternalStringFinalizer(str: *mut JSString) + -> *const JSStringFinalizer { + _Z29JS_GetExternalStringFinalizerP8JSString(str) +} +pub unsafe extern "C" fn JS_SetNativeStackQuota(cx: *mut JSRuntime, + systemCodeStackSize: u32, + trustedScriptStackSize: u32, + untrustedScriptStackSize: + u32) { + _Z22JS_SetNativeStackQuotaP9JSRuntimejjj(cx, systemCodeStackSize, + trustedScriptStackSize, + untrustedScriptStackSize) +} +pub unsafe extern "C" fn JS_IdArrayLength(cx: *mut JSContext, + ida: *mut JSIdArray) -> i32 { + _Z16JS_IdArrayLengthP9JSContextP9JSIdArray(cx, ida) +} +pub unsafe extern "C" fn JS_IdArrayGet(cx: *mut JSContext, + ida: *mut JSIdArray, index: u32) + -> jsid { + _Z13JS_IdArrayGetP9JSContextP9JSIdArrayj(cx, ida, index) +} +pub unsafe extern "C" fn JS_DestroyIdArray(cx: *mut JSContext, + ida: *mut JSIdArray) { + _Z17JS_DestroyIdArrayP9JSContextP9JSIdArray(cx, ida) +} +pub unsafe extern "C" fn JS_ValueToId(cx: *mut JSContext, v: HandleValue, + idp: MutableHandleId) -> u8 { + _Z12JS_ValueToIdP9JSContextN2JS6HandleINS1_5ValueEEENS1_13MutableHandleI4jsidEE(cx, + v, + idp) +} +pub unsafe extern "C" fn JS_StringToId(cx: *mut JSContext, s: HandleString, + idp: MutableHandleId) -> u8 { + _Z13JS_StringToIdP9JSContextN2JS6HandleIP8JSStringEENS1_13MutableHandleI4jsidEE(cx, + s, + idp) +} +pub unsafe extern "C" fn JS_IdToValue(cx: *mut JSContext, id: jsid, + vp: MutableHandle) -> u8 { + _Z12JS_IdToValueP9JSContext4jsidN2JS13MutableHandleINS2_5ValueEEE(cx, id, + vp) +} +pub unsafe extern "C" fn JS_DefaultValue(cx: *mut JSContext, + obj: Handle<*mut JSObject>, + hint: JSType, + vp: MutableHandle) -> u8 { + _Z15JS_DefaultValueP9JSContextN2JS6HandleIP8JSObjectEE6JSTypeNS1_13MutableHandleINS1_5ValueEEE(cx, + obj, + hint, + vp) +} +pub unsafe extern "C" fn JS_PropertyStub(cx: *mut JSContext, + obj: HandleObject, id: HandleId, + vp: MutableHandleValue) -> u8 { + _Z15JS_PropertyStubP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEENS1_13MutableHandleINS1_5ValueEEE(cx, + obj, + id, + vp) +} +pub unsafe extern "C" fn JS_StrictPropertyStub(cx: *mut JSContext, + obj: HandleObject, + id: HandleId, + vp: MutableHandleValue, + result: *mut ObjectOpResult) + -> u8 { + _Z21JS_StrictPropertyStubP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEENS1_13MutableHandleINS1_5ValueEEERNS1_14ObjectOpResultE(cx, + obj, + id, + vp, + result) +} +pub unsafe extern "C" fn CheckIsNative(native: JSNative) -> i32 { + _ZN2JS6detail13CheckIsNativeEPFbP9JSContextjPNS_5ValueEE(native) +} +pub unsafe extern "C" fn CheckIsGetterOp(op: JSGetterOp) -> i32 { + _ZN2JS6detail15CheckIsGetterOpEPFbP9JSContextNS_6HandleIP8JSObjectEENS3_I4jsidEENS_13MutableHandleINS_5ValueEEEE(op) +} +pub unsafe extern "C" fn CheckIsSetterOp(op: JSSetterOp) -> i32 { + _ZN2JS6detail15CheckIsSetterOpEPFbP9JSContextNS_6HandleIP8JSObjectEENS3_I4jsidEENS_13MutableHandleINS_5ValueEEERNS_14ObjectOpResultEE(op) +} +pub unsafe extern "C" fn JS_InitClass(cx: *mut JSContext, obj: HandleObject, + parent_proto: HandleObject, + clasp: *const JSClass, + constructor: JSNative, nargs: u32, + ps: *const JSPropertySpec, + fs: *const JSFunctionSpec, + static_ps: *const JSPropertySpec, + static_fs: *const JSFunctionSpec) + -> *mut JSObject { + _Z12JS_InitClassP9JSContextN2JS6HandleIP8JSObjectEES5_PK7JSClassPFbS0_jPNS1_5ValueEEjPK14JSPropertySpecPK14JSFunctionSpecSF_SI_(cx, + obj, + parent_proto, + clasp, + constructor, + nargs, + ps, + fs, + static_ps, + static_fs) +} +pub unsafe extern "C" fn JS_LinkConstructorAndPrototype(cx: *mut JSContext, + ctor: + Handle<*mut JSObject>, + proto: + Handle<*mut JSObject>) + -> u8 { + _Z30JS_LinkConstructorAndPrototypeP9JSContextN2JS6HandleIP8JSObjectEES5_(cx, + ctor, + proto) +} +pub unsafe extern "C" fn JS_GetClass(obj: *mut JSObject) -> *const JSClass { + _Z11JS_GetClassP8JSObject(obj) +} +pub unsafe extern "C" fn JS_InstanceOf(cx: *mut JSContext, + obj: Handle<*mut JSObject>, + clasp: *const JSClass, + args: *mut CallArgs) -> u8 { + _Z13JS_InstanceOfP9JSContextN2JS6HandleIP8JSObjectEEPK7JSClassPNS1_8CallArgsE(cx, + obj, + clasp, + args) +} +pub unsafe extern "C" fn JS_HasInstance(cx: *mut JSContext, + obj: Handle<*mut JSObject>, + v: Handle, bp: *mut u8) -> u8 { + _Z14JS_HasInstanceP9JSContextN2JS6HandleIP8JSObjectEENS2_INS1_5ValueEEEPb(cx, + obj, + v, + bp) +} +pub unsafe extern "C" fn JS_GetPrivate(obj: *mut JSObject) + -> *mut ::libc::c_void { + _Z13JS_GetPrivateP8JSObject(obj) +} +pub unsafe extern "C" fn JS_SetPrivate(obj: *mut JSObject, + data: *mut ::libc::c_void) { + _Z13JS_SetPrivateP8JSObjectPv(obj, data) +} +pub unsafe extern "C" fn JS_GetInstancePrivate(cx: *mut JSContext, + obj: Handle<*mut JSObject>, + clasp: *const JSClass, + args: *mut CallArgs) + -> *mut ::libc::c_void { + _Z21JS_GetInstancePrivateP9JSContextN2JS6HandleIP8JSObjectEEPK7JSClassPNS1_8CallArgsE(cx, + obj, + clasp, + args) +} +pub unsafe extern "C" fn JS_GetPrototype(cx: *mut JSContext, + obj: HandleObject, + protop: MutableHandleObject) -> u8 { + _Z15JS_GetPrototypeP9JSContextN2JS6HandleIP8JSObjectEENS1_13MutableHandleIS4_EE(cx, + obj, + protop) +} +pub unsafe extern "C" fn JS_SetPrototype(cx: *mut JSContext, + obj: HandleObject, + proto: HandleObject) -> u8 { + _Z15JS_SetPrototypeP9JSContextN2JS6HandleIP8JSObjectEES5_(cx, obj, proto) +} +pub unsafe extern "C" fn JS_GetConstructor(cx: *mut JSContext, + proto: Handle<*mut JSObject>) + -> *mut JSObject { + _Z17JS_GetConstructorP9JSContextN2JS6HandleIP8JSObjectEE(cx, proto) +} +pub unsafe extern "C" fn CompartmentOptionsRef(compartment: + *mut JSCompartment) + -> *mut CompartmentOptions { + _ZN2JS21CompartmentOptionsRefEP13JSCompartment(compartment) +} +pub unsafe extern "C" fn CompartmentOptionsRef1(obj: *mut JSObject) + -> *mut CompartmentOptions { + _ZN2JS21CompartmentOptionsRefEP8JSObject(obj) +} +pub unsafe extern "C" fn CompartmentOptionsRef2(cx: *mut JSContext) + -> *mut CompartmentOptions { + _ZN2JS21CompartmentOptionsRefEP9JSContext(cx) +} +pub unsafe extern "C" fn JS_NewGlobalObject(cx: *mut JSContext, + clasp: *const JSClass, + principals: *mut JSPrincipals, + hookOption: OnNewGlobalHookOption, + options: + *const CompartmentOptions) + -> *mut JSObject { + _Z18JS_NewGlobalObjectP9JSContextPK7JSClassP12JSPrincipalsN2JS21OnNewGlobalHookOptionERKNS6_18CompartmentOptionsE(cx, + clasp, + principals, + hookOption, + options) +} +pub unsafe extern "C" fn JS_GlobalObjectTraceHook(trc: *mut JSTracer, + global: *mut JSObject) { + _Z24JS_GlobalObjectTraceHookP8JSTracerP8JSObject(trc, global) +} +pub unsafe extern "C" fn JS_FireOnNewGlobalObject(cx: *mut JSContext, + global: HandleObject) { + _Z24JS_FireOnNewGlobalObjectP9JSContextN2JS6HandleIP8JSObjectEE(cx, + global) +} +pub unsafe extern "C" fn JS_NewObject(cx: *mut JSContext, + clasp: *const JSClass) + -> *mut JSObject { + _Z12JS_NewObjectP9JSContextPK7JSClass(cx, clasp) +} +pub unsafe extern "C" fn JS_IsExtensible(cx: *mut JSContext, + obj: HandleObject, + extensible: *mut u8) -> u8 { + _Z15JS_IsExtensibleP9JSContextN2JS6HandleIP8JSObjectEEPb(cx, obj, + extensible) +} +pub unsafe extern "C" fn JS_IsNative(obj: *mut JSObject) -> u8 { + _Z11JS_IsNativeP8JSObject(obj) +} +pub unsafe extern "C" fn JS_GetObjectRuntime(obj: *mut JSObject) + -> *mut JSRuntime { + _Z19JS_GetObjectRuntimeP8JSObject(obj) +} +pub unsafe extern "C" fn JS_NewObjectWithGivenProto(cx: *mut JSContext, + clasp: *const JSClass, + proto: + Handle<*mut JSObject>) + -> *mut JSObject { + _Z26JS_NewObjectWithGivenProtoP9JSContextPK7JSClassN2JS6HandleIP8JSObjectEE(cx, + clasp, + proto) +} +pub unsafe extern "C" fn JS_NewPlainObject(cx: *mut JSContext) + -> *mut JSObject { + _Z17JS_NewPlainObjectP9JSContext(cx) +} +pub unsafe extern "C" fn JS_DeepFreezeObject(cx: *mut JSContext, + obj: Handle<*mut JSObject>) + -> u8 { + _Z19JS_DeepFreezeObjectP9JSContextN2JS6HandleIP8JSObjectEE(cx, obj) +} +pub unsafe extern "C" fn JS_FreezeObject(cx: *mut JSContext, + obj: Handle<*mut JSObject>) -> u8 { + _Z15JS_FreezeObjectP9JSContextN2JS6HandleIP8JSObjectEE(cx, obj) +} +pub unsafe extern "C" fn JS_PreventExtensions(cx: *mut JSContext, + obj: HandleObject, + result: *mut ObjectOpResult) + -> u8 { + _Z20JS_PreventExtensionsP9JSContextN2JS6HandleIP8JSObjectEERNS1_14ObjectOpResultE(cx, + obj, + result) +} +pub unsafe extern "C" fn JS_New(cx: *mut JSContext, ctor: HandleObject, + args: *const HandleValueArray) + -> *mut JSObject { + _Z6JS_NewP9JSContextN2JS6HandleIP8JSObjectEERKNS1_16HandleValueArrayE(cx, + ctor, + args) +} +pub unsafe extern "C" fn ObjectToCompletePropertyDescriptor(cx: + *mut JSContext, + obj: HandleObject, + descriptor: + HandleValue, + desc: + MutableHandle) + -> u8 { + _ZN2JS34ObjectToCompletePropertyDescriptorEP9JSContextNS_6HandleIP8JSObjectEENS2_INS_5ValueEEENS_13MutableHandleI20JSPropertyDescriptorEE(cx, + obj, + descriptor, + desc) +} +pub unsafe extern "C" fn JS_DefineProperty(cx: *mut JSContext, + obj: HandleObject, name: *const i8, + value: HandleValue, attrs: u32, + getter: JSNative, setter: JSNative) + -> u8 { + _Z17JS_DefinePropertyP9JSContextN2JS6HandleIP8JSObjectEEPKcNS2_INS1_5ValueEEEjPFbS0_jPS8_ESC_(cx, + obj, + name, + value, + attrs, + getter, + setter) +} +pub unsafe extern "C" fn JS_DefineProperty1(cx: *mut JSContext, + obj: HandleObject, + name: *const i8, + value: HandleObject, attrs: u32, + getter: JSNative, + setter: JSNative) -> u8 { + _Z17JS_DefinePropertyP9JSContextN2JS6HandleIP8JSObjectEEPKcS5_jPFbS0_jPNS1_5ValueEESB_(cx, + obj, + name, + value, + attrs, + getter, + setter) +} +pub unsafe extern "C" fn JS_DefineProperty2(cx: *mut JSContext, + obj: HandleObject, + name: *const i8, + value: HandleString, attrs: u32, + getter: JSNative, + setter: JSNative) -> u8 { + _Z17JS_DefinePropertyP9JSContextN2JS6HandleIP8JSObjectEEPKcNS2_IP8JSStringEEjPFbS0_jPNS1_5ValueEESE_(cx, + obj, + name, + value, + attrs, + getter, + setter) +} +pub unsafe extern "C" fn JS_DefineProperty3(cx: *mut JSContext, + obj: HandleObject, + name: *const i8, value: i32, + attrs: u32, getter: JSNative, + setter: JSNative) -> u8 { + _Z17JS_DefinePropertyP9JSContextN2JS6HandleIP8JSObjectEEPKcijPFbS0_jPNS1_5ValueEESB_(cx, + obj, + name, + value, + attrs, + getter, + setter) +} +pub unsafe extern "C" fn JS_DefineProperty4(cx: *mut JSContext, + obj: HandleObject, + name: *const i8, value: u32, + attrs: u32, getter: JSNative, + setter: JSNative) -> u8 { + _Z17JS_DefinePropertyP9JSContextN2JS6HandleIP8JSObjectEEPKcjjPFbS0_jPNS1_5ValueEESB_(cx, + obj, + name, + value, + attrs, + getter, + setter) +} +pub unsafe extern "C" fn JS_DefineProperty5(cx: *mut JSContext, + obj: HandleObject, + name: *const i8, value: f64, + attrs: u32, getter: JSNative, + setter: JSNative) -> u8 { + _Z17JS_DefinePropertyP9JSContextN2JS6HandleIP8JSObjectEEPKcdjPFbS0_jPNS1_5ValueEESB_(cx, + obj, + name, + value, + attrs, + getter, + setter) +} +pub unsafe extern "C" fn JS_DefinePropertyById(cx: *mut JSContext, + obj: HandleObject, + id: HandleId, + value: HandleValue, attrs: u32, + getter: JSNative, + setter: JSNative) -> u8 { + _Z21JS_DefinePropertyByIdP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEENS2_INS1_5ValueEEEjPFbS0_jPS8_ESC_(cx, + obj, + id, + value, + attrs, + getter, + setter) +} +pub unsafe extern "C" fn JS_DefinePropertyById1(cx: *mut JSContext, + obj: HandleObject, + id: HandleId, + value: HandleObject, + attrs: u32, getter: JSNative, + setter: JSNative) -> u8 { + _Z21JS_DefinePropertyByIdP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEES5_jPFbS0_jPNS1_5ValueEESB_(cx, + obj, + id, + value, + attrs, + getter, + setter) +} +pub unsafe extern "C" fn JS_DefinePropertyById2(cx: *mut JSContext, + obj: HandleObject, + id: HandleId, + value: HandleString, + attrs: u32, getter: JSNative, + setter: JSNative) -> u8 { + _Z21JS_DefinePropertyByIdP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEENS2_IP8JSStringEEjPFbS0_jPNS1_5ValueEESE_(cx, + obj, + id, + value, + attrs, + getter, + setter) +} +pub unsafe extern "C" fn JS_DefinePropertyById3(cx: *mut JSContext, + obj: HandleObject, + id: HandleId, value: i32, + attrs: u32, getter: JSNative, + setter: JSNative) -> u8 { + _Z21JS_DefinePropertyByIdP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEEijPFbS0_jPNS1_5ValueEESB_(cx, + obj, + id, + value, + attrs, + getter, + setter) +} +pub unsafe extern "C" fn JS_DefinePropertyById4(cx: *mut JSContext, + obj: HandleObject, + id: HandleId, value: u32, + attrs: u32, getter: JSNative, + setter: JSNative) -> u8 { + _Z21JS_DefinePropertyByIdP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEEjjPFbS0_jPNS1_5ValueEESB_(cx, + obj, + id, + value, + attrs, + getter, + setter) +} +pub unsafe extern "C" fn JS_DefinePropertyById5(cx: *mut JSContext, + obj: HandleObject, + id: HandleId, value: f64, + attrs: u32, getter: JSNative, + setter: JSNative) -> u8 { + _Z21JS_DefinePropertyByIdP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEEdjPFbS0_jPNS1_5ValueEESB_(cx, + obj, + id, + value, + attrs, + getter, + setter) +} +pub unsafe extern "C" fn JS_DefinePropertyById6(cx: *mut JSContext, + obj: HandleObject, + id: HandleId, + desc: + Handle, + result: *mut ObjectOpResult) + -> u8 { + _Z21JS_DefinePropertyByIdP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEENS2_I20JSPropertyDescriptorEERNS1_14ObjectOpResultE(cx, + obj, + id, + desc, + result) +} +pub unsafe extern "C" fn JS_DefinePropertyById7(cx: *mut JSContext, + obj: HandleObject, + id: HandleId, + desc: + Handle) + -> u8 { + _Z21JS_DefinePropertyByIdP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEENS2_I20JSPropertyDescriptorEE(cx, + obj, + id, + desc) +} +pub unsafe extern "C" fn JS_DefineObject(cx: *mut JSContext, + obj: HandleObject, name: *const i8, + clasp: *const JSClass, attrs: u32) + -> *mut JSObject { + _Z15JS_DefineObjectP9JSContextN2JS6HandleIP8JSObjectEEPKcPK7JSClassj(cx, + obj, + name, + clasp, + attrs) +} +pub unsafe extern "C" fn JS_DefineConstDoubles(cx: *mut JSContext, + obj: HandleObject, + cds: *const JSConstDoubleSpec) + -> u8 { + _Z21JS_DefineConstDoublesP9JSContextN2JS6HandleIP8JSObjectEEPK17JSConstScalarSpecIdE(cx, + obj, + cds) +} +pub unsafe extern "C" fn JS_DefineConstIntegers(cx: *mut JSContext, + obj: HandleObject, + cis: + *const JSConstIntegerSpec) + -> u8 { + _Z22JS_DefineConstIntegersP9JSContextN2JS6HandleIP8JSObjectEEPK17JSConstScalarSpecIiE(cx, + obj, + cis) +} +pub unsafe extern "C" fn JS_DefineProperties(cx: *mut JSContext, + obj: HandleObject, + ps: *const JSPropertySpec) + -> u8 { + _Z19JS_DefinePropertiesP9JSContextN2JS6HandleIP8JSObjectEEPK14JSPropertySpec(cx, + obj, + ps) +} +pub unsafe extern "C" fn JS_AlreadyHasOwnProperty(cx: *mut JSContext, + obj: HandleObject, + name: *const i8, + foundp: *mut u8) -> u8 { + _Z24JS_AlreadyHasOwnPropertyP9JSContextN2JS6HandleIP8JSObjectEEPKcPb(cx, + obj, + name, + foundp) +} +pub unsafe extern "C" fn JS_AlreadyHasOwnPropertyById(cx: *mut JSContext, + obj: HandleObject, + id: HandleId, + foundp: *mut u8) -> u8 { + _Z28JS_AlreadyHasOwnPropertyByIdP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEEPb(cx, + obj, + id, + foundp) +} +pub unsafe extern "C" fn JS_HasProperty(cx: *mut JSContext, obj: HandleObject, + name: *const i8, foundp: *mut u8) + -> u8 { + _Z14JS_HasPropertyP9JSContextN2JS6HandleIP8JSObjectEEPKcPb(cx, obj, name, + foundp) +} +pub unsafe extern "C" fn JS_HasPropertyById(cx: *mut JSContext, + obj: HandleObject, id: HandleId, + foundp: *mut u8) -> u8 { + _Z18JS_HasPropertyByIdP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEEPb(cx, + obj, + id, + foundp) +} +pub unsafe extern "C" fn JS_GetOwnPropertyDescriptorById(cx: *mut JSContext, + obj: HandleObject, + id: HandleId, + desc: + MutableHandle) + -> u8 { + _Z31JS_GetOwnPropertyDescriptorByIdP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEENS1_13MutableHandleI20JSPropertyDescriptorEE(cx, + obj, + id, + desc) +} +pub unsafe extern "C" fn JS_GetOwnPropertyDescriptor(cx: *mut JSContext, + obj: HandleObject, + name: *const i8, + desc: + MutableHandle) + -> u8 { + _Z27JS_GetOwnPropertyDescriptorP9JSContextN2JS6HandleIP8JSObjectEEPKcNS1_13MutableHandleI20JSPropertyDescriptorEE(cx, + obj, + name, + desc) +} +pub unsafe extern "C" fn JS_GetOwnUCPropertyDescriptor(cx: *mut JSContext, + obj: HandleObject, + name: *const i16, + desc: + MutableHandle) + -> u8 { + _Z29JS_GetOwnUCPropertyDescriptorP9JSContextN2JS6HandleIP8JSObjectEEPKDsNS1_13MutableHandleI20JSPropertyDescriptorEE(cx, + obj, + name, + desc) +} +pub unsafe extern "C" fn JS_GetPropertyDescriptorById(cx: *mut JSContext, + obj: HandleObject, + id: HandleId, + desc: + MutableHandle) + -> u8 { + _Z28JS_GetPropertyDescriptorByIdP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEENS1_13MutableHandleI20JSPropertyDescriptorEE(cx, + obj, + id, + desc) +} +pub unsafe extern "C" fn JS_GetPropertyDescriptor(cx: *mut JSContext, + obj: HandleObject, + name: *const i8, + desc: + MutableHandle) + -> u8 { + _Z24JS_GetPropertyDescriptorP9JSContextN2JS6HandleIP8JSObjectEEPKcNS1_13MutableHandleI20JSPropertyDescriptorEE(cx, + obj, + name, + desc) +} +pub unsafe extern "C" fn JS_GetProperty(cx: *mut JSContext, obj: HandleObject, + name: *const i8, + vp: MutableHandleValue) -> u8 { + _Z14JS_GetPropertyP9JSContextN2JS6HandleIP8JSObjectEEPKcNS1_13MutableHandleINS1_5ValueEEE(cx, + obj, + name, + vp) +} +pub unsafe extern "C" fn JS_GetPropertyById(cx: *mut JSContext, + obj: HandleObject, id: HandleId, + vp: MutableHandleValue) -> u8 { + _Z18JS_GetPropertyByIdP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEENS1_13MutableHandleINS1_5ValueEEE(cx, + obj, + id, + vp) +} +pub unsafe extern "C" fn JS_ForwardGetPropertyTo(cx: *mut JSContext, + obj: HandleObject, + id: HandleId, + onBehalfOf: HandleObject, + vp: MutableHandleValue) + -> u8 { + _Z23JS_ForwardGetPropertyToP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEES5_NS1_13MutableHandleINS1_5ValueEEE(cx, + obj, + id, + onBehalfOf, + vp) +} +pub unsafe extern "C" fn JS_SetProperty(cx: *mut JSContext, obj: HandleObject, + name: *const i8, v: HandleValue) + -> u8 { + _Z14JS_SetPropertyP9JSContextN2JS6HandleIP8JSObjectEEPKcNS2_INS1_5ValueEEE(cx, + obj, + name, + v) +} +pub unsafe extern "C" fn JS_SetPropertyById(cx: *mut JSContext, + obj: HandleObject, id: HandleId, + v: HandleValue) -> u8 { + _Z18JS_SetPropertyByIdP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEENS2_INS1_5ValueEEE(cx, + obj, + id, + v) +} +pub unsafe extern "C" fn JS_ForwardSetPropertyTo(cx: *mut JSContext, + obj: HandleObject, + id: HandleId, v: HandleValue, + receiver: HandleValue, + result: *mut ObjectOpResult) + -> u8 { + _Z23JS_ForwardSetPropertyToP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEENS2_INS1_5ValueEEES9_RNS1_14ObjectOpResultE(cx, + obj, + id, + v, + receiver, + result) +} +pub unsafe extern "C" fn JS_DeleteProperty(cx: *mut JSContext, + obj: HandleObject, name: *const i8) + -> u8 { + _Z17JS_DeletePropertyP9JSContextN2JS6HandleIP8JSObjectEEPKc(cx, obj, name) +} +pub unsafe extern "C" fn JS_DeleteProperty1(cx: *mut JSContext, + obj: HandleObject, + name: *const i8, + result: *mut ObjectOpResult) + -> u8 { + _Z17JS_DeletePropertyP9JSContextN2JS6HandleIP8JSObjectEEPKcRNS1_14ObjectOpResultE(cx, + obj, + name, + result) +} +pub unsafe extern "C" fn JS_DeletePropertyById(cx: *mut JSContext, + obj: HandleObject, id: jsid) + -> u8 { + _Z21JS_DeletePropertyByIdP9JSContextN2JS6HandleIP8JSObjectEE4jsid(cx, obj, + id) +} +pub unsafe extern "C" fn JS_DeletePropertyById1(cx: *mut JSContext, + obj: HandleObject, + id: HandleId, + result: *mut ObjectOpResult) + -> u8 { + _Z21JS_DeletePropertyByIdP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEERNS1_14ObjectOpResultE(cx, + obj, + id, + result) +} +pub unsafe extern "C" fn JS_DefineUCProperty(cx: *mut JSContext, + obj: HandleObject, + name: *const i16, namelen: u32, + value: HandleValue, attrs: u32, + getter: JSNative, + setter: JSNative) -> u8 { + _Z19JS_DefineUCPropertyP9JSContextN2JS6HandleIP8JSObjectEEPKDsjNS2_INS1_5ValueEEEjPFbS0_jPS8_ESC_(cx, + obj, + name, + namelen, + value, + attrs, + getter, + setter) +} +pub unsafe extern "C" fn JS_DefineUCProperty1(cx: *mut JSContext, + obj: HandleObject, + name: *const i16, namelen: u32, + value: HandleObject, attrs: u32, + getter: JSNative, + setter: JSNative) -> u8 { + _Z19JS_DefineUCPropertyP9JSContextN2JS6HandleIP8JSObjectEEPKDsjS5_jPFbS0_jPNS1_5ValueEESB_(cx, + obj, + name, + namelen, + value, + attrs, + getter, + setter) +} +pub unsafe extern "C" fn JS_DefineUCProperty2(cx: *mut JSContext, + obj: HandleObject, + name: *const i16, namelen: u32, + value: HandleString, attrs: u32, + getter: JSNative, + setter: JSNative) -> u8 { + _Z19JS_DefineUCPropertyP9JSContextN2JS6HandleIP8JSObjectEEPKDsjNS2_IP8JSStringEEjPFbS0_jPNS1_5ValueEESE_(cx, + obj, + name, + namelen, + value, + attrs, + getter, + setter) +} +pub unsafe extern "C" fn JS_DefineUCProperty3(cx: *mut JSContext, + obj: HandleObject, + name: *const i16, namelen: u32, + value: i32, attrs: u32, + getter: JSNative, + setter: JSNative) -> u8 { + _Z19JS_DefineUCPropertyP9JSContextN2JS6HandleIP8JSObjectEEPKDsjijPFbS0_jPNS1_5ValueEESB_(cx, + obj, + name, + namelen, + value, + attrs, + getter, + setter) +} +pub unsafe extern "C" fn JS_DefineUCProperty4(cx: *mut JSContext, + obj: HandleObject, + name: *const i16, namelen: u32, + value: u32, attrs: u32, + getter: JSNative, + setter: JSNative) -> u8 { + _Z19JS_DefineUCPropertyP9JSContextN2JS6HandleIP8JSObjectEEPKDsjjjPFbS0_jPNS1_5ValueEESB_(cx, + obj, + name, + namelen, + value, + attrs, + getter, + setter) +} +pub unsafe extern "C" fn JS_DefineUCProperty5(cx: *mut JSContext, + obj: HandleObject, + name: *const i16, namelen: u32, + value: f64, attrs: u32, + getter: JSNative, + setter: JSNative) -> u8 { + _Z19JS_DefineUCPropertyP9JSContextN2JS6HandleIP8JSObjectEEPKDsjdjPFbS0_jPNS1_5ValueEESB_(cx, + obj, + name, + namelen, + value, + attrs, + getter, + setter) +} +pub unsafe extern "C" fn JS_DefineUCProperty6(cx: *mut JSContext, + obj: HandleObject, + name: *const i16, namelen: u32, + desc: + Handle, + result: *mut ObjectOpResult) + -> u8 { + _Z19JS_DefineUCPropertyP9JSContextN2JS6HandleIP8JSObjectEEPKDsjNS2_I20JSPropertyDescriptorEERNS1_14ObjectOpResultE(cx, + obj, + name, + namelen, + desc, + result) +} +pub unsafe extern "C" fn JS_DefineUCProperty7(cx: *mut JSContext, + obj: HandleObject, + name: *const i16, namelen: u32, + desc: + Handle) + -> u8 { + _Z19JS_DefineUCPropertyP9JSContextN2JS6HandleIP8JSObjectEEPKDsjNS2_I20JSPropertyDescriptorEE(cx, + obj, + name, + namelen, + desc) +} +pub unsafe extern "C" fn JS_AlreadyHasOwnUCProperty(cx: *mut JSContext, + obj: HandleObject, + name: *const i16, + namelen: u32, + foundp: *mut u8) -> u8 { + _Z26JS_AlreadyHasOwnUCPropertyP9JSContextN2JS6HandleIP8JSObjectEEPKDsjPb(cx, + obj, + name, + namelen, + foundp) +} +pub unsafe extern "C" fn JS_HasUCProperty(cx: *mut JSContext, + obj: HandleObject, name: *const i16, + namelen: u32, vp: *mut u8) -> u8 { + _Z16JS_HasUCPropertyP9JSContextN2JS6HandleIP8JSObjectEEPKDsjPb(cx, obj, + name, + namelen, + vp) +} +pub unsafe extern "C" fn JS_GetUCProperty(cx: *mut JSContext, + obj: HandleObject, name: *const i16, + namelen: u32, + vp: MutableHandleValue) -> u8 { + _Z16JS_GetUCPropertyP9JSContextN2JS6HandleIP8JSObjectEEPKDsjNS1_13MutableHandleINS1_5ValueEEE(cx, + obj, + name, + namelen, + vp) +} +pub unsafe extern "C" fn JS_SetUCProperty(cx: *mut JSContext, + obj: HandleObject, name: *const i16, + namelen: u32, v: HandleValue) + -> u8 { + _Z16JS_SetUCPropertyP9JSContextN2JS6HandleIP8JSObjectEEPKDsjNS2_INS1_5ValueEEE(cx, + obj, + name, + namelen, + v) +} +pub unsafe extern "C" fn JS_DeleteUCProperty(cx: *mut JSContext, + obj: HandleObject, + name: *const i16, namelen: u32, + result: *mut ObjectOpResult) + -> u8 { + _Z19JS_DeleteUCPropertyP9JSContextN2JS6HandleIP8JSObjectEEPKDsjRNS1_14ObjectOpResultE(cx, + obj, + name, + namelen, + result) +} +pub unsafe extern "C" fn JS_NewArrayObject(cx: *mut JSContext, + contents: *const HandleValueArray) + -> *mut JSObject { + _Z17JS_NewArrayObjectP9JSContextRKN2JS16HandleValueArrayE(cx, contents) +} +pub unsafe extern "C" fn JS_NewArrayObject1(cx: *mut JSContext, length: u32) + -> *mut JSObject { + _Z17JS_NewArrayObjectP9JSContextj(cx, length) +} +pub unsafe extern "C" fn JS_IsArrayObject(cx: *mut JSContext, + value: HandleValue) -> u8 { + _Z16JS_IsArrayObjectP9JSContextN2JS6HandleINS1_5ValueEEE(cx, value) +} +pub unsafe extern "C" fn JS_IsArrayObject1(cx: *mut JSContext, + obj: HandleObject) -> u8 { + _Z16JS_IsArrayObjectP9JSContextN2JS6HandleIP8JSObjectEE(cx, obj) +} +pub unsafe extern "C" fn JS_GetArrayLength(cx: *mut JSContext, + obj: Handle<*mut JSObject>, + lengthp: *mut u32) -> u8 { + _Z17JS_GetArrayLengthP9JSContextN2JS6HandleIP8JSObjectEEPj(cx, obj, + lengthp) +} +pub unsafe extern "C" fn JS_SetArrayLength(cx: *mut JSContext, + obj: Handle<*mut JSObject>, + length: u32) -> u8 { + _Z17JS_SetArrayLengthP9JSContextN2JS6HandleIP8JSObjectEEj(cx, obj, length) +} +pub unsafe extern "C" fn JS_DefineElement(cx: *mut JSContext, + obj: HandleObject, index: u32, + value: HandleValue, attrs: u32, + getter: JSNative, setter: JSNative) + -> u8 { + _Z16JS_DefineElementP9JSContextN2JS6HandleIP8JSObjectEEjNS2_INS1_5ValueEEEjPFbS0_jPS6_ESA_(cx, + obj, + index, + value, + attrs, + getter, + setter) +} +pub unsafe extern "C" fn JS_DefineElement1(cx: *mut JSContext, + obj: HandleObject, index: u32, + value: HandleObject, attrs: u32, + getter: JSNative, setter: JSNative) + -> u8 { + _Z16JS_DefineElementP9JSContextN2JS6HandleIP8JSObjectEEjS5_jPFbS0_jPNS1_5ValueEES9_(cx, + obj, + index, + value, + attrs, + getter, + setter) +} +pub unsafe extern "C" fn JS_DefineElement2(cx: *mut JSContext, + obj: HandleObject, index: u32, + value: HandleString, attrs: u32, + getter: JSNative, setter: JSNative) + -> u8 { + _Z16JS_DefineElementP9JSContextN2JS6HandleIP8JSObjectEEjNS2_IP8JSStringEEjPFbS0_jPNS1_5ValueEESC_(cx, + obj, + index, + value, + attrs, + getter, + setter) +} +pub unsafe extern "C" fn JS_DefineElement3(cx: *mut JSContext, + obj: HandleObject, index: u32, + value: i32, attrs: u32, + getter: JSNative, setter: JSNative) + -> u8 { + _Z16JS_DefineElementP9JSContextN2JS6HandleIP8JSObjectEEjijPFbS0_jPNS1_5ValueEES9_(cx, + obj, + index, + value, + attrs, + getter, + setter) +} +pub unsafe extern "C" fn JS_DefineElement4(cx: *mut JSContext, + obj: HandleObject, index: u32, + value: u32, attrs: u32, + getter: JSNative, setter: JSNative) + -> u8 { + _Z16JS_DefineElementP9JSContextN2JS6HandleIP8JSObjectEEjjjPFbS0_jPNS1_5ValueEES9_(cx, + obj, + index, + value, + attrs, + getter, + setter) +} +pub unsafe extern "C" fn JS_DefineElement5(cx: *mut JSContext, + obj: HandleObject, index: u32, + value: f64, attrs: u32, + getter: JSNative, setter: JSNative) + -> u8 { + _Z16JS_DefineElementP9JSContextN2JS6HandleIP8JSObjectEEjdjPFbS0_jPNS1_5ValueEES9_(cx, + obj, + index, + value, + attrs, + getter, + setter) +} +pub unsafe extern "C" fn JS_AlreadyHasOwnElement(cx: *mut JSContext, + obj: HandleObject, + index: u32, foundp: *mut u8) + -> u8 { + _Z23JS_AlreadyHasOwnElementP9JSContextN2JS6HandleIP8JSObjectEEjPb(cx, obj, + index, + foundp) +} +pub unsafe extern "C" fn JS_HasElement(cx: *mut JSContext, obj: HandleObject, + index: u32, foundp: *mut u8) -> u8 { + _Z13JS_HasElementP9JSContextN2JS6HandleIP8JSObjectEEjPb(cx, obj, index, + foundp) +} +pub unsafe extern "C" fn JS_GetElement(cx: *mut JSContext, obj: HandleObject, + index: u32, vp: MutableHandleValue) + -> u8 { + _Z13JS_GetElementP9JSContextN2JS6HandleIP8JSObjectEEjNS1_13MutableHandleINS1_5ValueEEE(cx, + obj, + index, + vp) +} +pub unsafe extern "C" fn JS_ForwardGetElementTo(cx: *mut JSContext, + obj: HandleObject, index: u32, + onBehalfOf: HandleObject, + vp: MutableHandleValue) + -> u8 { + _Z22JS_ForwardGetElementToP9JSContextN2JS6HandleIP8JSObjectEEjS5_NS1_13MutableHandleINS1_5ValueEEE(cx, + obj, + index, + onBehalfOf, + vp) +} +pub unsafe extern "C" fn JS_SetElement(cx: *mut JSContext, obj: HandleObject, + index: u32, v: HandleValue) -> u8 { + _Z13JS_SetElementP9JSContextN2JS6HandleIP8JSObjectEEjNS2_INS1_5ValueEEE(cx, + obj, + index, + v) +} +pub unsafe extern "C" fn JS_SetElement1(cx: *mut JSContext, obj: HandleObject, + index: u32, v: HandleObject) -> u8 { + _Z13JS_SetElementP9JSContextN2JS6HandleIP8JSObjectEEjS5_(cx, obj, index, + v) +} +pub unsafe extern "C" fn JS_SetElement2(cx: *mut JSContext, obj: HandleObject, + index: u32, v: HandleString) -> u8 { + _Z13JS_SetElementP9JSContextN2JS6HandleIP8JSObjectEEjNS2_IP8JSStringEE(cx, + obj, + index, + v) +} +pub unsafe extern "C" fn JS_SetElement3(cx: *mut JSContext, obj: HandleObject, + index: u32, v: i32) -> u8 { + _Z13JS_SetElementP9JSContextN2JS6HandleIP8JSObjectEEji(cx, obj, index, v) +} +pub unsafe extern "C" fn JS_SetElement4(cx: *mut JSContext, obj: HandleObject, + index: u32, v: u32) -> u8 { + _Z13JS_SetElementP9JSContextN2JS6HandleIP8JSObjectEEjj(cx, obj, index, v) +} +pub unsafe extern "C" fn JS_SetElement5(cx: *mut JSContext, obj: HandleObject, + index: u32, v: f64) -> u8 { + _Z13JS_SetElementP9JSContextN2JS6HandleIP8JSObjectEEjd(cx, obj, index, v) +} +pub unsafe extern "C" fn JS_DeleteElement(cx: *mut JSContext, + obj: HandleObject, index: u32) + -> u8 { + _Z16JS_DeleteElementP9JSContextN2JS6HandleIP8JSObjectEEj(cx, obj, index) +} +pub unsafe extern "C" fn JS_DeleteElement1(cx: *mut JSContext, + obj: HandleObject, index: u32, + result: *mut ObjectOpResult) + -> u8 { + _Z16JS_DeleteElementP9JSContextN2JS6HandleIP8JSObjectEEjRNS1_14ObjectOpResultE(cx, + obj, + index, + result) +} +pub unsafe extern "C" fn JS_SetAllNonReservedSlotsToUndefined(cx: + *mut JSContext, + objArg: + *mut JSObject) { + _Z36JS_SetAllNonReservedSlotsToUndefinedP9JSContextP8JSObject(cx, objArg) +} +pub unsafe extern "C" fn JS_NewArrayBufferWithContents(cx: *mut JSContext, + nbytes: u32, + contents: + *mut ::libc::c_void) + -> *mut JSObject { + _Z29JS_NewArrayBufferWithContentsP9JSContextjPv(cx, nbytes, contents) +} +pub unsafe extern "C" fn JS_StealArrayBufferContents(cx: *mut JSContext, + obj: HandleObject) + -> *mut ::libc::c_void { + _Z27JS_StealArrayBufferContentsP9JSContextN2JS6HandleIP8JSObjectEE(cx, + obj) +} +pub unsafe extern "C" fn JS_NewMappedArrayBufferWithContents(cx: + *mut JSContext, + nbytes: u32, + contents: + *mut ::libc::c_void) + -> *mut JSObject { + _Z35JS_NewMappedArrayBufferWithContentsP9JSContextjPv(cx, nbytes, + contents) +} +pub unsafe extern "C" fn JS_CreateMappedArrayBufferContents(fd: i32, + offset: u32, + length: u32) + -> *mut ::libc::c_void { + _Z34JS_CreateMappedArrayBufferContentsijj(fd, offset, length) +} +pub unsafe extern "C" fn JS_ReleaseMappedArrayBufferContents(contents: + *mut ::libc::c_void, + length: u32) { + _Z35JS_ReleaseMappedArrayBufferContentsPvj(contents, length) +} +pub unsafe extern "C" fn JS_Enumerate(cx: *mut JSContext, obj: HandleObject) + -> *mut JSIdArray { + _Z12JS_EnumerateP9JSContextN2JS6HandleIP8JSObjectEE(cx, obj) +} +pub unsafe extern "C" fn JS_GetReservedSlot(obj: *mut JSObject, index: u32) + -> Value { + _Z18JS_GetReservedSlotP8JSObjectj(obj, index) +} +pub unsafe extern "C" fn JS_SetReservedSlot(obj: *mut JSObject, index: u32, + v: Value) { + _Z18JS_SetReservedSlotP8JSObjectjN2JS5ValueE(obj, index, v) +} +pub unsafe extern "C" fn JS_NewFunction(cx: *mut JSContext, call: JSNative, + nargs: u32, flags: u32, + name: *const i8) -> *mut JSFunction { + _Z14JS_NewFunctionP9JSContextPFbS0_jPN2JS5ValueEEjjPKc(cx, call, nargs, + flags, name) +} +pub unsafe extern "C" fn JS_NewFunctionById(cx: *mut JSContext, + call: JSNative, nargs: u32, + flags: u32, id: Handle) + -> *mut JSFunction { + _Z18JS_NewFunctionByIdP9JSContextPFbS0_jPN2JS5ValueEEjjNS1_6HandleI4jsidEE(cx, + call, + nargs, + flags, + id) +} +pub unsafe extern "C" fn GetSelfHostedFunction(cx: *mut JSContext, + selfHostedName: *const i8, + id: Handle, nargs: u32) + -> *mut JSFunction { + _ZN2JS21GetSelfHostedFunctionEP9JSContextPKcNS_6HandleI4jsidEEj(cx, + selfHostedName, + id, nargs) +} +pub unsafe extern "C" fn JS_GetFunctionObject(fun: *mut JSFunction) + -> *mut JSObject { + _Z20JS_GetFunctionObjectP10JSFunction(fun) +} +pub unsafe extern "C" fn JS_GetFunctionId(fun: *mut JSFunction) + -> *mut JSString { + _Z16JS_GetFunctionIdP10JSFunction(fun) +} +pub unsafe extern "C" fn JS_GetFunctionDisplayId(fun: *mut JSFunction) + -> *mut JSString { + _Z23JS_GetFunctionDisplayIdP10JSFunction(fun) +} +pub unsafe extern "C" fn JS_GetFunctionArity(fun: *mut JSFunction) -> u16 { + _Z19JS_GetFunctionArityP10JSFunction(fun) +} +pub unsafe extern "C" fn IsCallable(obj: *mut JSObject) -> u8 { + _ZN2JS10IsCallableEP8JSObject(obj) +} +pub unsafe extern "C" fn IsConstructor(obj: *mut JSObject) -> u8 { + _ZN2JS13IsConstructorEP8JSObject(obj) +} +pub unsafe extern "C" fn JS_ObjectIsFunction(cx: *mut JSContext, + obj: *mut JSObject) -> u8 { + _Z19JS_ObjectIsFunctionP9JSContextP8JSObject(cx, obj) +} +pub unsafe extern "C" fn JS_IsNativeFunction(funobj: *mut JSObject, + call: JSNative) -> u8 { + _Z19JS_IsNativeFunctionP8JSObjectPFbP9JSContextjPN2JS5ValueEE(funobj, + call) +} +pub unsafe extern "C" fn JS_IsConstructor(fun: *mut JSFunction) -> u8 { + _Z16JS_IsConstructorP10JSFunction(fun) +} +pub unsafe extern "C" fn JS_BindCallable(cx: *mut JSContext, + callable: Handle<*mut JSObject>, + newThis: Handle<*mut JSObject>) + -> *mut JSObject { + _Z15JS_BindCallableP9JSContextN2JS6HandleIP8JSObjectEES5_(cx, callable, + newThis) +} +pub unsafe extern "C" fn JS_DefineFunctions(cx: *mut JSContext, + obj: Handle<*mut JSObject>, + fs: *const JSFunctionSpec, + behavior: + PropertyDefinitionBehavior) + -> u8 { + _Z18JS_DefineFunctionsP9JSContextN2JS6HandleIP8JSObjectEEPK14JSFunctionSpec26PropertyDefinitionBehavior(cx, + obj, + fs, + behavior) +} +pub unsafe extern "C" fn JS_DefineFunction(cx: *mut JSContext, + obj: Handle<*mut JSObject>, + name: *const i8, call: JSNative, + nargs: u32, attrs: u32) + -> *mut JSFunction { + _Z17JS_DefineFunctionP9JSContextN2JS6HandleIP8JSObjectEEPKcPFbS0_jPNS1_5ValueEEjj(cx, + obj, + name, + call, + nargs, + attrs) +} +pub unsafe extern "C" fn JS_DefineUCFunction(cx: *mut JSContext, + obj: Handle<*mut JSObject>, + name: *const i16, namelen: u32, + call: JSNative, nargs: u32, + attrs: u32) -> *mut JSFunction { + _Z19JS_DefineUCFunctionP9JSContextN2JS6HandleIP8JSObjectEEPKDsjPFbS0_jPNS1_5ValueEEjj(cx, + obj, + name, + namelen, + call, + nargs, + attrs) +} +pub unsafe extern "C" fn JS_DefineFunctionById(cx: *mut JSContext, + obj: Handle<*mut JSObject>, + id: Handle, + call: JSNative, nargs: u32, + attrs: u32) + -> *mut JSFunction { + _Z21JS_DefineFunctionByIdP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEEPFbS0_jPNS1_5ValueEEjj(cx, + obj, + id, + call, + nargs, + attrs) +} +pub unsafe extern "C" fn CloneFunctionObject(cx: *mut JSContext, + funobj: HandleObject) + -> *mut JSObject { + _ZN2JS19CloneFunctionObjectEP9JSContextNS_6HandleIP8JSObjectEE(cx, funobj) +} +pub unsafe extern "C" fn CloneFunctionObject1(cx: *mut JSContext, + funobj: HandleObject, + scopeChain: + *mut AutoObjectVector) + -> *mut JSObject { + _ZN2JS19CloneFunctionObjectEP9JSContextNS_6HandleIP8JSObjectEERNS_16AutoObjectVectorE(cx, + funobj, + scopeChain) +} +pub unsafe extern "C" fn JS_BufferIsCompilableUnit(cx: *mut JSContext, + obj: Handle<*mut JSObject>, + utf8: *const i8, + length: u32) -> u8 { + _Z25JS_BufferIsCompilableUnitP9JSContextN2JS6HandleIP8JSObjectEEPKcj(cx, + obj, + utf8, + length) +} +pub unsafe extern "C" fn JS_CompileScript(cx: *mut JSContext, + ascii: *const i8, length: u32, + options: *const CompileOptions, + script: MutableHandleScript) -> u8 { + _Z16JS_CompileScriptP9JSContextPKcjRKN2JS14CompileOptionsENS3_13MutableHandleIP8JSScriptEE(cx, + ascii, + length, + options, + script) +} +pub unsafe extern "C" fn JS_CompileUCScript(cx: *mut JSContext, + chars: *const i16, length: u32, + options: *const CompileOptions, + script: MutableHandleScript) + -> u8 { + _Z18JS_CompileUCScriptP9JSContextPKDsjRKN2JS14CompileOptionsENS3_13MutableHandleIP8JSScriptEE(cx, + chars, + length, + options, + script) +} +pub unsafe extern "C" fn JS_GetGlobalFromScript(script: *mut JSScript) + -> *mut JSObject { + _Z22JS_GetGlobalFromScriptP8JSScript(script) +} +pub unsafe extern "C" fn JS_GetScriptFilename(script: *mut JSScript) + -> *const i8 { + _Z20JS_GetScriptFilenameP8JSScript(script) +} +pub unsafe extern "C" fn JS_GetScriptBaseLineNumber(cx: *mut JSContext, + script: *mut JSScript) + -> u32 { + _Z26JS_GetScriptBaseLineNumberP9JSContextP8JSScript(cx, script) +} +pub unsafe extern "C" fn JS_GetFunctionScript(cx: *mut JSContext, + fun: HandleFunction) + -> *mut JSScript { + _Z20JS_GetFunctionScriptP9JSContextN2JS6HandleIP10JSFunctionEE(cx, fun) +} +pub unsafe extern "C" fn Compile(cx: *mut JSContext, + options: *const ReadOnlyCompileOptions, + srcBuf: *mut SourceBufferHolder, + script: MutableHandleScript) -> u8 { + _ZN2JS7CompileEP9JSContextRKNS_22ReadOnlyCompileOptionsERNS_18SourceBufferHolderENS_13MutableHandleIP8JSScriptEE(cx, + options, + srcBuf, + script) +} +pub unsafe extern "C" fn Compile1(cx: *mut JSContext, + options: *const ReadOnlyCompileOptions, + bytes: *const i8, length: u32, + script: MutableHandleScript) -> u8 { + _ZN2JS7CompileEP9JSContextRKNS_22ReadOnlyCompileOptionsEPKcjNS_13MutableHandleIP8JSScriptEE(cx, + options, + bytes, + length, + script) +} +pub unsafe extern "C" fn Compile2(cx: *mut JSContext, + options: *const ReadOnlyCompileOptions, + chars: *const i16, length: u32, + script: MutableHandleScript) -> u8 { + _ZN2JS7CompileEP9JSContextRKNS_22ReadOnlyCompileOptionsEPKDsjNS_13MutableHandleIP8JSScriptEE(cx, + options, + chars, + length, + script) +} +pub unsafe extern "C" fn Compile3(cx: *mut JSContext, + options: *const ReadOnlyCompileOptions, + file: *mut FILE, + script: MutableHandleScript) -> u8 { + _ZN2JS7CompileEP9JSContextRKNS_22ReadOnlyCompileOptionsEP8_IO_FILENS_13MutableHandleIP8JSScriptEE(cx, + options, + file, + script) +} +pub unsafe extern "C" fn Compile4(cx: *mut JSContext, + options: *const ReadOnlyCompileOptions, + filename: *const i8, + script: MutableHandleScript) -> u8 { + _ZN2JS7CompileEP9JSContextRKNS_22ReadOnlyCompileOptionsEPKcNS_13MutableHandleIP8JSScriptEE(cx, + options, + filename, + script) +} +pub unsafe extern "C" fn CanCompileOffThread(cx: *mut JSContext, + options: + *const ReadOnlyCompileOptions, + length: u32) -> u8 { + _ZN2JS19CanCompileOffThreadEP9JSContextRKNS_22ReadOnlyCompileOptionsEj(cx, + options, + length) +} +pub unsafe extern "C" fn CompileOffThread(cx: *mut JSContext, + options: + *const ReadOnlyCompileOptions, + chars: *const i16, length: u32, + callback: OffThreadCompileCallback, + callbackData: *mut ::libc::c_void) + -> u8 { + _ZN2JS16CompileOffThreadEP9JSContextRKNS_22ReadOnlyCompileOptionsEPKDsjPFvPvS7_ES7_(cx, + options, + chars, + length, + callback, + callbackData) +} +pub unsafe extern "C" fn FinishOffThreadScript(maybecx: *mut JSContext, + rt: *mut JSRuntime, + token: *mut ::libc::c_void) + -> *mut JSScript { + _ZN2JS21FinishOffThreadScriptEP9JSContextP9JSRuntimePv(maybecx, rt, token) +} +#[cfg(target_pointer_width = "64")] +pub unsafe extern "C" fn CompileFunction(cx: *mut JSContext, + scopeChain: *mut AutoObjectVector, + options: + *const ReadOnlyCompileOptions, + name: *const i8, nargs: u32, + argnames: *const *const i8, + chars: *const i16, length: ::libc::size_t, + fun: MutableHandleFunction) -> u8 { + _ZN2JS15CompileFunctionEP9JSContextRNS_16AutoObjectVectorERKNS_22ReadOnlyCompileOptionsEPKcjPKS8_PKDsmNS_13MutableHandleIP10JSFunctionEE(cx, + scopeChain, + options, + name, + nargs, + argnames, + chars, + length, + fun) +} +#[cfg(target_pointer_width = "32")] +pub unsafe extern "C" fn CompileFunction(cx: *mut JSContext, + scopeChain: *mut AutoObjectVector, + options: + *const ReadOnlyCompileOptions, + name: *const i8, nargs: u32, + argnames: *const *const i8, + chars: *const i16, length: ::libc::size_t, + fun: MutableHandleFunction) -> u8 { + _ZN2JS15CompileFunctionEP9JSContextRNS_16AutoObjectVectorERKNS_22ReadOnlyCompileOptionsEPKcjPKS8_PKDsjNS_13MutableHandleIP10JSFunctionEE(cx, + scopeChain, + options, + name, + nargs, + argnames, + chars, + length, + fun) +} +pub unsafe extern "C" fn CompileFunction1(cx: *mut JSContext, + scopeChain: *mut AutoObjectVector, + options: + *const ReadOnlyCompileOptions, + name: *const i8, nargs: u32, + argnames: *const *const i8, + srcBuf: *mut SourceBufferHolder, + fun: MutableHandleFunction) -> u8 { + _ZN2JS15CompileFunctionEP9JSContextRNS_16AutoObjectVectorERKNS_22ReadOnlyCompileOptionsEPKcjPKS8_RNS_18SourceBufferHolderENS_13MutableHandleIP10JSFunctionEE(cx, + scopeChain, + options, + name, + nargs, + argnames, + srcBuf, + fun) +} +pub unsafe extern "C" fn CompileFunction2(cx: *mut JSContext, + scopeChain: *mut AutoObjectVector, + options: + *const ReadOnlyCompileOptions, + name: *const i8, nargs: u32, + argnames: *const *const i8, + bytes: *const i8, length: u32, + fun: MutableHandleFunction) -> u8 { + _ZN2JS15CompileFunctionEP9JSContextRNS_16AutoObjectVectorERKNS_22ReadOnlyCompileOptionsEPKcjPKS8_S8_jNS_13MutableHandleIP10JSFunctionEE(cx, + scopeChain, + options, + name, + nargs, + argnames, + bytes, + length, + fun) +} +pub unsafe extern "C" fn JS_DecompileScript(cx: *mut JSContext, + script: Handle<*mut JSScript>, + name: *const i8, indent: u32) + -> *mut JSString { + _Z18JS_DecompileScriptP9JSContextN2JS6HandleIP8JSScriptEEPKcj(cx, script, + name, + indent) +} +pub unsafe extern "C" fn JS_DecompileFunction(cx: *mut JSContext, + fun: Handle<*mut JSFunction>, + indent: u32) -> *mut JSString { + _Z20JS_DecompileFunctionP9JSContextN2JS6HandleIP10JSFunctionEEj(cx, fun, + indent) +} +pub unsafe extern "C" fn JS_DecompileFunctionBody(cx: *mut JSContext, + fun: + Handle<*mut JSFunction>, + indent: u32) + -> *mut JSString { + _Z24JS_DecompileFunctionBodyP9JSContextN2JS6HandleIP10JSFunctionEEj(cx, + fun, + indent) +} +pub unsafe extern "C" fn JS_ExecuteScript(cx: *mut JSContext, + script: HandleScript, + rval: MutableHandleValue) -> u8 { + _Z16JS_ExecuteScriptP9JSContextN2JS6HandleIP8JSScriptEENS1_13MutableHandleINS1_5ValueEEE(cx, + script, + rval) +} +pub unsafe extern "C" fn JS_ExecuteScript1(cx: *mut JSContext, + script: HandleScript) -> u8 { + _Z16JS_ExecuteScriptP9JSContextN2JS6HandleIP8JSScriptEE(cx, script) +} +pub unsafe extern "C" fn JS_ExecuteScript2(cx: *mut JSContext, + scopeChain: *mut AutoObjectVector, + script: HandleScript, + rval: MutableHandleValue) -> u8 { + _Z16JS_ExecuteScriptP9JSContextRN2JS16AutoObjectVectorENS1_6HandleIP8JSScriptEENS1_13MutableHandleINS1_5ValueEEE(cx, + scopeChain, + script, + rval) +} +pub unsafe extern "C" fn JS_ExecuteScript3(cx: *mut JSContext, + scopeChain: *mut AutoObjectVector, + script: HandleScript) -> u8 { + _Z16JS_ExecuteScriptP9JSContextRN2JS16AutoObjectVectorENS1_6HandleIP8JSScriptEE(cx, + scopeChain, + script) +} +pub unsafe extern "C" fn CloneAndExecuteScript(cx: *mut JSContext, + script: Handle<*mut JSScript>) + -> u8 { + _ZN2JS21CloneAndExecuteScriptEP9JSContextNS_6HandleIP8JSScriptEE(cx, + script) +} +pub unsafe extern "C" fn Evaluate(cx: *mut JSContext, + options: *const ReadOnlyCompileOptions, + srcBuf: *mut SourceBufferHolder, + rval: MutableHandleValue) -> u8 { + _ZN2JS8EvaluateEP9JSContextRKNS_22ReadOnlyCompileOptionsERNS_18SourceBufferHolderENS_13MutableHandleINS_5ValueEEE(cx, + options, + srcBuf, + rval) +} +pub unsafe extern "C" fn Evaluate1(cx: *mut JSContext, + scopeChain: *mut AutoObjectVector, + options: *const ReadOnlyCompileOptions, + srcBuf: *mut SourceBufferHolder, + rval: MutableHandleValue) -> u8 { + _ZN2JS8EvaluateEP9JSContextRNS_16AutoObjectVectorERKNS_22ReadOnlyCompileOptionsERNS_18SourceBufferHolderENS_13MutableHandleINS_5ValueEEE(cx, + scopeChain, + options, + srcBuf, + rval) +} +#[cfg(target_pointer_width = "64")] +pub unsafe extern "C" fn Evaluate2(cx: *mut JSContext, + options: *const ReadOnlyCompileOptions, + chars: *const i16, length: ::libc::size_t, + rval: MutableHandleValue) -> u8 { + _ZN2JS8EvaluateEP9JSContextRKNS_22ReadOnlyCompileOptionsEPKDsmNS_13MutableHandleINS_5ValueEEE(cx, + options, + chars, + length, + rval) +} +#[cfg(target_pointer_width = "32")] +pub unsafe extern "C" fn Evaluate2(cx: *mut JSContext, + options: *const ReadOnlyCompileOptions, + chars: *const i16, length: ::libc::size_t, + rval: MutableHandleValue) -> u8 { + _ZN2JS8EvaluateEP9JSContextRKNS_22ReadOnlyCompileOptionsEPKDsjNS_13MutableHandleINS_5ValueEEE(cx, + options, + chars, + length, + rval) +} +#[cfg(target_pointer_width = "64")] +pub unsafe extern "C" fn Evaluate3(cx: *mut JSContext, + scopeChain: *mut AutoObjectVector, + options: *const ReadOnlyCompileOptions, + chars: *const i16, length: ::libc::size_t, + rval: MutableHandleValue) -> u8 { + _ZN2JS8EvaluateEP9JSContextRNS_16AutoObjectVectorERKNS_22ReadOnlyCompileOptionsEPKDsmNS_13MutableHandleINS_5ValueEEE(cx, + scopeChain, + options, + chars, + length, + rval) +} +#[cfg(target_pointer_width = "32")] +pub unsafe extern "C" fn Evaluate3(cx: *mut JSContext, + scopeChain: *mut AutoObjectVector, + options: *const ReadOnlyCompileOptions, + chars: *const i16, length: ::libc::size_t, + rval: MutableHandleValue) -> u8 { + _ZN2JS8EvaluateEP9JSContextRNS_16AutoObjectVectorERKNS_22ReadOnlyCompileOptionsEPKDsjNS_13MutableHandleINS_5ValueEEE(cx, + scopeChain, + options, + chars, + length, + rval) +} +pub unsafe extern "C" fn Evaluate4(cx: *mut JSContext, + options: *const ReadOnlyCompileOptions, + bytes: *const i8, length: u32, + rval: MutableHandleValue) -> u8 { + _ZN2JS8EvaluateEP9JSContextRKNS_22ReadOnlyCompileOptionsEPKcjNS_13MutableHandleINS_5ValueEEE(cx, + options, + bytes, + length, + rval) +} +pub unsafe extern "C" fn Evaluate5(cx: *mut JSContext, + options: *const ReadOnlyCompileOptions, + filename: *const i8, + rval: MutableHandleValue) -> u8 { + _ZN2JS8EvaluateEP9JSContextRKNS_22ReadOnlyCompileOptionsEPKcNS_13MutableHandleINS_5ValueEEE(cx, + options, + filename, + rval) +} +pub unsafe extern "C" fn JS_CallFunction(cx: *mut JSContext, + obj: HandleObject, + fun: HandleFunction, + args: *const HandleValueArray, + rval: MutableHandleValue) -> u8 { + _Z15JS_CallFunctionP9JSContextN2JS6HandleIP8JSObjectEENS2_IP10JSFunctionEERKNS1_16HandleValueArrayENS1_13MutableHandleINS1_5ValueEEE(cx, + obj, + fun, + args, + rval) +} +pub unsafe extern "C" fn JS_CallFunctionName(cx: *mut JSContext, + obj: HandleObject, + name: *const i8, + args: *const HandleValueArray, + rval: MutableHandleValue) -> u8 { + _Z19JS_CallFunctionNameP9JSContextN2JS6HandleIP8JSObjectEEPKcRKNS1_16HandleValueArrayENS1_13MutableHandleINS1_5ValueEEE(cx, + obj, + name, + args, + rval) +} +pub unsafe extern "C" fn JS_CallFunctionValue(cx: *mut JSContext, + obj: HandleObject, + fval: HandleValue, + args: *const HandleValueArray, + rval: MutableHandleValue) + -> u8 { + _Z20JS_CallFunctionValueP9JSContextN2JS6HandleIP8JSObjectEENS2_INS1_5ValueEEERKNS1_16HandleValueArrayENS1_13MutableHandleIS6_EE(cx, + obj, + fval, + args, + rval) +} +pub unsafe extern "C" fn Call(cx: *mut JSContext, thisv: HandleValue, + fun: HandleValue, args: *const HandleValueArray, + rval: MutableHandleValue) -> u8 { + _ZN2JS4CallEP9JSContextNS_6HandleINS_5ValueEEES4_RKNS_16HandleValueArrayENS_13MutableHandleIS3_EE(cx, + thisv, + fun, + args, + rval) +} +pub unsafe extern "C" fn Construct(cx: *mut JSContext, fun: HandleValue, + args: *const HandleValueArray, + rval: MutableHandleValue) -> u8 { + _ZN2JS9ConstructEP9JSContextNS_6HandleINS_5ValueEEERKNS_16HandleValueArrayENS_13MutableHandleIS3_EE(cx, + fun, + args, + rval) +} +pub unsafe extern "C" fn JS_SetInterruptCallback(rt: *mut JSRuntime, + callback: + JSInterruptCallback) + -> JSInterruptCallback { + _Z23JS_SetInterruptCallbackP9JSRuntimePFbP9JSContextE(rt, callback) +} +pub unsafe extern "C" fn JS_GetInterruptCallback(rt: *mut JSRuntime) + -> JSInterruptCallback { + _Z23JS_GetInterruptCallbackP9JSRuntime(rt) +} +pub unsafe extern "C" fn JS_RequestInterruptCallback(rt: *mut JSRuntime) { + _Z27JS_RequestInterruptCallbackP9JSRuntime(rt) +} +pub unsafe extern "C" fn JS_IsRunning(cx: *mut JSContext) -> u8 { + _Z12JS_IsRunningP9JSContext(cx) +} +pub unsafe extern "C" fn JS_SaveFrameChain(cx: *mut JSContext) -> u8 { + _Z17JS_SaveFrameChainP9JSContext(cx) +} +pub unsafe extern "C" fn JS_RestoreFrameChain(cx: *mut JSContext) { + _Z20JS_RestoreFrameChainP9JSContext(cx) +} +#[cfg(target_pointer_width = "64")] +pub unsafe extern "C" fn JS_NewStringCopyN(cx: *mut JSContext, s: *const i8, + n: ::libc::size_t) -> *mut JSString { + _Z17JS_NewStringCopyNP9JSContextPKcm(cx, s, n) +} +#[cfg(target_pointer_width = "32")] +pub unsafe extern "C" fn JS_NewStringCopyN(cx: *mut JSContext, s: *const i8, + n: ::libc::size_t) -> *mut JSString { + _Z17JS_NewStringCopyNP9JSContextPKcj(cx, s, n) +} +pub unsafe extern "C" fn JS_NewStringCopyZ(cx: *mut JSContext, s: *const i8) + -> *mut JSString { + _Z17JS_NewStringCopyZP9JSContextPKc(cx, s) +} +pub unsafe extern "C" fn JS_InternJSString(cx: *mut JSContext, + str: HandleString) + -> *mut JSString { + _Z17JS_InternJSStringP9JSContextN2JS6HandleIP8JSStringEE(cx, str) +} +pub unsafe extern "C" fn JS_InternStringN(cx: *mut JSContext, s: *const i8, + length: u32) -> *mut JSString { + _Z16JS_InternStringNP9JSContextPKcj(cx, s, length) +} +pub unsafe extern "C" fn JS_InternString(cx: *mut JSContext, s: *const i8) + -> *mut JSString { + _Z15JS_InternStringP9JSContextPKc(cx, s) +} +pub unsafe extern "C" fn JS_NewUCString(cx: *mut JSContext, chars: *mut i16, + length: u32) -> *mut JSString { + _Z14JS_NewUCStringP9JSContextPDsj(cx, chars, length) +} +#[cfg(target_pointer_width = "64")] +pub unsafe extern "C" fn JS_NewUCStringCopyN(cx: *mut JSContext, + s: *const i16, n: ::libc::size_t) + -> *mut JSString { + _Z19JS_NewUCStringCopyNP9JSContextPKDsm(cx, s, n) +} +#[cfg(target_pointer_width = "32")] +pub unsafe extern "C" fn JS_NewUCStringCopyN(cx: *mut JSContext, + s: *const i16, n: ::libc::size_t) + -> *mut JSString { + _Z19JS_NewUCStringCopyNP9JSContextPKDsj(cx, s, n) +} +pub unsafe extern "C" fn JS_NewUCStringCopyZ(cx: *mut JSContext, + s: *const i16) -> *mut JSString { + _Z19JS_NewUCStringCopyZP9JSContextPKDs(cx, s) +} +pub unsafe extern "C" fn JS_InternUCStringN(cx: *mut JSContext, s: *const i16, + length: u32) -> *mut JSString { + _Z18JS_InternUCStringNP9JSContextPKDsj(cx, s, length) +} +pub unsafe extern "C" fn JS_InternUCString(cx: *mut JSContext, s: *const i16) + -> *mut JSString { + _Z17JS_InternUCStringP9JSContextPKDs(cx, s) +} +pub unsafe extern "C" fn JS_CompareStrings(cx: *mut JSContext, + str1: *mut JSString, + str2: *mut JSString, + result: *mut i32) -> u8 { + _Z17JS_CompareStringsP9JSContextP8JSStringS2_Pi(cx, str1, str2, result) +} +pub unsafe extern "C" fn JS_StringEqualsAscii(cx: *mut JSContext, + str: *mut JSString, + asciiBytes: *const i8, + _match: *mut u8) -> u8 { + _Z20JS_StringEqualsAsciiP9JSContextP8JSStringPKcPb(cx, str, asciiBytes, + _match) +} +pub unsafe extern "C" fn JS_PutEscapedString(cx: *mut JSContext, + buffer: *mut i8, size: u32, + str: *mut JSString, quote: i8) + -> u32 { + _Z19JS_PutEscapedStringP9JSContextPcjP8JSStringc(cx, buffer, size, str, + quote) +} +pub unsafe extern "C" fn JS_FileEscapedString(fp: *mut FILE, + str: *mut JSString, quote: i8) + -> u8 { + _Z20JS_FileEscapedStringP8_IO_FILEP8JSStringc(fp, str, quote) +} +pub unsafe extern "C" fn JS_GetStringLength(str: *mut JSString) -> u32 { + _Z18JS_GetStringLengthP8JSString(str) +} +pub unsafe extern "C" fn JS_StringIsFlat(str: *mut JSString) -> u8 { + _Z15JS_StringIsFlatP8JSString(str) +} +pub unsafe extern "C" fn JS_StringHasLatin1Chars(str: *mut JSString) -> u8 { + _Z23JS_StringHasLatin1CharsP8JSString(str) +} +#[cfg(target_pointer_width = "64")] +pub unsafe extern "C" fn JS_GetLatin1StringCharsAndLength(cx: *mut JSContext, + nogc: + *const AutoCheckCannotGC, + str: *mut JSString, + length: *mut ::libc::size_t) + -> *const Latin1Char { + _Z32JS_GetLatin1StringCharsAndLengthP9JSContextRKN2JS17AutoCheckCannotGCEP8JSStringPm(cx, + nogc, + str, + length) +} +#[cfg(target_pointer_width = "32")] +pub unsafe extern "C" fn JS_GetLatin1StringCharsAndLength(cx: *mut JSContext, + nogc: + *const AutoCheckCannotGC, + str: *mut JSString, + length: *mut ::libc::size_t) + -> *const Latin1Char { + _Z32JS_GetLatin1StringCharsAndLengthP9JSContextRKN2JS17AutoCheckCannotGCEP8JSStringPj(cx, + nogc, + str, + length) +} +#[cfg(target_pointer_width = "64")] +pub unsafe extern "C" fn JS_GetTwoByteStringCharsAndLength(cx: *mut JSContext, + nogc: + *const AutoCheckCannotGC, + str: *mut JSString, + length: *mut ::libc::size_t) + -> *const i16 { + _Z33JS_GetTwoByteStringCharsAndLengthP9JSContextRKN2JS17AutoCheckCannotGCEP8JSStringPm(cx, + nogc, + str, + length) +} +#[cfg(target_pointer_width = "32")] +pub unsafe extern "C" fn JS_GetTwoByteStringCharsAndLength(cx: *mut JSContext, + nogc: + *const AutoCheckCannotGC, + str: *mut JSString, + length: *mut ::libc::size_t) + -> *const i16 { + _Z33JS_GetTwoByteStringCharsAndLengthP9JSContextRKN2JS17AutoCheckCannotGCEP8JSStringPj(cx, + nogc, + str, + length) +} +pub unsafe extern "C" fn JS_GetStringCharAt(cx: *mut JSContext, + str: *mut JSString, index: u32, + res: *mut i16) -> u8 { + _Z18JS_GetStringCharAtP9JSContextP8JSStringjPDs(cx, str, index, res) +} +pub unsafe extern "C" fn JS_GetFlatStringCharAt(str: *mut JSFlatString, + index: u32) -> i16 { + _Z22JS_GetFlatStringCharAtP12JSFlatStringj(str, index) +} +pub unsafe extern "C" fn JS_GetTwoByteExternalStringChars(str: *mut JSString) + -> *const i16 { + _Z32JS_GetTwoByteExternalStringCharsP8JSString(str) +} +pub unsafe extern "C" fn JS_CopyStringChars(cx: *mut JSContext, + dest: Range, + str: *mut JSString) -> u8 { + _Z18JS_CopyStringCharsP9JSContextN7mozilla5RangeIDsEEP8JSString(cx, dest, + str) +} +pub unsafe extern "C" fn JS_GetLatin1InternedStringChars(nogc: + *const AutoCheckCannotGC, + str: *mut JSString) + -> *const Latin1Char { + _Z31JS_GetLatin1InternedStringCharsRKN2JS17AutoCheckCannotGCEP8JSString(nogc, + str) +} +pub unsafe extern "C" fn JS_GetTwoByteInternedStringChars(nogc: + *const AutoCheckCannotGC, + str: *mut JSString) + -> *const i16 { + _Z32JS_GetTwoByteInternedStringCharsRKN2JS17AutoCheckCannotGCEP8JSString(nogc, + str) +} +pub unsafe extern "C" fn JS_FlattenString(cx: *mut JSContext, + str: *mut JSString) + -> *mut JSFlatString { + _Z16JS_FlattenStringP9JSContextP8JSString(cx, str) +} +pub unsafe extern "C" fn JS_GetLatin1FlatStringChars(nogc: + *const AutoCheckCannotGC, + str: *mut JSFlatString) + -> *const Latin1Char { + _Z27JS_GetLatin1FlatStringCharsRKN2JS17AutoCheckCannotGCEP12JSFlatString(nogc, + str) +} +pub unsafe extern "C" fn JS_GetTwoByteFlatStringChars(nogc: + *const AutoCheckCannotGC, + str: *mut JSFlatString) + -> *const i16 { + _Z28JS_GetTwoByteFlatStringCharsRKN2JS17AutoCheckCannotGCEP12JSFlatString(nogc, + str) +} +pub unsafe extern "C" fn JS_FlatStringEqualsAscii(str: *mut JSFlatString, + asciiBytes: *const i8) + -> u8 { + _Z24JS_FlatStringEqualsAsciiP12JSFlatStringPKc(str, asciiBytes) +} +pub unsafe extern "C" fn JS_PutEscapedFlatString(buffer: *mut i8, size: u32, + str: *mut JSFlatString, + quote: i8) -> u32 { + _Z23JS_PutEscapedFlatStringPcjP12JSFlatStringc(buffer, size, str, quote) +} +pub unsafe extern "C" fn JS_NewDependentString(cx: *mut JSContext, + str: HandleString, start: u32, + length: u32) -> *mut JSString { + _Z21JS_NewDependentStringP9JSContextN2JS6HandleIP8JSStringEEjj(cx, str, + start, + length) +} +pub unsafe extern "C" fn JS_ConcatStrings(cx: *mut JSContext, + left: HandleString, + right: HandleString) + -> *mut JSString { + _Z16JS_ConcatStringsP9JSContextN2JS6HandleIP8JSStringEES5_(cx, left, + right) +} +pub unsafe extern "C" fn JS_DecodeBytes(cx: *mut JSContext, src: *const i8, + srclen: u32, dst: *mut i16, + dstlenp: *mut u32) -> u8 { + _Z14JS_DecodeBytesP9JSContextPKcjPDsPj(cx, src, srclen, dst, dstlenp) +} +pub unsafe extern "C" fn JS_EncodeString(cx: *mut JSContext, + str: *mut JSString) -> *mut i8 { + _Z15JS_EncodeStringP9JSContextP8JSString(cx, str) +} +pub unsafe extern "C" fn JS_EncodeStringToUTF8(cx: *mut JSContext, + str: HandleString) -> *mut i8 { + _Z21JS_EncodeStringToUTF8P9JSContextN2JS6HandleIP8JSStringEE(cx, str) +} +pub unsafe extern "C" fn JS_GetStringEncodingLength(cx: *mut JSContext, + str: *mut JSString) + -> u32 { + _Z26JS_GetStringEncodingLengthP9JSContextP8JSString(cx, str) +} +pub unsafe extern "C" fn JS_EncodeStringToBuffer(cx: *mut JSContext, + str: *mut JSString, + buffer: *mut i8, length: u32) + -> u32 { + _Z23JS_EncodeStringToBufferP9JSContextP8JSStringPcj(cx, str, buffer, + length) +} +pub unsafe extern "C" fn NewAddonId(cx: *mut JSContext, str: HandleString) + -> *mut JSAddonId { + _ZN2JS10NewAddonIdEP9JSContextNS_6HandleIP8JSStringEE(cx, str) +} +pub unsafe extern "C" fn StringOfAddonId(id: *mut JSAddonId) + -> *mut JSString { + _ZN2JS15StringOfAddonIdEP9JSAddonId(id) +} +pub unsafe extern "C" fn AddonIdOfObject(obj: *mut JSObject) + -> *mut JSAddonId { + _ZN2JS15AddonIdOfObjectEP8JSObject(obj) +} +pub unsafe extern "C" fn NewSymbol(cx: *mut JSContext, + description: HandleString) -> *mut Symbol { + _ZN2JS9NewSymbolEP9JSContextNS_6HandleIP8JSStringEE(cx, description) +} +pub unsafe extern "C" fn GetSymbolFor(cx: *mut JSContext, key: HandleString) + -> *mut Symbol { + _ZN2JS12GetSymbolForEP9JSContextNS_6HandleIP8JSStringEE(cx, key) +} +pub unsafe extern "C" fn GetSymbolDescription(symbol: HandleSymbol) + -> *mut JSString { + _ZN2JS20GetSymbolDescriptionENS_6HandleIPNS_6SymbolEEE(symbol) +} +pub unsafe extern "C" fn GetSymbolCode(symbol: Handle<*mut Symbol>) + -> SymbolCode { + _ZN2JS13GetSymbolCodeENS_6HandleIPNS_6SymbolEEE(symbol) +} +pub unsafe extern "C" fn GetWellKnownSymbol(cx: *mut JSContext, + which: SymbolCode) + -> *mut Symbol { + _ZN2JS18GetWellKnownSymbolEP9JSContextNS_10SymbolCodeE(cx, which) +} +pub unsafe extern "C" fn PropertySpecNameIsSymbol(name: *const i8) -> u8 { + _ZN2JS24PropertySpecNameIsSymbolEPKc(name) +} +pub unsafe extern "C" fn PropertySpecNameEqualsId(name: *const i8, + id: HandleId) -> u8 { + _ZN2JS24PropertySpecNameEqualsIdEPKcNS_6HandleI4jsidEE(name, id) +} +pub unsafe extern "C" fn PropertySpecNameToPermanentId(cx: *mut JSContext, + name: *const i8, + idp: *mut jsid) -> u8 { + _ZN2JS29PropertySpecNameToPermanentIdEP9JSContextPKcP4jsid(cx, name, idp) +} +pub unsafe extern "C" fn JS_Stringify(cx: *mut JSContext, + value: MutableHandleValue, + replacer: HandleObject, + space: HandleValue, + callback: JSONWriteCallback, + data: *mut ::libc::c_void) -> u8 { + _Z12JS_StringifyP9JSContextN2JS13MutableHandleINS1_5ValueEEENS1_6HandleIP8JSObjectEENS5_IS3_EEPFbPKDsjPvESC_(cx, + value, + replacer, + space, + callback, + data) +} +pub unsafe extern "C" fn JS_ParseJSON(cx: *mut JSContext, chars: *const i16, + len: u32, vp: MutableHandleValue) + -> u8 { + _Z12JS_ParseJSONP9JSContextPKDsjN2JS13MutableHandleINS3_5ValueEEE(cx, + chars, + len, vp) +} +pub unsafe extern "C" fn JS_ParseJSON1(cx: *mut JSContext, str: HandleString, + vp: MutableHandleValue) -> u8 { + _Z12JS_ParseJSONP9JSContextN2JS6HandleIP8JSStringEENS1_13MutableHandleINS1_5ValueEEE(cx, + str, + vp) +} +pub unsafe extern "C" fn JS_ParseJSONWithReviver(cx: *mut JSContext, + chars: *const i16, len: u32, + reviver: HandleValue, + vp: MutableHandleValue) + -> u8 { + _Z23JS_ParseJSONWithReviverP9JSContextPKDsjN2JS6HandleINS3_5ValueEEENS3_13MutableHandleIS5_EE(cx, + chars, + len, + reviver, + vp) +} +pub unsafe extern "C" fn JS_ParseJSONWithReviver1(cx: *mut JSContext, + str: HandleString, + reviver: HandleValue, + vp: MutableHandleValue) + -> u8 { + _Z23JS_ParseJSONWithReviverP9JSContextN2JS6HandleIP8JSStringEENS2_INS1_5ValueEEENS1_13MutableHandleIS6_EE(cx, + str, + reviver, + vp) +} +pub unsafe extern "C" fn JS_SetDefaultLocale(rt: *mut JSRuntime, + locale: *const i8) -> u8 { + _Z19JS_SetDefaultLocaleP9JSRuntimePKc(rt, locale) +} +pub unsafe extern "C" fn JS_ResetDefaultLocale(rt: *mut JSRuntime) { + _Z21JS_ResetDefaultLocaleP9JSRuntime(rt) +} +pub unsafe extern "C" fn JS_SetLocaleCallbacks(rt: *mut JSRuntime, + callbacks: + *const JSLocaleCallbacks) { + _Z21JS_SetLocaleCallbacksP9JSRuntimePK17JSLocaleCallbacks(rt, callbacks) +} +pub unsafe extern "C" fn JS_GetLocaleCallbacks(rt: *mut JSRuntime) + -> *const JSLocaleCallbacks { + _Z21JS_GetLocaleCallbacksP9JSRuntime(rt) +} +pub unsafe extern "C" fn JS_ReportError(cx: *mut JSContext, + format: *const i8) { + _Z14JS_ReportErrorP9JSContextPKcz(cx, format) +} +pub unsafe extern "C" fn JS_ReportErrorNumber(cx: *mut JSContext, + errorCallback: JSErrorCallback, + userRef: *mut ::libc::c_void, + errorNumber: u32) { + _Z20JS_ReportErrorNumberP9JSContextPFPK19JSErrorFormatStringPvjES4_jz(cx, + errorCallback, + userRef, + errorNumber) +} +pub unsafe extern "C" fn JS_ReportErrorNumber1(cx: *mut JSContext, + errorCallback: JSErrorCallback, + userRef: *mut ::libc::c_void, + errorNumber: u32, + arg1: *const i8) { + _Z20JS_ReportErrorNumberP9JSContextPFPK19JSErrorFormatStringPvjES4_jz(cx, + errorCallback, + userRef, + errorNumber, + arg1) +} +pub unsafe extern "C" fn JS_ReportErrorNumberVA(cx: *mut JSContext, + errorCallback: + JSErrorCallback, + userRef: *mut ::libc::c_void, + errorNumber: u32, + ap: va_list) { + _Z22JS_ReportErrorNumberVAP9JSContextPFPK19JSErrorFormatStringPvjES4_jPc(cx, + errorCallback, + userRef, + errorNumber, + ap) +} +pub unsafe extern "C" fn JS_ReportErrorNumberUC(cx: *mut JSContext, + errorCallback: + JSErrorCallback, + userRef: *mut ::libc::c_void, + errorNumber: u32) { + _Z22JS_ReportErrorNumberUCP9JSContextPFPK19JSErrorFormatStringPvjES4_jz(cx, + errorCallback, + userRef, + errorNumber) +} +pub unsafe extern "C" fn JS_ReportErrorNumberUCArray(cx: *mut JSContext, + errorCallback: + JSErrorCallback, + userRef: + *mut ::libc::c_void, + errorNumber: u32, + args: *mut *const i16) { + _Z27JS_ReportErrorNumberUCArrayP9JSContextPFPK19JSErrorFormatStringPvjES4_jPPKDs(cx, + errorCallback, + userRef, + errorNumber, + args) +} +pub unsafe extern "C" fn JS_ReportWarning(cx: *mut JSContext, + format: *const i8) -> u8 { + _Z16JS_ReportWarningP9JSContextPKcz(cx, format) +} +pub unsafe extern "C" fn JS_ReportErrorFlagsAndNumber(cx: *mut JSContext, + flags: u32, + errorCallback: + JSErrorCallback, + userRef: + *mut ::libc::c_void, + errorNumber: u32) + -> u8 { + _Z28JS_ReportErrorFlagsAndNumberP9JSContextjPFPK19JSErrorFormatStringPvjES4_jz(cx, + flags, + errorCallback, + userRef, + errorNumber) +} +pub unsafe extern "C" fn JS_ReportErrorFlagsAndNumberUC(cx: *mut JSContext, + flags: u32, + errorCallback: + JSErrorCallback, + userRef: + *mut ::libc::c_void, + errorNumber: u32) + -> u8 { + _Z30JS_ReportErrorFlagsAndNumberUCP9JSContextjPFPK19JSErrorFormatStringPvjES4_jz(cx, + flags, + errorCallback, + userRef, + errorNumber) +} +pub unsafe extern "C" fn JS_ReportOutOfMemory(cx: *mut JSContext) { + _Z20JS_ReportOutOfMemoryP9JSContext(cx) +} +pub unsafe extern "C" fn JS_ReportAllocationOverflow(cx: *mut JSContext) { + _Z27JS_ReportAllocationOverflowP9JSContext(cx) +} +pub unsafe extern "C" fn JS_GetErrorReporter(rt: *mut JSRuntime) + -> JSErrorReporter { + _Z19JS_GetErrorReporterP9JSRuntime(rt) +} +pub unsafe extern "C" fn JS_SetErrorReporter(rt: *mut JSRuntime, + er: JSErrorReporter) + -> JSErrorReporter { + _Z19JS_SetErrorReporterP9JSRuntimePFvP9JSContextPKcP13JSErrorReportE(rt, + er) +} +pub unsafe extern "C" fn CreateError(cx: *mut JSContext, _type: JSExnType, + stack: HandleString, + fileName: HandleString, lineNumber: u32, + columnNumber: u32, + report: *mut JSErrorReport, + message: HandleString, + rval: MutableHandleValue) -> u8 { + _ZN2JS11CreateErrorEP9JSContext9JSExnTypeNS_6HandleIP8JSStringEES6_jjP13JSErrorReportS6_NS_13MutableHandleINS_5ValueEEE(cx, + _type, + stack, + fileName, + lineNumber, + columnNumber, + report, + message, + rval) +} +pub unsafe extern "C" fn NewWeakMapObject(cx: *mut JSContext) + -> *mut JSObject { + _ZN2JS16NewWeakMapObjectEP9JSContext(cx) +} +pub unsafe extern "C" fn IsWeakMapObject(obj: *mut JSObject) -> u8 { + _ZN2JS15IsWeakMapObjectEP8JSObject(obj) +} +pub unsafe extern "C" fn GetWeakMapEntry(cx: *mut JSContext, + mapObj: HandleObject, + key: HandleObject, + val: MutableHandleValue) -> u8 { + _ZN2JS15GetWeakMapEntryEP9JSContextNS_6HandleIP8JSObjectEES5_NS_13MutableHandleINS_5ValueEEE(cx, + mapObj, + key, + val) +} +pub unsafe extern "C" fn SetWeakMapEntry(cx: *mut JSContext, + mapObj: HandleObject, + key: HandleObject, val: HandleValue) + -> u8 { + _ZN2JS15SetWeakMapEntryEP9JSContextNS_6HandleIP8JSObjectEES5_NS2_INS_5ValueEEE(cx, + mapObj, + key, + val) +} +pub unsafe extern "C" fn NewMapObject(cx: *mut JSContext) -> *mut JSObject { + _ZN2JS12NewMapObjectEP9JSContext(cx) +} +pub unsafe extern "C" fn MapSize(cx: *mut JSContext, obj: HandleObject) + -> u32 { + _ZN2JS7MapSizeEP9JSContextNS_6HandleIP8JSObjectEE(cx, obj) +} +pub unsafe extern "C" fn MapGet(cx: *mut JSContext, obj: HandleObject, + key: HandleValue, rval: MutableHandleValue) + -> u8 { + _ZN2JS6MapGetEP9JSContextNS_6HandleIP8JSObjectEENS2_INS_5ValueEEENS_13MutableHandleIS6_EE(cx, + obj, + key, + rval) +} +pub unsafe extern "C" fn MapHas(cx: *mut JSContext, obj: HandleObject, + key: HandleValue, rval: *mut u8) -> u8 { + _ZN2JS6MapHasEP9JSContextNS_6HandleIP8JSObjectEENS2_INS_5ValueEEEPb(cx, + obj, + key, + rval) +} +pub unsafe extern "C" fn MapSet(cx: *mut JSContext, obj: HandleObject, + key: HandleValue, val: HandleValue) -> u8 { + _ZN2JS6MapSetEP9JSContextNS_6HandleIP8JSObjectEENS2_INS_5ValueEEES7_(cx, + obj, + key, + val) +} +pub unsafe extern "C" fn MapClear(cx: *mut JSContext, obj: HandleObject) + -> u8 { + _ZN2JS8MapClearEP9JSContextNS_6HandleIP8JSObjectEE(cx, obj) +} +pub unsafe extern "C" fn MapKeys(cx: *mut JSContext, obj: HandleObject, + rval: MutableHandleValue) -> u8 { + _ZN2JS7MapKeysEP9JSContextNS_6HandleIP8JSObjectEENS_13MutableHandleINS_5ValueEEE(cx, + obj, + rval) +} +pub unsafe extern "C" fn MapValues(cx: *mut JSContext, obj: HandleObject, + rval: MutableHandleValue) -> u8 { + _ZN2JS9MapValuesEP9JSContextNS_6HandleIP8JSObjectEENS_13MutableHandleINS_5ValueEEE(cx, + obj, + rval) +} +pub unsafe extern "C" fn MapEntries(cx: *mut JSContext, obj: HandleObject, + rval: MutableHandleValue) -> u8 { + _ZN2JS10MapEntriesEP9JSContextNS_6HandleIP8JSObjectEENS_13MutableHandleINS_5ValueEEE(cx, + obj, + rval) +} +pub unsafe extern "C" fn JS_NewDateObject(cx: *mut JSContext, year: i32, + mon: i32, mday: i32, hour: i32, + min: i32, sec: i32) + -> *mut JSObject { + _Z16JS_NewDateObjectP9JSContextiiiiii(cx, year, mon, mday, hour, min, sec) +} +pub unsafe extern "C" fn JS_NewDateObjectMsec(cx: *mut JSContext, msec: f64) + -> *mut JSObject { + _Z20JS_NewDateObjectMsecP9JSContextd(cx, msec) +} +pub unsafe extern "C" fn JS_ObjectIsDate(cx: *mut JSContext, + obj: HandleObject) -> u8 { + _Z15JS_ObjectIsDateP9JSContextN2JS6HandleIP8JSObjectEE(cx, obj) +} +pub unsafe extern "C" fn JS_ClearDateCaches(cx: *mut JSContext) { + _Z18JS_ClearDateCachesP9JSContext(cx) +} +pub unsafe extern "C" fn JS_NewRegExpObject(cx: *mut JSContext, + obj: HandleObject, + bytes: *const i8, length: u32, + flags: u32) -> *mut JSObject { + _Z18JS_NewRegExpObjectP9JSContextN2JS6HandleIP8JSObjectEEPKcjj(cx, obj, + bytes, + length, + flags) +} +pub unsafe extern "C" fn JS_NewUCRegExpObject(cx: *mut JSContext, + obj: HandleObject, + chars: *const i16, length: u32, + flags: u32) -> *mut JSObject { + _Z20JS_NewUCRegExpObjectP9JSContextN2JS6HandleIP8JSObjectEEPKDsjj(cx, obj, + chars, + length, + flags) +} +pub unsafe extern "C" fn JS_SetRegExpInput(cx: *mut JSContext, + obj: HandleObject, + input: HandleString, multiline: u8) + -> u8 { + _Z17JS_SetRegExpInputP9JSContextN2JS6HandleIP8JSObjectEENS2_IP8JSStringEEb(cx, + obj, + input, + multiline) +} +pub unsafe extern "C" fn JS_ClearRegExpStatics(cx: *mut JSContext, + obj: HandleObject) -> u8 { + _Z21JS_ClearRegExpStaticsP9JSContextN2JS6HandleIP8JSObjectEE(cx, obj) +} +pub unsafe extern "C" fn JS_ExecuteRegExp(cx: *mut JSContext, + obj: HandleObject, + reobj: HandleObject, + chars: *mut i16, length: u32, + indexp: *mut u32, test: u8, + rval: MutableHandleValue) -> u8 { + _Z16JS_ExecuteRegExpP9JSContextN2JS6HandleIP8JSObjectEES5_PDsjPjbNS1_13MutableHandleINS1_5ValueEEE(cx, + obj, + reobj, + chars, + length, + indexp, + test, + rval) +} +pub unsafe extern "C" fn JS_NewRegExpObjectNoStatics(cx: *mut JSContext, + bytes: *mut i8, + length: u32, flags: u32) + -> *mut JSObject { + _Z27JS_NewRegExpObjectNoStaticsP9JSContextPcjj(cx, bytes, length, flags) +} +pub unsafe extern "C" fn JS_NewUCRegExpObjectNoStatics(cx: *mut JSContext, + chars: *mut i16, + length: u32, + flags: u32) + -> *mut JSObject { + _Z29JS_NewUCRegExpObjectNoStaticsP9JSContextPDsjj(cx, chars, length, + flags) +} +pub unsafe extern "C" fn JS_ExecuteRegExpNoStatics(cx: *mut JSContext, + reobj: HandleObject, + chars: *mut i16, + length: u32, + indexp: *mut u32, test: u8, + rval: MutableHandleValue) + -> u8 { + _Z25JS_ExecuteRegExpNoStaticsP9JSContextN2JS6HandleIP8JSObjectEEPDsjPjbNS1_13MutableHandleINS1_5ValueEEE(cx, + reobj, + chars, + length, + indexp, + test, + rval) +} +pub unsafe extern "C" fn JS_ObjectIsRegExp(cx: *mut JSContext, + obj: HandleObject) -> u8 { + _Z17JS_ObjectIsRegExpP9JSContextN2JS6HandleIP8JSObjectEE(cx, obj) +} +pub unsafe extern "C" fn JS_GetRegExpFlags(cx: *mut JSContext, + obj: HandleObject) -> u32 { + _Z17JS_GetRegExpFlagsP9JSContextN2JS6HandleIP8JSObjectEE(cx, obj) +} +pub unsafe extern "C" fn JS_GetRegExpSource(cx: *mut JSContext, + obj: HandleObject) + -> *mut JSString { + _Z18JS_GetRegExpSourceP9JSContextN2JS6HandleIP8JSObjectEE(cx, obj) +} +pub unsafe extern "C" fn JS_IsExceptionPending(cx: *mut JSContext) -> u8 { + _Z21JS_IsExceptionPendingP9JSContext(cx) +} +pub unsafe extern "C" fn JS_GetPendingException(cx: *mut JSContext, + vp: MutableHandleValue) + -> u8 { + _Z22JS_GetPendingExceptionP9JSContextN2JS13MutableHandleINS1_5ValueEEE(cx, + vp) +} +pub unsafe extern "C" fn JS_SetPendingException(cx: *mut JSContext, + v: HandleValue) { + _Z22JS_SetPendingExceptionP9JSContextN2JS6HandleINS1_5ValueEEE(cx, v) +} +pub unsafe extern "C" fn JS_ClearPendingException(cx: *mut JSContext) { + _Z24JS_ClearPendingExceptionP9JSContext(cx) +} +pub unsafe extern "C" fn JS_ReportPendingException(cx: *mut JSContext) -> u8 { + _Z25JS_ReportPendingExceptionP9JSContext(cx) +} +pub unsafe extern "C" fn JS_SaveExceptionState(cx: *mut JSContext) + -> *mut JSExceptionState { + _Z21JS_SaveExceptionStateP9JSContext(cx) +} +pub unsafe extern "C" fn JS_RestoreExceptionState(cx: *mut JSContext, + state: + *mut JSExceptionState) { + _Z24JS_RestoreExceptionStateP9JSContextP16JSExceptionState(cx, state) +} +pub unsafe extern "C" fn JS_DropExceptionState(cx: *mut JSContext, + state: *mut JSExceptionState) { + _Z21JS_DropExceptionStateP9JSContextP16JSExceptionState(cx, state) +} +pub unsafe extern "C" fn JS_ErrorFromException(cx: *mut JSContext, + obj: HandleObject) + -> *mut JSErrorReport { + _Z21JS_ErrorFromExceptionP9JSContextN2JS6HandleIP8JSObjectEE(cx, obj) +} +pub unsafe extern "C" fn JS_ThrowStopIteration(cx: *mut JSContext) -> u8 { + _Z21JS_ThrowStopIterationP9JSContext(cx) +} +pub unsafe extern "C" fn JS_IsStopIteration(v: Value) -> u8 { + _Z18JS_IsStopIterationN2JS5ValueE(v) +} +pub unsafe extern "C" fn JS_GetCurrentThread() -> i32 { + _Z19JS_GetCurrentThreadv() +} +pub unsafe extern "C" fn JS_AbortIfWrongThread(rt: *mut JSRuntime) { + _Z21JS_AbortIfWrongThreadP9JSRuntime(rt) +} +pub unsafe extern "C" fn JS_NewObjectForConstructor(cx: *mut JSContext, + clasp: *const JSClass, + args: *const CallArgs) + -> *mut JSObject { + _Z26JS_NewObjectForConstructorP9JSContextPK7JSClassRKN2JS8CallArgsE(cx, + clasp, + args) +} +pub unsafe extern "C" fn JS_GetGCZeal(cx: *mut JSContext, zeal: *mut u8, + frequency: *mut u32, + nextScheduled: *mut u32) { + _Z12JS_GetGCZealP9JSContextPhPjS2_(cx, zeal, frequency, nextScheduled) +} +pub unsafe extern "C" fn JS_SetGCZeal(cx: *mut JSContext, zeal: u8, + frequency: u32) { + _Z12JS_SetGCZealP9JSContexthj(cx, zeal, frequency) +} +pub unsafe extern "C" fn JS_ScheduleGC(cx: *mut JSContext, count: u32) { + _Z13JS_ScheduleGCP9JSContextj(cx, count) +} +pub unsafe extern "C" fn JS_SetParallelParsingEnabled(rt: *mut JSRuntime, + enabled: u8) { + _Z28JS_SetParallelParsingEnabledP9JSRuntimeb(rt, enabled) +} +pub unsafe extern "C" fn JS_SetOffthreadIonCompilationEnabled(rt: + *mut JSRuntime, + enabled: u8) { + _Z36JS_SetOffthreadIonCompilationEnabledP9JSRuntimeb(rt, enabled) +} +pub unsafe extern "C" fn JS_SetGlobalJitCompilerOption(rt: *mut JSRuntime, + opt: + JSJitCompilerOption, + value: u32) { + _Z29JS_SetGlobalJitCompilerOptionP9JSRuntime19JSJitCompilerOptionj(rt, + opt, + value) +} +pub unsafe extern "C" fn JS_GetGlobalJitCompilerOption(rt: *mut JSRuntime, + opt: + JSJitCompilerOption) + -> i32 { + _Z29JS_GetGlobalJitCompilerOptionP9JSRuntime19JSJitCompilerOption(rt, opt) +} +pub unsafe extern "C" fn JS_IndexToId(cx: *mut JSContext, index: u32, + arg1: MutableHandleId) -> u8 { + _Z12JS_IndexToIdP9JSContextjN2JS13MutableHandleI4jsidEE(cx, index, arg1) +} +pub unsafe extern "C" fn JS_CharsToId(cx: *mut JSContext, chars: TwoByteChars, + arg1: MutableHandleId) -> u8 { + _Z12JS_CharsToIdP9JSContextN2JS12TwoByteCharsENS1_13MutableHandleI4jsidEE(cx, + chars, + arg1) +} +pub unsafe extern "C" fn JS_IsIdentifier(cx: *mut JSContext, + str: HandleString, + isIdentifier: *mut u8) -> u8 { + _Z15JS_IsIdentifierP9JSContextN2JS6HandleIP8JSStringEEPb(cx, str, + isIdentifier) +} +pub unsafe extern "C" fn JS_IsIdentifier1(chars: *const i16, length: u32) + -> u8 { + _Z15JS_IsIdentifierPKDsj(chars, length) +} +pub unsafe extern "C" fn DescribeScriptedCaller(cx: *mut JSContext, + filename: *mut AutoFilename, + lineno: *mut u32) -> u8 { + _ZN2JS22DescribeScriptedCallerEP9JSContextPNS_12AutoFilenameEPj(cx, + filename, + lineno) +} +pub unsafe extern "C" fn GetScriptedCallerGlobal(cx: *mut JSContext) + -> *mut JSObject { + _ZN2JS23GetScriptedCallerGlobalEP9JSContext(cx) +} +pub unsafe extern "C" fn HideScriptedCaller(cx: *mut JSContext) { + _ZN2JS18HideScriptedCallerEP9JSContext(cx) +} +pub unsafe extern "C" fn UnhideScriptedCaller(cx: *mut JSContext) { + _ZN2JS20UnhideScriptedCallerEP9JSContext(cx) +} +pub unsafe extern "C" fn JS_EncodeScript(cx: *mut JSContext, + script: HandleScript, + lengthp: *mut u32) + -> *mut ::libc::c_void { + _Z15JS_EncodeScriptP9JSContextN2JS6HandleIP8JSScriptEEPj(cx, script, + lengthp) +} +pub unsafe extern "C" fn JS_EncodeInterpretedFunction(cx: *mut JSContext, + funobj: HandleObject, + lengthp: *mut u32) + -> *mut ::libc::c_void { + _Z28JS_EncodeInterpretedFunctionP9JSContextN2JS6HandleIP8JSObjectEEPj(cx, + funobj, + lengthp) +} +pub unsafe extern "C" fn JS_DecodeScript(cx: *mut JSContext, + data: *const ::libc::c_void, + length: u32) -> *mut JSScript { + _Z15JS_DecodeScriptP9JSContextPKvj(cx, data, length) +} +pub unsafe extern "C" fn JS_DecodeInterpretedFunction(cx: *mut JSContext, + data: + *const ::libc::c_void, + length: u32) + -> *mut JSObject { + _Z28JS_DecodeInterpretedFunctionP9JSContextPKvj(cx, data, length) +} +pub unsafe extern "C" fn SetAsmJSCacheOps(rt: *mut JSRuntime, + callbacks: *const AsmJSCacheOps) { + _ZN2JS16SetAsmJSCacheOpsEP9JSRuntimePKNS_13AsmJSCacheOpsE(rt, callbacks) +} +pub unsafe extern "C" fn SetLargeAllocationFailureCallback(rt: *mut JSRuntime, + afc: + LargeAllocationFailureCallback, + data: + *mut ::libc::c_void) { + _ZN2JS33SetLargeAllocationFailureCallbackEP9JSRuntimePFvPvES2_(rt, afc, + data) +} +pub unsafe extern "C" fn SetOutOfMemoryCallback(rt: *mut JSRuntime, + cb: OutOfMemoryCallback, + data: *mut ::libc::c_void) { + _ZN2JS22SetOutOfMemoryCallbackEP9JSRuntimePFvP9JSContextPvES4_(rt, cb, + data) +} +pub unsafe extern "C" fn CaptureCurrentStack(cx: *mut JSContext, + stackp: MutableHandleObject, + maxFrameCount: u32) -> u8 { + _ZN2JS19CaptureCurrentStackEP9JSContextNS_13MutableHandleIP8JSObjectEEj(cx, + stackp, + maxFrameCount) +} +pub unsafe extern "C" fn GetSavedFrameSource(cx: *mut JSContext, + savedFrame: HandleObject, + sourcep: MutableHandleString) + -> SavedFrameResult { + _ZN2JS19GetSavedFrameSourceEP9JSContextNS_6HandleIP8JSObjectEENS_13MutableHandleIP8JSStringEE(cx, + savedFrame, + sourcep) +} +pub unsafe extern "C" fn GetSavedFrameLine(cx: *mut JSContext, + savedFrame: HandleObject, + linep: *mut u32) + -> SavedFrameResult { + _ZN2JS17GetSavedFrameLineEP9JSContextNS_6HandleIP8JSObjectEEPj(cx, + savedFrame, + linep) +} +pub unsafe extern "C" fn GetSavedFrameColumn(cx: *mut JSContext, + savedFrame: HandleObject, + columnp: *mut u32) + -> SavedFrameResult { + _ZN2JS19GetSavedFrameColumnEP9JSContextNS_6HandleIP8JSObjectEEPj(cx, + savedFrame, + columnp) +} +pub unsafe extern "C" fn GetSavedFrameFunctionDisplayName(cx: *mut JSContext, + savedFrame: + HandleObject, + namep: + MutableHandleString) + -> SavedFrameResult { + _ZN2JS32GetSavedFrameFunctionDisplayNameEP9JSContextNS_6HandleIP8JSObjectEENS_13MutableHandleIP8JSStringEE(cx, + savedFrame, + namep) +} +pub unsafe extern "C" fn GetSavedFrameAsyncCause(cx: *mut JSContext, + savedFrame: HandleObject, + asyncCausep: + MutableHandleString) + -> SavedFrameResult { + _ZN2JS23GetSavedFrameAsyncCauseEP9JSContextNS_6HandleIP8JSObjectEENS_13MutableHandleIP8JSStringEE(cx, + savedFrame, + asyncCausep) +} +pub unsafe extern "C" fn GetSavedFrameAsyncParent(cx: *mut JSContext, + savedFrame: HandleObject, + asyncParentp: + MutableHandleObject) + -> SavedFrameResult { + _ZN2JS24GetSavedFrameAsyncParentEP9JSContextNS_6HandleIP8JSObjectEENS_13MutableHandleIS4_EE(cx, + savedFrame, + asyncParentp) +} +pub unsafe extern "C" fn GetSavedFrameParent(cx: *mut JSContext, + savedFrame: HandleObject, + parentp: MutableHandleObject) + -> SavedFrameResult { + _ZN2JS19GetSavedFrameParentEP9JSContextNS_6HandleIP8JSObjectEENS_13MutableHandleIS4_EE(cx, + savedFrame, + parentp) +} +pub unsafe extern "C" fn StringifySavedFrameStack(cx: *mut JSContext, + stack: HandleObject, + stringp: + MutableHandleString) + -> u8 { + _ZN2JS24StringifySavedFrameStackEP9JSContextNS_6HandleIP8JSObjectEENS_13MutableHandleIP8JSStringEE(cx, + stack, + stringp) +} +pub unsafe extern "C" fn CallMethodIfWrapped(cx: *mut JSContext, + test: IsAcceptableThis, + _impl: NativeImpl, + args: CallArgs) -> u8 { + _ZN2JS6detail19CallMethodIfWrappedEP9JSContextPFbNS_6HandleINS_5ValueEEEEPFbS2_NS_8CallArgsEES8_(cx, + test, + _impl, + args) +} +pub unsafe extern "C" fn CallNonGenericMethod(cx: *mut JSContext, + Test: IsAcceptableThis, + Impl: NativeImpl, + args: CallArgs) -> u8 { + _ZN2JS20CallNonGenericMethodEP9JSContextPFbNS_6HandleINS_5ValueEEEEPFbS1_NS_8CallArgsEES7_(cx, + Test, + Impl, + args) +} +pub unsafe extern "C" fn JS_SetGrayGCRootsTracer(rt: *mut JSRuntime, + traceOp: JSTraceDataOp, + data: *mut ::libc::c_void) { + _Z23JS_SetGrayGCRootsTracerP9JSRuntimePFvP8JSTracerPvES3_(rt, traceOp, + data) +} +pub unsafe extern "C" fn JS_GetAnonymousString(rt: *mut JSRuntime) + -> *mut JSString { + _Z21JS_GetAnonymousStringP9JSRuntime(rt) +} +pub unsafe extern "C" fn JS_FindCompilationScope(cx: *mut JSContext, + obj: HandleObject) + -> *mut JSObject { + _Z23JS_FindCompilationScopeP9JSContextN2JS6HandleIP8JSObjectEE(cx, obj) +} +pub unsafe extern "C" fn JS_GetObjectFunction(obj: *mut JSObject) + -> *mut JSFunction { + _Z20JS_GetObjectFunctionP8JSObject(obj) +} +pub unsafe extern "C" fn JS_SplicePrototype(cx: *mut JSContext, + obj: HandleObject, + proto: HandleObject) -> u8 { + _Z18JS_SplicePrototypeP9JSContextN2JS6HandleIP8JSObjectEES5_(cx, obj, + proto) +} +pub unsafe extern "C" fn JS_NewObjectWithUniqueType(cx: *mut JSContext, + clasp: *const JSClass, + proto: HandleObject) + -> *mut JSObject { + _Z26JS_NewObjectWithUniqueTypeP9JSContextPK7JSClassN2JS6HandleIP8JSObjectEE(cx, + clasp, + proto) +} +pub unsafe extern "C" fn JS_NewObjectWithoutMetadata(cx: *mut JSContext, + clasp: *const JSClass, + proto: + Handle<*mut JSObject>) + -> *mut JSObject { + _Z27JS_NewObjectWithoutMetadataP9JSContextPK7JSClassN2JS6HandleIP8JSObjectEE(cx, + clasp, + proto) +} +pub unsafe extern "C" fn JS_ObjectCountDynamicSlots(obj: HandleObject) + -> u32 { + _Z26JS_ObjectCountDynamicSlotsN2JS6HandleIP8JSObjectEE(obj) +} +pub unsafe extern "C" fn JS_SetProtoCalled(cx: *mut JSContext) -> u32 { + _Z17JS_SetProtoCalledP9JSContext(cx) +} +pub unsafe extern "C" fn JS_GetCustomIteratorCount(cx: *mut JSContext) + -> u32 { + _Z25JS_GetCustomIteratorCountP9JSContext(cx) +} +pub unsafe extern "C" fn JS_NondeterministicGetWeakMapKeys(cx: *mut JSContext, + obj: HandleObject, + ret: + MutableHandleObject) + -> u8 { + _Z33JS_NondeterministicGetWeakMapKeysP9JSContextN2JS6HandleIP8JSObjectEENS1_13MutableHandleIS4_EE(cx, + obj, + ret) +} +pub unsafe extern "C" fn JS_PCToLineNumber(script: *mut JSScript, pc: *mut u8, + columnp: *mut u32) -> u32 { + _Z17JS_PCToLineNumberP8JSScriptPhPj(script, pc, columnp) +} +pub unsafe extern "C" fn JS_IsDeadWrapper(obj: *mut JSObject) -> u8 { + _Z16JS_IsDeadWrapperP8JSObject(obj) +} +pub unsafe extern "C" fn JS_TraceShapeCycleCollectorChildren(trc: + *mut JSTracer, + shape: + GCCellPtr) { + _Z35JS_TraceShapeCycleCollectorChildrenP8JSTracerN2JS9GCCellPtrE(trc, + shape) +} +pub unsafe extern "C" fn JS_SetAccumulateTelemetryCallback(rt: *mut JSRuntime, + callback: + JSAccumulateTelemetryDataCallback) { + _Z33JS_SetAccumulateTelemetryCallbackP9JSRuntimePFvijPKcE(rt, callback) +} +pub unsafe extern "C" fn JS_GetCompartmentPrincipals(compartment: + *mut JSCompartment) + -> *mut JSPrincipals { + _Z27JS_GetCompartmentPrincipalsP13JSCompartment(compartment) +} +pub unsafe extern "C" fn JS_SetCompartmentPrincipals(compartment: + *mut JSCompartment, + principals: + *mut JSPrincipals) { + _Z27JS_SetCompartmentPrincipalsP13JSCompartmentP12JSPrincipals(compartment, + principals) +} +pub unsafe extern "C" fn JS_GetScriptPrincipals(script: *mut JSScript) + -> *mut JSPrincipals { + _Z22JS_GetScriptPrincipalsP8JSScript(script) +} +pub unsafe extern "C" fn JS_ScriptHasMutedErrors(script: *mut JSScript) + -> u8 { + _Z23JS_ScriptHasMutedErrorsP8JSScript(script) +} +pub unsafe extern "C" fn JS_ObjectToInnerObject(cx: *mut JSContext, + obj: HandleObject) + -> *mut JSObject { + _Z22JS_ObjectToInnerObjectP9JSContextN2JS6HandleIP8JSObjectEE(cx, obj) +} +pub unsafe extern "C" fn JS_ObjectToOuterObject(cx: *mut JSContext, + obj: HandleObject) + -> *mut JSObject { + _Z22JS_ObjectToOuterObjectP9JSContextN2JS6HandleIP8JSObjectEE(cx, obj) +} +pub unsafe extern "C" fn JS_CloneObject(cx: *mut JSContext, obj: HandleObject, + proto: HandleObject) + -> *mut JSObject { + _Z14JS_CloneObjectP9JSContextN2JS6HandleIP8JSObjectEES5_(cx, obj, proto) +} +pub unsafe extern "C" fn JS_InitializePropertiesFromCompatibleNativeObject(cx: + *mut JSContext, + dst: + HandleObject, + src: + HandleObject) + -> u8 { + _Z49JS_InitializePropertiesFromCompatibleNativeObjectP9JSContextN2JS6HandleIP8JSObjectEES5_(cx, + dst, + src) +} +pub unsafe extern "C" fn JS_BasicObjectToString(cx: *mut JSContext, + obj: HandleObject) + -> *mut JSString { + _Z22JS_BasicObjectToStringP9JSContextN2JS6HandleIP8JSObjectEE(cx, obj) +} +pub unsafe extern "C" fn ObjectClassIs1(cx: *mut JSContext, obj: HandleObject, + classValue: ESClassValue) -> u8 { + _ZN2js13ObjectClassIsEP9JSContextN2JS6HandleIP8JSObjectEENS_12ESClassValueE(cx, + obj, + classValue) +} +pub unsafe extern "C" fn ObjectClassName(cx: *mut JSContext, + obj: HandleObject) -> *const i8 { + _ZN2js15ObjectClassNameEP9JSContextN2JS6HandleIP8JSObjectEE(cx, obj) +} +pub unsafe extern "C" fn ReportOverRecursed(maybecx: *mut JSContext) { + _ZN2js18ReportOverRecursedEP9JSContext(maybecx) +} +pub unsafe extern "C" fn AddRawValueRoot(cx: *mut JSContext, vp: *mut Value, + name: *const i8) -> u8 { + _ZN2js15AddRawValueRootEP9JSContextPN2JS5ValueEPKc(cx, vp, name) +} +pub unsafe extern "C" fn RemoveRawValueRoot(cx: *mut JSContext, + vp: *mut Value) { + _ZN2js18RemoveRawValueRootEP9JSContextPN2JS5ValueE(cx, vp) +} +pub unsafe extern "C" fn DumpBacktrace(cx: *mut JSContext) { + _ZN2js13DumpBacktraceEP9JSContext(cx) +} +pub unsafe extern "C" fn FormatStackDump(cx: *mut JSContext, buf: *mut i8, + showArgs: u8, showLocals: u8, + showThisProps: u8) -> *mut i8 { + _ZN2JS15FormatStackDumpEP9JSContextPcbbb(cx, buf, showArgs, showLocals, + showThisProps) +} +pub unsafe extern "C" fn JS_CopyPropertiesFrom(cx: *mut JSContext, + target: HandleObject, + obj: HandleObject) -> u8 { + _Z21JS_CopyPropertiesFromP9JSContextN2JS6HandleIP8JSObjectEES5_(cx, + target, + obj) +} +pub unsafe extern "C" fn JS_CopyPropertyFrom(cx: *mut JSContext, id: HandleId, + target: HandleObject, + obj: HandleObject, + copyBehavior: + PropertyCopyBehavior) -> u8 { + _Z19JS_CopyPropertyFromP9JSContextN2JS6HandleI4jsidEENS2_IP8JSObjectEES7_20PropertyCopyBehavior(cx, + id, + target, + obj, + copyBehavior) +} +pub unsafe extern "C" fn JS_WrapPropertyDescriptor(cx: *mut JSContext, + desc: + MutableHandle) + -> u8 { + _Z25JS_WrapPropertyDescriptorP9JSContextN2JS13MutableHandleI20JSPropertyDescriptorEE(cx, + desc) +} +pub unsafe extern "C" fn JS_DefineFunctionsWithHelp(cx: *mut JSContext, + obj: HandleObject, + fs: + *const JSFunctionSpecWithHelp) + -> u8 { + _Z26JS_DefineFunctionsWithHelpP9JSContextN2JS6HandleIP8JSObjectEEPK22JSFunctionSpecWithHelp(cx, + obj, + fs) +} +pub unsafe extern "C" fn proxy_LookupProperty(cx: *mut JSContext, + obj: HandleObject, id: HandleId, + objp: MutableHandleObject, + propp: + MutableHandle<*mut Shape>) + -> u8 { + _ZN2js20proxy_LookupPropertyEP9JSContextN2JS6HandleIP8JSObjectEENS3_I4jsidEENS2_13MutableHandleIS5_EENS9_IPNS_5ShapeEEE(cx, + obj, + id, + objp, + propp) +} +pub unsafe extern "C" fn proxy_DefineProperty(cx: *mut JSContext, + obj: HandleObject, id: HandleId, + value: HandleValue, + getter: JSGetterOp, + setter: JSSetterOp, attrs: u32, + result: *mut ObjectOpResult) + -> u8 { + _ZN2js20proxy_DefinePropertyEP9JSContextN2JS6HandleIP8JSObjectEENS3_I4jsidEENS3_INS2_5ValueEEEPFbS1_S6_S8_NS2_13MutableHandleIS9_EEEPFbS1_S6_S8_SC_RNS2_14ObjectOpResultEEjSG_(cx, + obj, + id, + value, + getter, + setter, + attrs, + result) +} +pub unsafe extern "C" fn proxy_HasProperty(cx: *mut JSContext, + obj: HandleObject, id: HandleId, + foundp: *mut u8) -> u8 { + _ZN2js17proxy_HasPropertyEP9JSContextN2JS6HandleIP8JSObjectEENS3_I4jsidEEPb(cx, + obj, + id, + foundp) +} +pub unsafe extern "C" fn proxy_GetProperty(cx: *mut JSContext, + obj: HandleObject, + receiver: HandleObject, + id: HandleId, + vp: MutableHandleValue) -> u8 { + _ZN2js17proxy_GetPropertyEP9JSContextN2JS6HandleIP8JSObjectEES6_NS3_I4jsidEENS2_13MutableHandleINS2_5ValueEEE(cx, + obj, + receiver, + id, + vp) +} +pub unsafe extern "C" fn proxy_SetProperty(cx: *mut JSContext, + obj: HandleObject, + receiver: HandleObject, + id: HandleId, + bp: MutableHandleValue, + result: *mut ObjectOpResult) + -> u8 { + _ZN2js17proxy_SetPropertyEP9JSContextN2JS6HandleIP8JSObjectEES6_NS3_I4jsidEENS2_13MutableHandleINS2_5ValueEEERNS2_14ObjectOpResultE(cx, + obj, + receiver, + id, + bp, + result) +} +pub unsafe extern "C" fn proxy_GetOwnPropertyDescriptor(cx: *mut JSContext, + obj: HandleObject, + id: HandleId, + desc: + MutableHandle) + -> u8 { + _ZN2js30proxy_GetOwnPropertyDescriptorEP9JSContextN2JS6HandleIP8JSObjectEENS3_I4jsidEENS2_13MutableHandleI20JSPropertyDescriptorEE(cx, + obj, + id, + desc) +} +pub unsafe extern "C" fn proxy_DeleteProperty(cx: *mut JSContext, + obj: HandleObject, id: HandleId, + result: *mut ObjectOpResult) + -> u8 { + _ZN2js20proxy_DeletePropertyEP9JSContextN2JS6HandleIP8JSObjectEENS3_I4jsidEERNS2_14ObjectOpResultE(cx, + obj, + id, + result) +} +pub unsafe extern "C" fn proxy_Trace(trc: *mut JSTracer, obj: *mut JSObject) { + _ZN2js11proxy_TraceEP8JSTracerP8JSObject(trc, obj) +} +pub unsafe extern "C" fn proxy_WeakmapKeyDelegate(obj: *mut JSObject) + -> *mut JSObject { + _ZN2js24proxy_WeakmapKeyDelegateEP8JSObject(obj) +} +pub unsafe extern "C" fn proxy_Convert(cx: *mut JSContext, + proxy: HandleObject, hint: JSType, + vp: MutableHandleValue) -> u8 { + _ZN2js13proxy_ConvertEP9JSContextN2JS6HandleIP8JSObjectEE6JSTypeNS2_13MutableHandleINS2_5ValueEEE(cx, + proxy, + hint, + vp) +} +pub unsafe extern "C" fn proxy_Finalize(fop: *mut FreeOp, + obj: *mut JSObject) { + _ZN2js14proxy_FinalizeEPNS_6FreeOpEP8JSObject(fop, obj) +} +pub unsafe extern "C" fn proxy_ObjectMoved(obj: *mut JSObject, + old: *const JSObject) { + _ZN2js17proxy_ObjectMovedEP8JSObjectPKS0_(obj, old) +} +pub unsafe extern "C" fn proxy_HasInstance(cx: *mut JSContext, + proxy: HandleObject, + v: MutableHandleValue, bp: *mut u8) + -> u8 { + _ZN2js17proxy_HasInstanceEP9JSContextN2JS6HandleIP8JSObjectEENS2_13MutableHandleINS2_5ValueEEEPb(cx, + proxy, + v, + bp) +} +pub unsafe extern "C" fn proxy_Call(cx: *mut JSContext, argc: u32, + vp: *mut Value) -> u8 { + _ZN2js10proxy_CallEP9JSContextjPN2JS5ValueE(cx, argc, vp) +} +pub unsafe extern "C" fn proxy_Construct(cx: *mut JSContext, argc: u32, + vp: *mut Value) -> u8 { + _ZN2js15proxy_ConstructEP9JSContextjPN2JS5ValueE(cx, argc, vp) +} +pub unsafe extern "C" fn proxy_innerObject(obj: *mut JSObject) + -> *mut JSObject { + _ZN2js17proxy_innerObjectEP8JSObject(obj) +} +pub unsafe extern "C" fn proxy_Watch(cx: *mut JSContext, obj: HandleObject, + id: HandleId, callable: HandleObject) + -> u8 { + _ZN2js11proxy_WatchEP9JSContextN2JS6HandleIP8JSObjectEENS3_I4jsidEES6_(cx, + obj, + id, + callable) +} +pub unsafe extern "C" fn proxy_Unwatch(cx: *mut JSContext, obj: HandleObject, + id: HandleId) -> u8 { + _ZN2js13proxy_UnwatchEP9JSContextN2JS6HandleIP8JSObjectEENS3_I4jsidEE(cx, + obj, + id) +} +pub unsafe extern "C" fn proxy_GetElements(cx: *mut JSContext, + proxy: HandleObject, begin: u32, + end: u32, adder: *mut ElementAdder) + -> u8 { + _ZN2js17proxy_GetElementsEP9JSContextN2JS6HandleIP8JSObjectEEjjPNS_12ElementAdderE(cx, + proxy, + begin, + end, + adder) +} +pub unsafe extern "C" fn SetSourceHook(rt: *mut JSRuntime, + hook: + UniquePtr) { + _ZN2js13SetSourceHookEP9JSRuntimeN7mozilla9UniquePtrINS_10SourceHookENS2_13DefaultDeleteIS4_EEEE(rt, + hook) +} +pub unsafe extern "C" fn ForgetSourceHook(rt: *mut JSRuntime) + -> UniquePtr { + _ZN2js16ForgetSourceHookEP9JSRuntime(rt) +} +pub unsafe extern "C" fn GetCompartmentZone(comp: *mut JSCompartment) + -> *mut Zone { + _ZN2js18GetCompartmentZoneEP13JSCompartment(comp) +} +pub unsafe extern "C" fn DumpHeapComplete(rt: *mut JSRuntime, fp: *mut FILE, + nurseryBehaviour: + DumpHeapNurseryBehaviour) { + _ZN2js16DumpHeapCompleteEP9JSRuntimeP8_IO_FILENS_24DumpHeapNurseryBehaviourE(rt, + fp, + nurseryBehaviour) +} +pub unsafe extern "C" fn obj_defineGetter(cx: *mut JSContext, argc: u32, + vp: *mut Value) -> u8 { + _ZN2js16obj_defineGetterEP9JSContextjPN2JS5ValueE(cx, argc, vp) +} +pub unsafe extern "C" fn obj_defineSetter(cx: *mut JSContext, argc: u32, + vp: *mut Value) -> u8 { + _ZN2js16obj_defineSetterEP9JSContextjPN2JS5ValueE(cx, argc, vp) +} +pub unsafe extern "C" fn IsSystemCompartment(comp: *mut JSCompartment) -> u8 { + _ZN2js19IsSystemCompartmentEP13JSCompartment(comp) +} +pub unsafe extern "C" fn IsSystemZone(zone: *mut Zone) -> u8 { + _ZN2js12IsSystemZoneEPN2JS4ZoneE(zone) +} +pub unsafe extern "C" fn IsAtomsCompartment(comp: *mut JSCompartment) -> u8 { + _ZN2js18IsAtomsCompartmentEP13JSCompartment(comp) +} +pub unsafe extern "C" fn IsInNonStrictPropertySet(cx: *mut JSContext) -> u8 { + _ZN2js24IsInNonStrictPropertySetEP9JSContext(cx) +} +pub unsafe extern "C" fn TraceWeakMaps(trc: *mut WeakMapTracer) { + _ZN2js13TraceWeakMapsEPNS_13WeakMapTracerE(trc) +} +pub unsafe extern "C" fn AreGCGrayBitsValid(rt: *mut JSRuntime) -> u8 { + _ZN2js18AreGCGrayBitsValidEP9JSRuntime(rt) +} +pub unsafe extern "C" fn ZoneGlobalsAreAllGray(zone: *mut Zone) -> u8 { + _ZN2js21ZoneGlobalsAreAllGrayEPN2JS4ZoneE(zone) +} +pub unsafe extern "C" fn VisitGrayWrapperTargets(zone: *mut Zone, + callback: GCThingCallback, + closure: + *mut ::libc::c_void) { + _ZN2js23VisitGrayWrapperTargetsEPN2JS4ZoneEPFvPvNS0_9GCCellPtrEES3_(zone, + callback, + closure) +} +pub unsafe extern "C" fn GetWeakmapKeyDelegate(key: *mut JSObject) + -> *mut JSObject { + _ZN2js21GetWeakmapKeyDelegateEP8JSObject(key) +} +pub unsafe extern "C" fn GCThingTraceKind(thing: *mut ::libc::c_void) + -> JSGCTraceKind { + _ZN2js16GCThingTraceKindEPv(thing) +} +pub unsafe extern "C" fn IterateGrayObjects(zone: *mut Zone, + cellCallback: GCThingCallback, + data: *mut ::libc::c_void) { + _ZN2js18IterateGrayObjectsEPN2JS4ZoneEPFvPvNS0_9GCCellPtrEES3_(zone, + cellCallback, + data) +} +pub unsafe extern "C" fn SizeOfDataIfCDataObject(mallocSizeOf: MallocSizeOf, + obj: *mut JSObject) -> u32 { + _ZN2js23SizeOfDataIfCDataObjectEPFjPKvEP8JSObject(mallocSizeOf, obj) +} +pub unsafe extern "C" fn GetAnyCompartmentInZone(zone: *mut Zone) + -> *mut JSCompartment { + _ZN2js23GetAnyCompartmentInZoneEPN2JS4ZoneE(zone) +} +pub unsafe extern "C" fn GetObjectClass(obj: *mut JSObject) -> *const Class { + _ZN2js14GetObjectClassEP8JSObject(obj) +} +pub unsafe extern "C" fn GetObjectJSClass(obj: *mut JSObject) + -> *const JSClass { + _ZN2js16GetObjectJSClassEP8JSObject(obj) +} +pub unsafe extern "C" fn ProtoKeyToClass(key: JSProtoKey) -> *const Class { + _ZN2js15ProtoKeyToClassE10JSProtoKey(key) +} +pub unsafe extern "C" fn StandardClassIsDependent(key: JSProtoKey) -> u8 { + _ZN2js24StandardClassIsDependentE10JSProtoKey(key) +} +pub unsafe extern "C" fn ParentKeyForStandardClass(key: JSProtoKey) + -> JSProtoKey { + _ZN2js25ParentKeyForStandardClassE10JSProtoKey(key) +} +pub unsafe extern "C" fn IsInnerObject(obj: *mut JSObject) -> u8 { + _ZN2js13IsInnerObjectEP8JSObject(obj) +} +pub unsafe extern "C" fn IsOuterObject(obj: *mut JSObject) -> u8 { + _ZN2js13IsOuterObjectEP8JSObject(obj) +} +pub unsafe extern "C" fn IsFunctionObject(obj: *mut JSObject) -> u8 { + _ZN2js16IsFunctionObjectEP8JSObject(obj) +} +pub unsafe extern "C" fn IsScopeObject(obj: *mut JSObject) -> u8 { + _ZN2js13IsScopeObjectEP8JSObject(obj) +} +pub unsafe extern "C" fn IsCallObject(obj: *mut JSObject) -> u8 { + _ZN2js12IsCallObjectEP8JSObject(obj) +} +pub unsafe extern "C" fn CanAccessObjectShape(obj: *mut JSObject) -> u8 { + _ZN2js20CanAccessObjectShapeEP8JSObject(obj) +} +pub unsafe extern "C" fn GetGlobalForObjectCrossCompartment(obj: + *mut JSObject) + -> *mut JSObject { + _ZN2js34GetGlobalForObjectCrossCompartmentEP8JSObject(obj) +} +pub unsafe extern "C" fn GetPrototypeNoProxy(obj: *mut JSObject) + -> *mut JSObject { + _ZN2js19GetPrototypeNoProxyEP8JSObject(obj) +} +pub unsafe extern "C" fn SetPendingExceptionCrossContext(cx: *mut JSContext, + v: HandleValue) { + _ZN2js31SetPendingExceptionCrossContextEP9JSContextN2JS6HandleINS2_5ValueEEE(cx, + v) +} +pub unsafe extern "C" fn AssertSameCompartment(cx: *mut JSContext, + obj: *mut JSObject) { + _ZN2js21AssertSameCompartmentEP9JSContextP8JSObject(cx, obj) +} +pub unsafe extern "C" fn AssertSameCompartment1(objA: *mut JSObject, + objB: *mut JSObject) { + _ZN2js21AssertSameCompartmentEP8JSObjectS1_(objA, objB) +} +pub unsafe extern "C" fn NotifyAnimationActivity(obj: *mut JSObject) { + _ZN2js23NotifyAnimationActivityEP8JSObject(obj) +} +pub unsafe extern "C" fn GetOutermostEnclosingFunctionOfScriptedCaller(cx: + *mut JSContext) + -> *mut JSFunction { + _ZN2js45GetOutermostEnclosingFunctionOfScriptedCallerEP9JSContext(cx) +} +pub unsafe extern "C" fn DefineFunctionWithReserved(cx: *mut JSContext, + obj: *mut JSObject, + name: *const i8, + call: JSNative, + nargs: u32, attrs: u32) + -> *mut JSFunction { + _ZN2js26DefineFunctionWithReservedEP9JSContextP8JSObjectPKcPFbS1_jPN2JS5ValueEEjj(cx, + obj, + name, + call, + nargs, + attrs) +} +pub unsafe extern "C" fn NewFunctionWithReserved(cx: *mut JSContext, + call: JSNative, nargs: u32, + flags: u32, name: *const i8) + -> *mut JSFunction { + _ZN2js23NewFunctionWithReservedEP9JSContextPFbS1_jPN2JS5ValueEEjjPKc(cx, + call, + nargs, + flags, + name) +} +pub unsafe extern "C" fn NewFunctionByIdWithReserved(cx: *mut JSContext, + native: JSNative, + nargs: u32, flags: u32, + id: jsid) + -> *mut JSFunction { + _ZN2js27NewFunctionByIdWithReservedEP9JSContextPFbS1_jPN2JS5ValueEEjj4jsid(cx, + native, + nargs, + flags, + id) +} +pub unsafe extern "C" fn GetFunctionNativeReserved(fun: *mut JSObject, + which: u32) + -> *const Value { + _ZN2js25GetFunctionNativeReservedEP8JSObjectj(fun, which) +} +pub unsafe extern "C" fn SetFunctionNativeReserved(fun: *mut JSObject, + which: u32, + val: *const Value) { + _ZN2js25SetFunctionNativeReservedEP8JSObjectjRKN2JS5ValueE(fun, which, + val) +} +pub unsafe extern "C" fn FunctionHasNativeReserved(fun: *mut JSObject) -> u8 { + _ZN2js25FunctionHasNativeReservedEP8JSObject(fun) +} +pub unsafe extern "C" fn GetObjectProto(cx: *mut JSContext, obj: HandleObject, + proto: MutableHandleObject) -> u8 { + _ZN2js14GetObjectProtoEP9JSContextN2JS6HandleIP8JSObjectEENS2_13MutableHandleIS5_EE(cx, + obj, + proto) +} +pub unsafe extern "C" fn GetOriginalEval(cx: *mut JSContext, + scope: HandleObject, + eval: MutableHandleObject) -> u8 { + _ZN2js15GetOriginalEvalEP9JSContextN2JS6HandleIP8JSObjectEENS2_13MutableHandleIS5_EE(cx, + scope, + eval) +} +pub unsafe extern "C" fn GetObjectPrivate(obj: *mut JSObject) + -> *mut ::libc::c_void { + _ZN2js16GetObjectPrivateEP8JSObject(obj) +} +pub unsafe extern "C" fn GetReservedSlot(obj: *mut JSObject, slot: u32) + -> *const Value { + _ZN2js15GetReservedSlotEP8JSObjectj(obj, slot) +} +pub unsafe extern "C" fn SetReservedOrProxyPrivateSlotWithBarrier(obj: + *mut JSObject, + slot: u32, + value: + *const Value) { + _ZN2js40SetReservedOrProxyPrivateSlotWithBarrierEP8JSObjectjRKN2JS5ValueE(obj, + slot, + value) +} +pub unsafe extern "C" fn SetReservedSlot(obj: *mut JSObject, slot: u32, + value: *const Value) { + _ZN2js15SetReservedSlotEP8JSObjectjRKN2JS5ValueE(obj, slot, value) +} +pub unsafe extern "C" fn GetObjectSlotSpan(obj: *mut JSObject) -> u32 { + _ZN2js17GetObjectSlotSpanEP8JSObject(obj) +} +pub unsafe extern "C" fn GetObjectSlot(obj: *mut JSObject, slot: u32) + -> *const Value { + _ZN2js13GetObjectSlotEP8JSObjectj(obj, slot) +} +pub unsafe extern "C" fn GetAtomLength(atom: *mut JSAtom) -> u32 { + _ZN2js13GetAtomLengthEP6JSAtom(atom) +} +pub unsafe extern "C" fn GetStringLength(s: *mut JSString) -> u32 { + _ZN2js15GetStringLengthEP8JSString(s) +} +pub unsafe extern "C" fn GetFlatStringLength(s: *mut JSFlatString) -> u32 { + _ZN2js19GetFlatStringLengthEP12JSFlatString(s) +} +pub unsafe extern "C" fn GetLinearStringLength(s: *mut JSLinearString) + -> u32 { + _ZN2js21GetLinearStringLengthEP14JSLinearString(s) +} +pub unsafe extern "C" fn LinearStringHasLatin1Chars(s: *mut JSLinearString) + -> u8 { + _ZN2js26LinearStringHasLatin1CharsEP14JSLinearString(s) +} +pub unsafe extern "C" fn AtomHasLatin1Chars(atom: *mut JSAtom) -> u8 { + _ZN2js18AtomHasLatin1CharsEP6JSAtom(atom) +} +pub unsafe extern "C" fn StringHasLatin1Chars(s: *mut JSString) -> u8 { + _ZN2js20StringHasLatin1CharsEP8JSString(s) +} +pub unsafe extern "C" fn GetLatin1LinearStringChars(nogc: + *const AutoCheckCannotGC, + linear: + *mut JSLinearString) + -> *const Latin1Char { + _ZN2js26GetLatin1LinearStringCharsERKN2JS17AutoCheckCannotGCEP14JSLinearString(nogc, + linear) +} +pub unsafe extern "C" fn GetTwoByteLinearStringChars(nogc: + *const AutoCheckCannotGC, + linear: + *mut JSLinearString) + -> *const i16 { + _ZN2js27GetTwoByteLinearStringCharsERKN2JS17AutoCheckCannotGCEP14JSLinearString(nogc, + linear) +} +pub unsafe extern "C" fn AtomToLinearString(atom: *mut JSAtom) + -> *mut JSLinearString { + _ZN2js18AtomToLinearStringEP6JSAtom(atom) +} +pub unsafe extern "C" fn FlatStringToLinearString(s: *mut JSFlatString) + -> *mut JSLinearString { + _ZN2js24FlatStringToLinearStringEP12JSFlatString(s) +} +pub unsafe extern "C" fn GetLatin1AtomChars(nogc: *const AutoCheckCannotGC, + atom: *mut JSAtom) + -> *const Latin1Char { + _ZN2js18GetLatin1AtomCharsERKN2JS17AutoCheckCannotGCEP6JSAtom(nogc, atom) +} +pub unsafe extern "C" fn GetTwoByteAtomChars(nogc: *const AutoCheckCannotGC, + atom: *mut JSAtom) + -> *const i16 { + _ZN2js19GetTwoByteAtomCharsERKN2JS17AutoCheckCannotGCEP6JSAtom(nogc, atom) +} +pub unsafe extern "C" fn StringToLinearStringSlow(cx: *mut JSContext, + str: *mut JSString) + -> *mut JSLinearString { + _ZN2js24StringToLinearStringSlowEP9JSContextP8JSString(cx, str) +} +pub unsafe extern "C" fn StringToLinearString(cx: *mut JSContext, + str: *mut JSString) + -> *mut JSLinearString { + _ZN2js20StringToLinearStringEP9JSContextP8JSString(cx, str) +} +pub unsafe extern "C" fn CopyLinearStringChars(dest: *mut i16, + s: *mut JSLinearString, + len: u32) { + _ZN2js21CopyLinearStringCharsEPDsP14JSLinearStringj(dest, s, len) +} +pub unsafe extern "C" fn CopyStringChars(cx: *mut JSContext, dest: *mut i16, + s: *mut JSString, len: u32) -> u8 { + _ZN2js15CopyStringCharsEP9JSContextPDsP8JSStringj(cx, dest, s, len) +} +pub unsafe extern "C" fn CopyFlatStringChars(dest: *mut i16, + s: *mut JSFlatString, len: u32) { + _ZN2js19CopyFlatStringCharsEPDsP12JSFlatStringj(dest, s, len) +} +pub unsafe extern "C" fn GetPropertyKeys(cx: *mut JSContext, + obj: HandleObject, flags: u32, + props: *mut AutoIdVector) -> u8 { + _ZN2js15GetPropertyKeysEP9JSContextN2JS6HandleIP8JSObjectEEjPNS2_12AutoIdVectorE(cx, + obj, + flags, + props) +} +pub unsafe extern "C" fn AppendUnique(cx: *mut JSContext, + base: *mut AutoIdVector, + others: *mut AutoIdVector) -> u8 { + _ZN2js12AppendUniqueEP9JSContextRN2JS12AutoIdVectorES4_(cx, base, others) +} +pub unsafe extern "C" fn GetGeneric(cx: *mut JSContext, obj: *mut JSObject, + receiver: *mut JSObject, id: jsid, + vp: *mut Value) -> u8 { + _ZN2js10GetGenericEP9JSContextP8JSObjectS3_4jsidPN2JS5ValueE(cx, obj, + receiver, id, + vp) +} +pub unsafe extern "C" fn StringIsArrayIndex(str: *mut JSLinearString, + indexp: *mut u32) -> u8 { + _ZN2js18StringIsArrayIndexEP14JSLinearStringPj(str, indexp) +} +pub unsafe extern "C" fn SetPreserveWrapperCallback(rt: *mut JSRuntime, + callback: + PreserveWrapperCallback) { + _ZN2js26SetPreserveWrapperCallbackEP9JSRuntimePFbP9JSContextP8JSObjectE(rt, + callback) +} +pub unsafe extern "C" fn IsObjectInContextCompartment(obj: *mut JSObject, + cx: *const JSContext) + -> u8 { + _ZN2js28IsObjectInContextCompartmentEP8JSObjectPK9JSContext(obj, cx) +} +pub unsafe extern "C" fn RunningWithTrustedPrincipals(cx: *mut JSContext) + -> u8 { + _ZN2js28RunningWithTrustedPrincipalsEP9JSContext(cx) +} +pub unsafe extern "C" fn GetNativeStackLimit(cx: *mut JSContext, + kind: StackKind, + extraAllowance: i32) -> u32 { + _ZN2js19GetNativeStackLimitEP9JSContextNS_9StackKindEi(cx, kind, + extraAllowance) +} +pub unsafe extern "C" fn GetNativeStackLimit1(cx: *mut JSContext, + extraAllowance: i32) -> u32 { + _ZN2js19GetNativeStackLimitEP9JSContexti(cx, extraAllowance) +} +pub unsafe extern "C" fn StartPCCountProfiling(cx: *mut JSContext) { + _ZN2js21StartPCCountProfilingEP9JSContext(cx) +} +pub unsafe extern "C" fn StopPCCountProfiling(cx: *mut JSContext) { + _ZN2js20StopPCCountProfilingEP9JSContext(cx) +} +pub unsafe extern "C" fn PurgePCCounts(cx: *mut JSContext) { + _ZN2js13PurgePCCountsEP9JSContext(cx) +} +pub unsafe extern "C" fn GetPCCountScriptCount(cx: *mut JSContext) -> u32 { + _ZN2js21GetPCCountScriptCountEP9JSContext(cx) +} +pub unsafe extern "C" fn GetPCCountScriptSummary(cx: *mut JSContext, + script: u32) + -> *mut JSString { + _ZN2js23GetPCCountScriptSummaryEP9JSContextj(cx, script) +} +pub unsafe extern "C" fn GetPCCountScriptContents(cx: *mut JSContext, + script: u32) + -> *mut JSString { + _ZN2js24GetPCCountScriptContentsEP9JSContextj(cx, script) +} +pub unsafe extern "C" fn ContextHasOutstandingRequests(cx: *const JSContext) + -> u8 { + _ZN2js29ContextHasOutstandingRequestsEPK9JSContext(cx) +} +pub unsafe extern "C" fn SetActivityCallback(rt: *mut JSRuntime, + cb: ActivityCallback, + arg: *mut ::libc::c_void) { + _ZN2js19SetActivityCallbackEP9JSRuntimePFvPvbES2_(rt, cb, arg) +} +pub unsafe extern "C" fn GetContextStructuredCloneCallbacks(cx: + *mut JSContext) + -> *const JSStructuredCloneCallbacks { + _ZN2js34GetContextStructuredCloneCallbacksEP9JSContext(cx) +} +pub unsafe extern "C" fn IsContextRunningJS(cx: *mut JSContext) -> u8 { + _ZN2js18IsContextRunningJSEP9JSContext(cx) +} +pub unsafe extern "C" fn SetDOMCallbacks(rt: *mut JSRuntime, + callbacks: *const DOMCallbacks) { + _ZN2js15SetDOMCallbacksEP9JSRuntimePKNS_14JSDOMCallbacksE(rt, callbacks) +} +pub unsafe extern "C" fn GetDOMCallbacks(rt: *mut JSRuntime) + -> *const DOMCallbacks { + _ZN2js15GetDOMCallbacksEP9JSRuntime(rt) +} +pub unsafe extern "C" fn GetTestingFunctions(cx: *mut JSContext) + -> *mut JSObject { + _ZN2js19GetTestingFunctionsEP9JSContext(cx) +} +pub unsafe extern "C" fn CastToJSFreeOp(fop: *mut FreeOp) -> *mut JSFreeOp { + _ZN2js14CastToJSFreeOpEPNS_6FreeOpE(fop) +} +pub unsafe extern "C" fn GetErrorTypeName(rt: *mut JSRuntime, exnType: i16) + -> *mut JSFlatString { + _ZN2js16GetErrorTypeNameEP9JSRuntimes(rt, exnType) +} +pub unsafe extern "C" fn RegExpToSharedNonInline(cx: *mut JSContext, + regexp: HandleObject, + shared: *mut RegExpGuard) + -> u8 { + _ZN2js23RegExpToSharedNonInlineEP9JSContextN2JS6HandleIP8JSObjectEEPNS_11RegExpGuardE(cx, + regexp, + shared) +} +pub unsafe extern "C" fn NukeCrossCompartmentWrappers(cx: *mut JSContext, + sourceFilter: + *const CompartmentFilter, + targetFilter: + *const CompartmentFilter, + nukeReferencesToWindow: + NukeReferencesToWindow) + -> u8 { + _ZN2js28NukeCrossCompartmentWrappersEP9JSContextRKNS_17CompartmentFilterES4_NS_22NukeReferencesToWindowE(cx, + sourceFilter, + targetFilter, + nukeReferencesToWindow) +} +pub unsafe extern "C" fn SetDOMProxyInformation(domProxyHandlerFamily: + *const ::libc::c_void, + domProxyExpandoSlot: u32, + domProxyShadowsCheck: + DOMProxyShadowsCheck) { + _ZN2js22SetDOMProxyInformationEPKvjPFNS_21DOMProxyShadowsResultEP9JSContextN2JS6HandleIP8JSObjectEENS6_I4jsidEEE(domProxyHandlerFamily, + domProxyExpandoSlot, + domProxyShadowsCheck) +} +pub unsafe extern "C" fn GetDOMProxyHandlerFamily() -> *const ::libc::c_void { + _ZN2js24GetDOMProxyHandlerFamilyEv() +} +pub unsafe extern "C" fn GetDOMProxyExpandoSlot() -> u32 { + _ZN2js22GetDOMProxyExpandoSlotEv() +} +pub unsafe extern "C" fn GetDOMProxyShadowsCheck() -> DOMProxyShadowsCheck { + _ZN2js23GetDOMProxyShadowsCheckEv() +} +pub unsafe extern "C" fn DOMProxyIsShadowing(result: DOMProxyShadowsResult) + -> u8 { + _ZN2js19DOMProxyIsShadowingENS_21DOMProxyShadowsResultE(result) +} +pub unsafe extern "C" fn DateIsValid(cx: *mut JSContext, obj: *mut JSObject) + -> u8 { + _ZN2js11DateIsValidEP9JSContextP8JSObject(cx, obj) +} +pub unsafe extern "C" fn DateGetMsecSinceEpoch(cx: *mut JSContext, + obj: *mut JSObject) -> f64 { + _ZN2js21DateGetMsecSinceEpochEP9JSContextP8JSObject(cx, obj) +} +pub unsafe extern "C" fn GetErrorMessage(userRef: *mut ::libc::c_void, + errorNumber: u32) + -> *const JSErrorFormatString { + _ZN2js15GetErrorMessageEPvj(userRef, errorNumber) +} +pub unsafe extern "C" fn ErrorReportToString(cx: *mut JSContext, + reportp: *mut JSErrorReport) + -> *mut JSString { + _ZN2js19ErrorReportToStringEP9JSContextP13JSErrorReport(cx, reportp) +} +pub unsafe extern "C" fn GetSCOffset(writer: *mut JSStructuredCloneWriter) + -> u64 { + _ZN2js11GetSCOffsetEP23JSStructuredCloneWriter(writer) +} +pub unsafe extern "C" fn JS_NewInt8Array(cx: *mut JSContext, nelements: u32) + -> *mut JSObject { + _Z15JS_NewInt8ArrayP9JSContextj(cx, nelements) +} +pub unsafe extern "C" fn JS_NewUint8Array(cx: *mut JSContext, nelements: u32) + -> *mut JSObject { + _Z16JS_NewUint8ArrayP9JSContextj(cx, nelements) +} +pub unsafe extern "C" fn JS_NewUint8ClampedArray(cx: *mut JSContext, + nelements: u32) + -> *mut JSObject { + _Z23JS_NewUint8ClampedArrayP9JSContextj(cx, nelements) +} +pub unsafe extern "C" fn JS_NewInt16Array(cx: *mut JSContext, nelements: u32) + -> *mut JSObject { + _Z16JS_NewInt16ArrayP9JSContextj(cx, nelements) +} +pub unsafe extern "C" fn JS_NewUint16Array(cx: *mut JSContext, nelements: u32) + -> *mut JSObject { + _Z17JS_NewUint16ArrayP9JSContextj(cx, nelements) +} +pub unsafe extern "C" fn JS_NewInt32Array(cx: *mut JSContext, nelements: u32) + -> *mut JSObject { + _Z16JS_NewInt32ArrayP9JSContextj(cx, nelements) +} +pub unsafe extern "C" fn JS_NewUint32Array(cx: *mut JSContext, nelements: u32) + -> *mut JSObject { + _Z17JS_NewUint32ArrayP9JSContextj(cx, nelements) +} +pub unsafe extern "C" fn JS_NewFloat32Array(cx: *mut JSContext, + nelements: u32) -> *mut JSObject { + _Z18JS_NewFloat32ArrayP9JSContextj(cx, nelements) +} +pub unsafe extern "C" fn JS_NewFloat64Array(cx: *mut JSContext, + nelements: u32) -> *mut JSObject { + _Z18JS_NewFloat64ArrayP9JSContextj(cx, nelements) +} +pub unsafe extern "C" fn JS_NewSharedInt8Array(cx: *mut JSContext, + nelements: u32) + -> *mut JSObject { + _Z21JS_NewSharedInt8ArrayP9JSContextj(cx, nelements) +} +pub unsafe extern "C" fn JS_NewSharedUint8Array(cx: *mut JSContext, + nelements: u32) + -> *mut JSObject { + _Z22JS_NewSharedUint8ArrayP9JSContextj(cx, nelements) +} +pub unsafe extern "C" fn JS_NewSharedUint8ClampedArray(cx: *mut JSContext, + nelements: u32) + -> *mut JSObject { + _Z29JS_NewSharedUint8ClampedArrayP9JSContextj(cx, nelements) +} +pub unsafe extern "C" fn JS_NewSharedInt16Array(cx: *mut JSContext, + nelements: u32) + -> *mut JSObject { + _Z22JS_NewSharedInt16ArrayP9JSContextj(cx, nelements) +} +pub unsafe extern "C" fn JS_NewSharedUint16Array(cx: *mut JSContext, + nelements: u32) + -> *mut JSObject { + _Z23JS_NewSharedUint16ArrayP9JSContextj(cx, nelements) +} +pub unsafe extern "C" fn JS_NewSharedInt32Array(cx: *mut JSContext, + nelements: u32) + -> *mut JSObject { + _Z22JS_NewSharedInt32ArrayP9JSContextj(cx, nelements) +} +pub unsafe extern "C" fn JS_NewSharedUint32Array(cx: *mut JSContext, + nelements: u32) + -> *mut JSObject { + _Z23JS_NewSharedUint32ArrayP9JSContextj(cx, nelements) +} +pub unsafe extern "C" fn JS_NewSharedFloat32Array(cx: *mut JSContext, + nelements: u32) + -> *mut JSObject { + _Z24JS_NewSharedFloat32ArrayP9JSContextj(cx, nelements) +} +pub unsafe extern "C" fn JS_NewSharedFloat64Array(cx: *mut JSContext, + nelements: u32) + -> *mut JSObject { + _Z24JS_NewSharedFloat64ArrayP9JSContextj(cx, nelements) +} +pub unsafe extern "C" fn JS_NewInt8ArrayFromArray(cx: *mut JSContext, + array: HandleObject) + -> *mut JSObject { + _Z24JS_NewInt8ArrayFromArrayP9JSContextN2JS6HandleIP8JSObjectEE(cx, array) +} +pub unsafe extern "C" fn JS_NewUint8ArrayFromArray(cx: *mut JSContext, + array: HandleObject) + -> *mut JSObject { + _Z25JS_NewUint8ArrayFromArrayP9JSContextN2JS6HandleIP8JSObjectEE(cx, + array) +} +pub unsafe extern "C" fn JS_NewUint8ClampedArrayFromArray(cx: *mut JSContext, + array: HandleObject) + -> *mut JSObject { + _Z32JS_NewUint8ClampedArrayFromArrayP9JSContextN2JS6HandleIP8JSObjectEE(cx, + array) +} +pub unsafe extern "C" fn JS_NewInt16ArrayFromArray(cx: *mut JSContext, + array: HandleObject) + -> *mut JSObject { + _Z25JS_NewInt16ArrayFromArrayP9JSContextN2JS6HandleIP8JSObjectEE(cx, + array) +} +pub unsafe extern "C" fn JS_NewUint16ArrayFromArray(cx: *mut JSContext, + array: HandleObject) + -> *mut JSObject { + _Z26JS_NewUint16ArrayFromArrayP9JSContextN2JS6HandleIP8JSObjectEE(cx, + array) +} +pub unsafe extern "C" fn JS_NewInt32ArrayFromArray(cx: *mut JSContext, + array: HandleObject) + -> *mut JSObject { + _Z25JS_NewInt32ArrayFromArrayP9JSContextN2JS6HandleIP8JSObjectEE(cx, + array) +} +pub unsafe extern "C" fn JS_NewUint32ArrayFromArray(cx: *mut JSContext, + array: HandleObject) + -> *mut JSObject { + _Z26JS_NewUint32ArrayFromArrayP9JSContextN2JS6HandleIP8JSObjectEE(cx, + array) +} +pub unsafe extern "C" fn JS_NewFloat32ArrayFromArray(cx: *mut JSContext, + array: HandleObject) + -> *mut JSObject { + _Z27JS_NewFloat32ArrayFromArrayP9JSContextN2JS6HandleIP8JSObjectEE(cx, + array) +} +pub unsafe extern "C" fn JS_NewFloat64ArrayFromArray(cx: *mut JSContext, + array: HandleObject) + -> *mut JSObject { + _Z27JS_NewFloat64ArrayFromArrayP9JSContextN2JS6HandleIP8JSObjectEE(cx, + array) +} +pub unsafe extern "C" fn JS_NewInt8ArrayWithBuffer(cx: *mut JSContext, + arrayBuffer: HandleObject, + byteOffset: u32, + length: i32) + -> *mut JSObject { + _Z25JS_NewInt8ArrayWithBufferP9JSContextN2JS6HandleIP8JSObjectEEji(cx, + arrayBuffer, + byteOffset, + length) +} +pub unsafe extern "C" fn JS_NewUint8ArrayWithBuffer(cx: *mut JSContext, + arrayBuffer: HandleObject, + byteOffset: u32, + length: i32) + -> *mut JSObject { + _Z26JS_NewUint8ArrayWithBufferP9JSContextN2JS6HandleIP8JSObjectEEji(cx, + arrayBuffer, + byteOffset, + length) +} +pub unsafe extern "C" fn JS_NewUint8ClampedArrayWithBuffer(cx: *mut JSContext, + arrayBuffer: + HandleObject, + byteOffset: u32, + length: i32) + -> *mut JSObject { + _Z33JS_NewUint8ClampedArrayWithBufferP9JSContextN2JS6HandleIP8JSObjectEEji(cx, + arrayBuffer, + byteOffset, + length) +} +pub unsafe extern "C" fn JS_NewInt16ArrayWithBuffer(cx: *mut JSContext, + arrayBuffer: HandleObject, + byteOffset: u32, + length: i32) + -> *mut JSObject { + _Z26JS_NewInt16ArrayWithBufferP9JSContextN2JS6HandleIP8JSObjectEEji(cx, + arrayBuffer, + byteOffset, + length) +} +pub unsafe extern "C" fn JS_NewUint16ArrayWithBuffer(cx: *mut JSContext, + arrayBuffer: + HandleObject, + byteOffset: u32, + length: i32) + -> *mut JSObject { + _Z27JS_NewUint16ArrayWithBufferP9JSContextN2JS6HandleIP8JSObjectEEji(cx, + arrayBuffer, + byteOffset, + length) +} +pub unsafe extern "C" fn JS_NewInt32ArrayWithBuffer(cx: *mut JSContext, + arrayBuffer: HandleObject, + byteOffset: u32, + length: i32) + -> *mut JSObject { + _Z26JS_NewInt32ArrayWithBufferP9JSContextN2JS6HandleIP8JSObjectEEji(cx, + arrayBuffer, + byteOffset, + length) +} +pub unsafe extern "C" fn JS_NewUint32ArrayWithBuffer(cx: *mut JSContext, + arrayBuffer: + HandleObject, + byteOffset: u32, + length: i32) + -> *mut JSObject { + _Z27JS_NewUint32ArrayWithBufferP9JSContextN2JS6HandleIP8JSObjectEEji(cx, + arrayBuffer, + byteOffset, + length) +} +pub unsafe extern "C" fn JS_NewFloat32ArrayWithBuffer(cx: *mut JSContext, + arrayBuffer: + HandleObject, + byteOffset: u32, + length: i32) + -> *mut JSObject { + _Z28JS_NewFloat32ArrayWithBufferP9JSContextN2JS6HandleIP8JSObjectEEji(cx, + arrayBuffer, + byteOffset, + length) +} +pub unsafe extern "C" fn JS_NewFloat64ArrayWithBuffer(cx: *mut JSContext, + arrayBuffer: + HandleObject, + byteOffset: u32, + length: i32) + -> *mut JSObject { + _Z28JS_NewFloat64ArrayWithBufferP9JSContextN2JS6HandleIP8JSObjectEEji(cx, + arrayBuffer, + byteOffset, + length) +} +pub unsafe extern "C" fn JS_NewSharedInt8ArrayWithBuffer(cx: *mut JSContext, + arrayBuffer: + HandleObject, + byteOffset: u32, + length: u32) + -> *mut JSObject { + _Z31JS_NewSharedInt8ArrayWithBufferP9JSContextN2JS6HandleIP8JSObjectEEjj(cx, + arrayBuffer, + byteOffset, + length) +} +pub unsafe extern "C" fn JS_NewSharedUint8ArrayWithBuffer(cx: *mut JSContext, + arrayBuffer: + HandleObject, + byteOffset: u32, + length: u32) + -> *mut JSObject { + _Z32JS_NewSharedUint8ArrayWithBufferP9JSContextN2JS6HandleIP8JSObjectEEjj(cx, + arrayBuffer, + byteOffset, + length) +} +pub unsafe extern "C" fn JS_NewSharedUint8ClampedArrayWithBuffer(cx: + *mut JSContext, + arrayBuffer: + HandleObject, + byteOffset: + u32, + length: u32) + -> *mut JSObject { + _Z39JS_NewSharedUint8ClampedArrayWithBufferP9JSContextN2JS6HandleIP8JSObjectEEjj(cx, + arrayBuffer, + byteOffset, + length) +} +pub unsafe extern "C" fn JS_NewSharedInt16ArrayWithBuffer(cx: *mut JSContext, + arrayBuffer: + HandleObject, + byteOffset: u32, + length: u32) + -> *mut JSObject { + _Z32JS_NewSharedInt16ArrayWithBufferP9JSContextN2JS6HandleIP8JSObjectEEjj(cx, + arrayBuffer, + byteOffset, + length) +} +pub unsafe extern "C" fn JS_NewSharedUint16ArrayWithBuffer(cx: *mut JSContext, + arrayBuffer: + HandleObject, + byteOffset: u32, + length: u32) + -> *mut JSObject { + _Z33JS_NewSharedUint16ArrayWithBufferP9JSContextN2JS6HandleIP8JSObjectEEjj(cx, + arrayBuffer, + byteOffset, + length) +} +pub unsafe extern "C" fn JS_NewSharedInt32ArrayWithBuffer(cx: *mut JSContext, + arrayBuffer: + HandleObject, + byteOffset: u32, + length: u32) + -> *mut JSObject { + _Z32JS_NewSharedInt32ArrayWithBufferP9JSContextN2JS6HandleIP8JSObjectEEjj(cx, + arrayBuffer, + byteOffset, + length) +} +pub unsafe extern "C" fn JS_NewSharedUint32ArrayWithBuffer(cx: *mut JSContext, + arrayBuffer: + HandleObject, + byteOffset: u32, + length: u32) + -> *mut JSObject { + _Z33JS_NewSharedUint32ArrayWithBufferP9JSContextN2JS6HandleIP8JSObjectEEjj(cx, + arrayBuffer, + byteOffset, + length) +} +pub unsafe extern "C" fn JS_NewSharedFloat32ArrayWithBuffer(cx: + *mut JSContext, + arrayBuffer: + HandleObject, + byteOffset: u32, + length: u32) + -> *mut JSObject { + _Z34JS_NewSharedFloat32ArrayWithBufferP9JSContextN2JS6HandleIP8JSObjectEEjj(cx, + arrayBuffer, + byteOffset, + length) +} +pub unsafe extern "C" fn JS_NewSharedFloat64ArrayWithBuffer(cx: + *mut JSContext, + arrayBuffer: + HandleObject, + byteOffset: u32, + length: u32) + -> *mut JSObject { + _Z34JS_NewSharedFloat64ArrayWithBufferP9JSContextN2JS6HandleIP8JSObjectEEjj(cx, + arrayBuffer, + byteOffset, + length) +} +pub unsafe extern "C" fn JS_NewArrayBuffer(cx: *mut JSContext, nbytes: u32) + -> *mut JSObject { + _Z17JS_NewArrayBufferP9JSContextj(cx, nbytes) +} +pub unsafe extern "C" fn JS_IsTypedArrayObject(obj: *mut JSObject) -> u8 { + _Z21JS_IsTypedArrayObjectP8JSObject(obj) +} +pub unsafe extern "C" fn JS_IsSharedTypedArrayObject(obj: *mut JSObject) + -> u8 { + _Z27JS_IsSharedTypedArrayObjectP8JSObject(obj) +} +pub unsafe extern "C" fn JS_IsInt8Array(obj: *mut JSObject) -> u8 { + _Z14JS_IsInt8ArrayP8JSObject(obj) +} +pub unsafe extern "C" fn JS_IsUint8Array(obj: *mut JSObject) -> u8 { + _Z15JS_IsUint8ArrayP8JSObject(obj) +} +pub unsafe extern "C" fn JS_IsUint8ClampedArray(obj: *mut JSObject) -> u8 { + _Z22JS_IsUint8ClampedArrayP8JSObject(obj) +} +pub unsafe extern "C" fn JS_IsInt16Array(obj: *mut JSObject) -> u8 { + _Z15JS_IsInt16ArrayP8JSObject(obj) +} +pub unsafe extern "C" fn JS_IsUint16Array(obj: *mut JSObject) -> u8 { + _Z16JS_IsUint16ArrayP8JSObject(obj) +} +pub unsafe extern "C" fn JS_IsInt32Array(obj: *mut JSObject) -> u8 { + _Z15JS_IsInt32ArrayP8JSObject(obj) +} +pub unsafe extern "C" fn JS_IsUint32Array(obj: *mut JSObject) -> u8 { + _Z16JS_IsUint32ArrayP8JSObject(obj) +} +pub unsafe extern "C" fn JS_IsFloat32Array(obj: *mut JSObject) -> u8 { + _Z17JS_IsFloat32ArrayP8JSObject(obj) +} +pub unsafe extern "C" fn JS_IsFloat64Array(obj: *mut JSObject) -> u8 { + _Z17JS_IsFloat64ArrayP8JSObject(obj) +} +pub unsafe extern "C" fn JS_IsSharedInt8Array(obj: *mut JSObject) -> u8 { + _Z20JS_IsSharedInt8ArrayP8JSObject(obj) +} +pub unsafe extern "C" fn JS_IsSharedUint8Array(obj: *mut JSObject) -> u8 { + _Z21JS_IsSharedUint8ArrayP8JSObject(obj) +} +pub unsafe extern "C" fn JS_IsSharedUint8ClampedArray(obj: *mut JSObject) + -> u8 { + _Z28JS_IsSharedUint8ClampedArrayP8JSObject(obj) +} +pub unsafe extern "C" fn JS_IsSharedInt16Array(obj: *mut JSObject) -> u8 { + _Z21JS_IsSharedInt16ArrayP8JSObject(obj) +} +pub unsafe extern "C" fn JS_IsSharedUint16Array(obj: *mut JSObject) -> u8 { + _Z22JS_IsSharedUint16ArrayP8JSObject(obj) +} +pub unsafe extern "C" fn JS_IsSharedInt32Array(obj: *mut JSObject) -> u8 { + _Z21JS_IsSharedInt32ArrayP8JSObject(obj) +} +pub unsafe extern "C" fn JS_IsSharedUint32Array(obj: *mut JSObject) -> u8 { + _Z22JS_IsSharedUint32ArrayP8JSObject(obj) +} +pub unsafe extern "C" fn JS_IsSharedFloat32Array(obj: *mut JSObject) -> u8 { + _Z23JS_IsSharedFloat32ArrayP8JSObject(obj) +} +pub unsafe extern "C" fn JS_IsSharedFloat64Array(obj: *mut JSObject) -> u8 { + _Z23JS_IsSharedFloat64ArrayP8JSObject(obj) +} +pub unsafe extern "C" fn UnwrapInt8Array(obj: *mut JSObject) + -> *mut JSObject { + _ZN2js15UnwrapInt8ArrayEP8JSObject(obj) +} +pub unsafe extern "C" fn UnwrapUint8Array(obj: *mut JSObject) + -> *mut JSObject { + _ZN2js16UnwrapUint8ArrayEP8JSObject(obj) +} +pub unsafe extern "C" fn UnwrapUint8ClampedArray(obj: *mut JSObject) + -> *mut JSObject { + _ZN2js23UnwrapUint8ClampedArrayEP8JSObject(obj) +} +pub unsafe extern "C" fn UnwrapInt16Array(obj: *mut JSObject) + -> *mut JSObject { + _ZN2js16UnwrapInt16ArrayEP8JSObject(obj) +} +pub unsafe extern "C" fn UnwrapUint16Array(obj: *mut JSObject) + -> *mut JSObject { + _ZN2js17UnwrapUint16ArrayEP8JSObject(obj) +} +pub unsafe extern "C" fn UnwrapInt32Array(obj: *mut JSObject) + -> *mut JSObject { + _ZN2js16UnwrapInt32ArrayEP8JSObject(obj) +} +pub unsafe extern "C" fn UnwrapUint32Array(obj: *mut JSObject) + -> *mut JSObject { + _ZN2js17UnwrapUint32ArrayEP8JSObject(obj) +} +pub unsafe extern "C" fn UnwrapFloat32Array(obj: *mut JSObject) + -> *mut JSObject { + _ZN2js18UnwrapFloat32ArrayEP8JSObject(obj) +} +pub unsafe extern "C" fn UnwrapFloat64Array(obj: *mut JSObject) + -> *mut JSObject { + _ZN2js18UnwrapFloat64ArrayEP8JSObject(obj) +} +pub unsafe extern "C" fn UnwrapArrayBuffer(obj: *mut JSObject) + -> *mut JSObject { + _ZN2js17UnwrapArrayBufferEP8JSObject(obj) +} +pub unsafe extern "C" fn UnwrapArrayBufferView(obj: *mut JSObject) + -> *mut JSObject { + _ZN2js21UnwrapArrayBufferViewEP8JSObject(obj) +} +pub unsafe extern "C" fn UnwrapSharedInt8Array(obj: *mut JSObject) + -> *mut JSObject { + _ZN2js21UnwrapSharedInt8ArrayEP8JSObject(obj) +} +pub unsafe extern "C" fn UnwrapSharedUint8Array(obj: *mut JSObject) + -> *mut JSObject { + _ZN2js22UnwrapSharedUint8ArrayEP8JSObject(obj) +} +pub unsafe extern "C" fn UnwrapSharedUint8ClampedArray(obj: *mut JSObject) + -> *mut JSObject { + _ZN2js29UnwrapSharedUint8ClampedArrayEP8JSObject(obj) +} +pub unsafe extern "C" fn UnwrapSharedInt16Array(obj: *mut JSObject) + -> *mut JSObject { + _ZN2js22UnwrapSharedInt16ArrayEP8JSObject(obj) +} +pub unsafe extern "C" fn UnwrapSharedUint16Array(obj: *mut JSObject) + -> *mut JSObject { + _ZN2js23UnwrapSharedUint16ArrayEP8JSObject(obj) +} +pub unsafe extern "C" fn UnwrapSharedInt32Array(obj: *mut JSObject) + -> *mut JSObject { + _ZN2js22UnwrapSharedInt32ArrayEP8JSObject(obj) +} +pub unsafe extern "C" fn UnwrapSharedUint32Array(obj: *mut JSObject) + -> *mut JSObject { + _ZN2js23UnwrapSharedUint32ArrayEP8JSObject(obj) +} +pub unsafe extern "C" fn UnwrapSharedFloat32Array(obj: *mut JSObject) + -> *mut JSObject { + _ZN2js24UnwrapSharedFloat32ArrayEP8JSObject(obj) +} +pub unsafe extern "C" fn UnwrapSharedFloat64Array(obj: *mut JSObject) + -> *mut JSObject { + _ZN2js24UnwrapSharedFloat64ArrayEP8JSObject(obj) +} +pub unsafe extern "C" fn GetInt8ArrayLengthAndData(obj: *mut JSObject, + length: *mut u32, + data: *mut *mut i8) { + _ZN2js25GetInt8ArrayLengthAndDataEP8JSObjectPjPPa(obj, length, data) +} +pub unsafe extern "C" fn GetUint8ArrayLengthAndData(obj: *mut JSObject, + length: *mut u32, + data: *mut *mut u8) { + _ZN2js26GetUint8ArrayLengthAndDataEP8JSObjectPjPPh(obj, length, data) +} +pub unsafe extern "C" fn GetUint8ClampedArrayLengthAndData(obj: *mut JSObject, + length: *mut u32, + data: + *mut *mut u8) { + _ZN2js33GetUint8ClampedArrayLengthAndDataEP8JSObjectPjPPh(obj, length, + data) +} +pub unsafe extern "C" fn GetInt16ArrayLengthAndData(obj: *mut JSObject, + length: *mut u32, + data: *mut *mut i16) { + _ZN2js26GetInt16ArrayLengthAndDataEP8JSObjectPjPPs(obj, length, data) +} +pub unsafe extern "C" fn GetUint16ArrayLengthAndData(obj: *mut JSObject, + length: *mut u32, + data: *mut *mut u16) { + _ZN2js27GetUint16ArrayLengthAndDataEP8JSObjectPjPPt(obj, length, data) +} +pub unsafe extern "C" fn GetInt32ArrayLengthAndData(obj: *mut JSObject, + length: *mut u32, + data: *mut *mut i32) { + _ZN2js26GetInt32ArrayLengthAndDataEP8JSObjectPjPPi(obj, length, data) +} +pub unsafe extern "C" fn GetUint32ArrayLengthAndData(obj: *mut JSObject, + length: *mut u32, + data: *mut *mut u32) { + _ZN2js27GetUint32ArrayLengthAndDataEP8JSObjectPjPS2_(obj, length, data) +} +pub unsafe extern "C" fn GetFloat32ArrayLengthAndData(obj: *mut JSObject, + length: *mut u32, + data: *mut *mut f32) { + _ZN2js28GetFloat32ArrayLengthAndDataEP8JSObjectPjPPf(obj, length, data) +} +pub unsafe extern "C" fn GetFloat64ArrayLengthAndData(obj: *mut JSObject, + length: *mut u32, + data: *mut *mut f64) { + _ZN2js28GetFloat64ArrayLengthAndDataEP8JSObjectPjPPd(obj, length, data) +} +pub unsafe extern "C" fn GetArrayBufferViewLengthAndData(obj: *mut JSObject, + length: *mut u32, + data: *mut *mut u8) { + _ZN2js31GetArrayBufferViewLengthAndDataEP8JSObjectPjPPh(obj, length, data) +} +pub unsafe extern "C" fn GetArrayBufferLengthAndData(obj: *mut JSObject, + length: *mut u32, + data: *mut *mut u8) { + _ZN2js27GetArrayBufferLengthAndDataEP8JSObjectPjPPh(obj, length, data) +} +pub unsafe extern "C" fn JS_GetObjectAsInt8Array(obj: *mut JSObject, + length: *mut u32, + data: *mut *mut i8) + -> *mut JSObject { + _Z23JS_GetObjectAsInt8ArrayP8JSObjectPjPPa(obj, length, data) +} +pub unsafe extern "C" fn JS_GetObjectAsUint8Array(obj: *mut JSObject, + length: *mut u32, + data: *mut *mut u8) + -> *mut JSObject { + _Z24JS_GetObjectAsUint8ArrayP8JSObjectPjPPh(obj, length, data) +} +pub unsafe extern "C" fn JS_GetObjectAsUint8ClampedArray(obj: *mut JSObject, + length: *mut u32, + data: *mut *mut u8) + -> *mut JSObject { + _Z31JS_GetObjectAsUint8ClampedArrayP8JSObjectPjPPh(obj, length, data) +} +pub unsafe extern "C" fn JS_GetObjectAsInt16Array(obj: *mut JSObject, + length: *mut u32, + data: *mut *mut i16) + -> *mut JSObject { + _Z24JS_GetObjectAsInt16ArrayP8JSObjectPjPPs(obj, length, data) +} +pub unsafe extern "C" fn JS_GetObjectAsUint16Array(obj: *mut JSObject, + length: *mut u32, + data: *mut *mut u16) + -> *mut JSObject { + _Z25JS_GetObjectAsUint16ArrayP8JSObjectPjPPt(obj, length, data) +} +pub unsafe extern "C" fn JS_GetObjectAsInt32Array(obj: *mut JSObject, + length: *mut u32, + data: *mut *mut i32) + -> *mut JSObject { + _Z24JS_GetObjectAsInt32ArrayP8JSObjectPjPPi(obj, length, data) +} +pub unsafe extern "C" fn JS_GetObjectAsUint32Array(obj: *mut JSObject, + length: *mut u32, + data: *mut *mut u32) + -> *mut JSObject { + _Z25JS_GetObjectAsUint32ArrayP8JSObjectPjPS1_(obj, length, data) +} +pub unsafe extern "C" fn JS_GetObjectAsFloat32Array(obj: *mut JSObject, + length: *mut u32, + data: *mut *mut f32) + -> *mut JSObject { + _Z26JS_GetObjectAsFloat32ArrayP8JSObjectPjPPf(obj, length, data) +} +pub unsafe extern "C" fn JS_GetObjectAsFloat64Array(obj: *mut JSObject, + length: *mut u32, + data: *mut *mut f64) + -> *mut JSObject { + _Z26JS_GetObjectAsFloat64ArrayP8JSObjectPjPPd(obj, length, data) +} +pub unsafe extern "C" fn JS_GetObjectAsArrayBufferView(obj: *mut JSObject, + length: *mut u32, + data: *mut *mut u8) + -> *mut JSObject { + _Z29JS_GetObjectAsArrayBufferViewP8JSObjectPjPPh(obj, length, data) +} +pub unsafe extern "C" fn JS_GetObjectAsArrayBuffer(obj: *mut JSObject, + length: *mut u32, + data: *mut *mut u8) + -> *mut JSObject { + _Z25JS_GetObjectAsArrayBufferP8JSObjectPjPPh(obj, length, data) +} +pub unsafe extern "C" fn JS_GetArrayBufferViewType(obj: *mut JSObject) + -> Type { + _Z25JS_GetArrayBufferViewTypeP8JSObject(obj) +} +pub unsafe extern "C" fn JS_IsArrayBufferObject(obj: *mut JSObject) -> u8 { + _Z22JS_IsArrayBufferObjectP8JSObject(obj) +} +pub unsafe extern "C" fn JS_IsSharedArrayBufferObject(obj: *mut JSObject) + -> u8 { + _Z28JS_IsSharedArrayBufferObjectP8JSObject(obj) +} +pub unsafe extern "C" fn JS_GetArrayBufferByteLength(obj: *mut JSObject) + -> u32 { + _Z27JS_GetArrayBufferByteLengthP8JSObject(obj) +} +pub unsafe extern "C" fn JS_ArrayBufferHasData(obj: *mut JSObject) -> u8 { + _Z21JS_ArrayBufferHasDataP8JSObject(obj) +} +pub unsafe extern "C" fn JS_IsMappedArrayBufferObject(obj: *mut JSObject) + -> u8 { + _Z28JS_IsMappedArrayBufferObjectP8JSObject(obj) +} +pub unsafe extern "C" fn JS_GetTypedArrayLength(obj: *mut JSObject) -> u32 { + _Z22JS_GetTypedArrayLengthP8JSObject(obj) +} +pub unsafe extern "C" fn JS_GetTypedArrayByteOffset(obj: *mut JSObject) + -> u32 { + _Z26JS_GetTypedArrayByteOffsetP8JSObject(obj) +} +pub unsafe extern "C" fn JS_GetTypedArrayByteLength(obj: *mut JSObject) + -> u32 { + _Z26JS_GetTypedArrayByteLengthP8JSObject(obj) +} +pub unsafe extern "C" fn JS_GetArrayBufferViewByteLength(obj: *mut JSObject) + -> u32 { + _Z31JS_GetArrayBufferViewByteLengthP8JSObject(obj) +} +pub unsafe extern "C" fn JS_GetArrayBufferData(obj: *mut JSObject, + arg1: *const AutoCheckCannotGC) + -> *mut u8 { + _Z21JS_GetArrayBufferDataP8JSObjectRKN2JS17AutoCheckCannotGCE(obj, arg1) +} +pub unsafe extern "C" fn JS_GetInt8ArrayData(obj: *mut JSObject, + arg1: *const AutoCheckCannotGC) + -> *mut i8 { + _Z19JS_GetInt8ArrayDataP8JSObjectRKN2JS17AutoCheckCannotGCE(obj, arg1) +} +pub unsafe extern "C" fn JS_GetUint8ArrayData(obj: *mut JSObject, + arg1: *const AutoCheckCannotGC) + -> *mut u8 { + _Z20JS_GetUint8ArrayDataP8JSObjectRKN2JS17AutoCheckCannotGCE(obj, arg1) +} +pub unsafe extern "C" fn JS_GetUint8ClampedArrayData(obj: *mut JSObject, + arg1: + *const AutoCheckCannotGC) + -> *mut u8 { + _Z27JS_GetUint8ClampedArrayDataP8JSObjectRKN2JS17AutoCheckCannotGCE(obj, + arg1) +} +pub unsafe extern "C" fn JS_GetInt16ArrayData(obj: *mut JSObject, + arg1: *const AutoCheckCannotGC) + -> *mut i16 { + _Z20JS_GetInt16ArrayDataP8JSObjectRKN2JS17AutoCheckCannotGCE(obj, arg1) +} +pub unsafe extern "C" fn JS_GetUint16ArrayData(obj: *mut JSObject, + arg1: *const AutoCheckCannotGC) + -> *mut u16 { + _Z21JS_GetUint16ArrayDataP8JSObjectRKN2JS17AutoCheckCannotGCE(obj, arg1) +} +pub unsafe extern "C" fn JS_GetInt32ArrayData(obj: *mut JSObject, + arg1: *const AutoCheckCannotGC) + -> *mut i32 { + _Z20JS_GetInt32ArrayDataP8JSObjectRKN2JS17AutoCheckCannotGCE(obj, arg1) +} +pub unsafe extern "C" fn JS_GetUint32ArrayData(obj: *mut JSObject, + arg1: *const AutoCheckCannotGC) + -> *mut u32 { + _Z21JS_GetUint32ArrayDataP8JSObjectRKN2JS17AutoCheckCannotGCE(obj, arg1) +} +pub unsafe extern "C" fn JS_GetFloat32ArrayData(obj: *mut JSObject, + arg1: + *const AutoCheckCannotGC) + -> *mut f32 { + _Z22JS_GetFloat32ArrayDataP8JSObjectRKN2JS17AutoCheckCannotGCE(obj, arg1) +} +pub unsafe extern "C" fn JS_GetFloat64ArrayData(obj: *mut JSObject, + arg1: + *const AutoCheckCannotGC) + -> *mut f64 { + _Z22JS_GetFloat64ArrayDataP8JSObjectRKN2JS17AutoCheckCannotGCE(obj, arg1) +} +pub unsafe extern "C" fn JS_GetArrayBufferViewData(obj: *mut JSObject, + arg1: + *const AutoCheckCannotGC) + -> *mut ::libc::c_void { + _Z25JS_GetArrayBufferViewDataP8JSObjectRKN2JS17AutoCheckCannotGCE(obj, + arg1) +} +pub unsafe extern "C" fn JS_GetArrayBufferViewBuffer(cx: *mut JSContext, + obj: HandleObject) + -> *mut JSObject { + _Z27JS_GetArrayBufferViewBufferP9JSContextN2JS6HandleIP8JSObjectEE(cx, + obj) +} +pub unsafe extern "C" fn JS_NeuterArrayBuffer(cx: *mut JSContext, + obj: HandleObject, + changeData: + NeuterDataDisposition) + -> u8 { + _Z20JS_NeuterArrayBufferP9JSContextN2JS6HandleIP8JSObjectEE21NeuterDataDisposition(cx, + obj, + changeData) +} +pub unsafe extern "C" fn JS_IsNeuteredArrayBufferObject(obj: *mut JSObject) + -> u8 { + _Z30JS_IsNeuteredArrayBufferObjectP8JSObject(obj) +} +pub unsafe extern "C" fn JS_IsDataViewObject(obj: *mut JSObject) -> u8 { + _Z19JS_IsDataViewObjectP8JSObject(obj) +} +pub unsafe extern "C" fn JS_GetDataViewByteOffset(obj: *mut JSObject) -> u32 { + _Z24JS_GetDataViewByteOffsetP8JSObject(obj) +} +pub unsafe extern "C" fn JS_GetDataViewByteLength(obj: *mut JSObject) -> u32 { + _Z24JS_GetDataViewByteLengthP8JSObject(obj) +} +pub unsafe extern "C" fn JS_GetDataViewData(obj: *mut JSObject, + arg1: *const AutoCheckCannotGC) + -> *mut ::libc::c_void { + _Z18JS_GetDataViewDataP8JSObjectRKN2JS17AutoCheckCannotGCE(obj, arg1) +} +pub unsafe extern "C" fn WatchGuts(cx: *mut JSContext, obj: HandleObject, + id: HandleId, callable: HandleObject) + -> u8 { + _ZN2js9WatchGutsEP9JSContextN2JS6HandleIP8JSObjectEENS3_I4jsidEES6_(cx, + obj, + id, + callable) +} +pub unsafe extern "C" fn UnwatchGuts(cx: *mut JSContext, obj: HandleObject, + id: HandleId) -> u8 { + _ZN2js11UnwatchGutsEP9JSContextN2JS6HandleIP8JSObjectEENS3_I4jsidEE(cx, + obj, + id) +} +pub unsafe extern "C" fn IdMatchesAtom(id: jsid, atom: *mut JSAtom) -> u8 { + _ZN2js6detail13IdMatchesAtomE4jsidP6JSAtom(id, atom) +} +pub unsafe extern "C" fn DefaultJSContext(rt: *mut JSRuntime) + -> *mut JSContext { + _ZN2js16DefaultJSContextEP9JSRuntime(rt) +} +pub unsafe extern "C" fn SetDefaultJSContextCallback(rt: *mut JSRuntime, + cb: + DefaultJSContextCallback) { + _ZN2js27SetDefaultJSContextCallbackEP9JSRuntimePFP9JSContextS1_E(rt, cb) +} +pub unsafe extern "C" fn Debug_SetActiveJSContext(rt: *mut JSRuntime, + cx: *mut JSContext) { + _ZN2js24Debug_SetActiveJSContextEP9JSRuntimeP9JSContext(rt, cx) +} +pub unsafe extern "C" fn SetCTypesActivityCallback(rt: *mut JSRuntime, + cb: + CTypesActivityCallback) { + _ZN2js25SetCTypesActivityCallbackEP9JSRuntimePFvP9JSContextNS_18CTypesActivityTypeEE(rt, + cb) +} +pub unsafe extern "C" fn SetObjectMetadataCallback(cx: *mut JSContext, + callback: + ObjectMetadataCallback) { + _ZN2js25SetObjectMetadataCallbackEP9JSContextPFbS1_PP8JSObjectE(cx, + callback) +} +pub unsafe extern "C" fn SetObjectMetadata(cx: *mut JSContext, + obj: HandleObject, + metadata: HandleObject) -> u8 { + _ZN2js17SetObjectMetadataEP9JSContextN2JS6HandleIP8JSObjectEES6_(cx, obj, + metadata) +} +pub unsafe extern "C" fn GetObjectMetadata(obj: *mut JSObject) + -> *mut JSObject { + _ZN2js17GetObjectMetadataEP8JSObject(obj) +} +pub unsafe extern "C" fn GetElementsWithAdder(cx: *mut JSContext, + obj: HandleObject, + receiver: HandleObject, + begin: u32, end: u32, + adder: *mut ElementAdder) + -> u8 { + _ZN2js20GetElementsWithAdderEP9JSContextN2JS6HandleIP8JSObjectEES6_jjPNS_12ElementAdderE(cx, + obj, + receiver, + begin, + end, + adder) +} +pub unsafe extern "C" fn ForwardToNative(cx: *mut JSContext, native: JSNative, + args: *const CallArgs) -> u8 { + _ZN2js15ForwardToNativeEP9JSContextPFbS1_jPN2JS5ValueEERKNS2_8CallArgsE(cx, + native, + args) +} +pub unsafe extern "C" fn SetPropertyIgnoringNamedGetter(cx: *mut JSContext, + obj: HandleObject, + id: HandleId, + vp: + MutableHandleValue, + receiver: + HandleObject, + ownDesc: + MutableHandle, + result: + *mut ObjectOpResult) + -> u8 { + _ZN2js30SetPropertyIgnoringNamedGetterEP9JSContextN2JS6HandleIP8JSObjectEENS3_I4jsidEENS2_13MutableHandleINS2_5ValueEEES6_NS9_I20JSPropertyDescriptorEERNS2_14ObjectOpResultE(cx, + obj, + id, + vp, + receiver, + ownDesc, + result) +} +pub unsafe extern "C" fn ReportErrorWithId(cx: *mut JSContext, msg: *const i8, + id: HandleId) { + _ZN2js17ReportErrorWithIdEP9JSContextPKcN2JS6HandleI4jsidEE(cx, msg, id) +} +pub unsafe extern "C" fn ExecuteInGlobalAndReturnScope(cx: *mut JSContext, + obj: HandleObject, + script: HandleScript, + scope: + MutableHandleObject) + -> u8 { + _ZN2js29ExecuteInGlobalAndReturnScopeEP9JSContextN2JS6HandleIP8JSObjectEENS3_IP8JSScriptEENS2_13MutableHandleIS5_EE(cx, + obj, + script, + scope) +} +pub unsafe extern "C" fn GetObjectEnvironmentObjectForFunction(fun: + *mut JSFunction) + -> *mut JSObject { + _ZN2js37GetObjectEnvironmentObjectForFunctionEP10JSFunction(fun) +} +pub unsafe extern "C" fn GetSavedFramePrincipals(savedFrame: HandleObject) + -> *mut JSPrincipals { + _ZN2js23GetSavedFramePrincipalsEN2JS6HandleIP8JSObjectEE(savedFrame) +} +pub unsafe extern "C" fn GetFirstSubsumedSavedFrame(cx: *mut JSContext, + savedFrame: HandleObject) + -> *mut JSObject { + _ZN2js26GetFirstSubsumedSavedFrameEP9JSContextN2JS6HandleIP8JSObjectEE(cx, + savedFrame) +} +pub unsafe extern "C" fn ReportIsNotFunction(cx: *mut JSContext, + v: HandleValue) -> u8 { + _ZN2js19ReportIsNotFunctionEP9JSContextN2JS6HandleINS2_5ValueEEE(cx, v) +} +pub unsafe extern "C" fn DefineOwnProperty(cx: *mut JSContext, + objArg: *mut JSObject, idArg: jsid, + descriptor: + Handle, + result: *mut ObjectOpResult) + -> u8 { + _ZN2js17DefineOwnPropertyEP9JSContextP8JSObject4jsidN2JS6HandleI20JSPropertyDescriptorEERNS5_14ObjectOpResultE(cx, + objArg, + idArg, + descriptor, + result) +} +pub unsafe extern "C" fn JS_StoreObjectPostBarrierCallback(cx: *mut JSContext, + callback: + ::std::option::Option, + key: *mut JSObject, + data: + *mut ::libc::c_void) { + _Z33JS_StoreObjectPostBarrierCallbackP9JSContextPFvP8JSTracerP8JSObjectPvES4_S5_(cx, + callback, + key, + data) +} +pub unsafe extern "C" fn JS_StoreStringPostBarrierCallback(cx: *mut JSContext, + callback: + ::std::option::Option, + key: *mut JSString, + data: + *mut ::libc::c_void) { + _Z33JS_StoreStringPostBarrierCallbackP9JSContextPFvP8JSTracerP8JSStringPvES4_S5_(cx, + callback, + key, + data) +} +/* automatically generated by rust-bindgen */ -pub fn JS_DecodeScript(cx: *mut JSContext, data: *const c_void, length: uint32_t, principals: *mut JSPrincipals, originPrincipals: *mut JSPrincipals) -> *mut JSScript; +extern "C" { + fn _ZN2js13ToBooleanSlowEN2JS6HandleINS0_5ValueEEE(v: HandleValue) -> u8; + fn _ZN2js12ToNumberSlowEP9JSContextN2JS5ValueEPd(cx: *mut JSContext, + v: Value, dp: *mut f64) + -> u8; + fn _ZN2js11ToInt32SlowEP9JSContextN2JS6HandleINS2_5ValueEEEPi(cx: + *mut JSContext, + v: + HandleValue, + out: + *mut i32) + -> u8; + fn _ZN2js12ToUint32SlowEP9JSContextN2JS6HandleINS2_5ValueEEEPj(cx: + *mut JSContext, + v: + HandleValue, + out: + *mut u32) + -> u8; + fn _ZN2js12ToUint16SlowEP9JSContextN2JS6HandleINS2_5ValueEEEPt(cx: + *mut JSContext, + v: + HandleValue, + out: + *mut u16) + -> u8; + #[cfg(target_pointer_width = "64")] + fn _ZN2js11ToInt64SlowEP9JSContextN2JS6HandleINS2_5ValueEEEPl(cx: + *mut JSContext, + v: + HandleValue, + out: + *mut i64) + -> u8; + #[cfg(target_pointer_width = "32")] + fn _ZN2js11ToInt64SlowEP9JSContextN2JS6HandleINS2_5ValueEEEPx(cx: + *mut JSContext, + v: + HandleValue, + out: + *mut i64) + -> u8; + #[cfg(target_pointer_width = "64")] + fn _ZN2js12ToUint64SlowEP9JSContextN2JS6HandleINS2_5ValueEEEPm(cx: + *mut JSContext, + v: + HandleValue, + out: + *mut u64) + -> u8; + #[cfg(target_pointer_width = "32")] + fn _ZN2js12ToUint64SlowEP9JSContextN2JS6HandleINS2_5ValueEEEPy(cx: + *mut JSContext, + v: + HandleValue, + out: + *mut u64) + -> u8; + fn _ZN2js12ToStringSlowEP9JSContextN2JS6HandleINS2_5ValueEEE(cx: + *mut JSContext, + v: + HandleValue) + -> *mut JSString; + fn _ZN2js12ToObjectSlowEP9JSContextN2JS6HandleINS2_5ValueEEEb(cx: + *mut JSContext, + v: + HandleValue, + reportScanStack: + u8) + -> *mut JSObject; + fn _ZN2JS6detail22AssertArgumentsAreSaneEP9JSContextNS_6HandleINS_5ValueEEE(cx: + *mut JSContext, + v: + HandleValue); + fn _ZN2JS19OrdinaryToPrimitiveEP9JSContextNS_6HandleIP8JSObjectEE6JSTypeNS_13MutableHandleINS_5ValueEEE(cx: + *mut JSContext, + obj: + HandleObject, + _type: + JSType, + vp: + MutableHandleValue) + -> u8; + fn _ZN2JS9ToBooleanENS_6HandleINS_5ValueEEE(v: HandleValue) -> u8; + fn _ZN2JS8ToNumberEP9JSContextNS_6HandleINS_5ValueEEEPd(cx: + *mut JSContext, + v: HandleValue, + out: *mut f64) + -> u8; + fn _ZN2JS9ToIntegerEd(d: f64) -> f64; + fn _ZN2JS7ToInt32EP9JSContextNS_6HandleINS_5ValueEEEPi(cx: *mut JSContext, + v: HandleValue, + out: *mut i32) + -> u8; + fn _ZN2JS8ToUint32EP9JSContextNS_6HandleINS_5ValueEEEPj(cx: + *mut JSContext, + v: HandleValue, + out: *mut u32) + -> u8; + fn _ZN2JS8ToUint16EP9JSContextNS_6HandleINS_5ValueEEEPt(cx: + *mut JSContext, + v: HandleValue, + out: *mut u16) + -> u8; + fn _ZN2JS7ToInt64EP9JSContextNS_6HandleINS_5ValueEEEPx(cx: *mut JSContext, + v: HandleValue, + out: *mut i64) + -> u8; + fn _ZN2JS8ToUint64EP9JSContextNS_6HandleINS_5ValueEEEPy(cx: + *mut JSContext, + v: HandleValue, + out: *mut u64) + -> u8; + fn _ZN2JS8ToStringEP9JSContextNS_6HandleINS_5ValueEEE(cx: *mut JSContext, + v: HandleValue) + -> *mut JSString; + fn _ZN2JS8ToObjectEP9JSContextNS_6HandleINS_5ValueEEE(cx: *mut JSContext, + v: HandleValue) + -> *mut JSObject; + fn _ZN2JS7ToInt32Ed(d: f64) -> i32; + fn _ZN2JS8ToUint32Ed(d: f64) -> u32; + fn _ZN2JS7ToInt64Ed(d: f64) -> i64; + fn _ZN2JS8ToUint64Ed(d: f64) -> u64; +} +pub unsafe extern "C" fn ToBooleanSlow(v: HandleValue) -> u8 { + _ZN2js13ToBooleanSlowEN2JS6HandleINS0_5ValueEEE(v) +} +pub unsafe extern "C" fn ToNumberSlow(cx: *mut JSContext, v: Value, + dp: *mut f64) -> u8 { + _ZN2js12ToNumberSlowEP9JSContextN2JS5ValueEPd(cx, v, dp) +} +pub unsafe extern "C" fn ToInt32Slow(cx: *mut JSContext, v: HandleValue, + out: *mut i32) -> u8 { + _ZN2js11ToInt32SlowEP9JSContextN2JS6HandleINS2_5ValueEEEPi(cx, v, out) +} +pub unsafe extern "C" fn ToUint32Slow(cx: *mut JSContext, v: HandleValue, + out: *mut u32) -> u8 { + _ZN2js12ToUint32SlowEP9JSContextN2JS6HandleINS2_5ValueEEEPj(cx, v, out) +} +pub unsafe extern "C" fn ToUint16Slow(cx: *mut JSContext, v: HandleValue, + out: *mut u16) -> u8 { + _ZN2js12ToUint16SlowEP9JSContextN2JS6HandleINS2_5ValueEEEPt(cx, v, out) +} +#[cfg(target_pointer_width = "64")] +pub unsafe extern "C" fn ToInt64Slow(cx: *mut JSContext, v: HandleValue, + out: *mut i64) -> u8 { + _ZN2js11ToInt64SlowEP9JSContextN2JS6HandleINS2_5ValueEEEPl(cx, v, out) +} +#[cfg(target_pointer_width = "32")] +pub unsafe extern "C" fn ToInt64Slow(cx: *mut JSContext, v: HandleValue, + out: *mut i64) -> u8 { + _ZN2js11ToInt64SlowEP9JSContextN2JS6HandleINS2_5ValueEEEPx(cx, v, out) +} +#[cfg(target_pointer_width = "64")] +pub unsafe extern "C" fn ToUint64Slow(cx: *mut JSContext, v: HandleValue, + out: *mut u64) -> u8 { + _ZN2js12ToUint64SlowEP9JSContextN2JS6HandleINS2_5ValueEEEPm(cx, v, out) +} +#[cfg(target_pointer_width = "32")] +pub unsafe extern "C" fn ToUint64Slow(cx: *mut JSContext, v: HandleValue, + out: *mut u64) -> u8 { + _ZN2js12ToUint64SlowEP9JSContextN2JS6HandleINS2_5ValueEEEPy(cx, v, out) +} +pub unsafe extern "C" fn ToStringSlow(cx: *mut JSContext, v: HandleValue) + -> *mut JSString { + _ZN2js12ToStringSlowEP9JSContextN2JS6HandleINS2_5ValueEEE(cx, v) +} +pub unsafe extern "C" fn ToObjectSlow(cx: *mut JSContext, v: HandleValue, + reportScanStack: u8) -> *mut JSObject { + _ZN2js12ToObjectSlowEP9JSContextN2JS6HandleINS2_5ValueEEEb(cx, v, + reportScanStack) +} +pub unsafe extern "C" fn AssertArgumentsAreSane(cx: *mut JSContext, + v: HandleValue) { + _ZN2JS6detail22AssertArgumentsAreSaneEP9JSContextNS_6HandleINS_5ValueEEE(cx, + v) +} +pub unsafe extern "C" fn OrdinaryToPrimitive(cx: *mut JSContext, + obj: HandleObject, _type: JSType, + vp: MutableHandleValue) -> u8 { + _ZN2JS19OrdinaryToPrimitiveEP9JSContextNS_6HandleIP8JSObjectEE6JSTypeNS_13MutableHandleINS_5ValueEEE(cx, + obj, + _type, + vp) +} +pub unsafe extern "C" fn ToBoolean(v: HandleValue) -> u8 { + _ZN2JS9ToBooleanENS_6HandleINS_5ValueEEE(v) +} +pub unsafe extern "C" fn ToNumber(cx: *mut JSContext, v: HandleValue, + out: *mut f64) -> u8 { + _ZN2JS8ToNumberEP9JSContextNS_6HandleINS_5ValueEEEPd(cx, v, out) +} +pub unsafe extern "C" fn ToInteger(d: f64) -> f64 { _ZN2JS9ToIntegerEd(d) } +pub unsafe extern "C" fn ToInt32(cx: *mut JSContext, v: HandleValue, + out: *mut i32) -> u8 { + _ZN2JS7ToInt32EP9JSContextNS_6HandleINS_5ValueEEEPi(cx, v, out) +} +pub unsafe extern "C" fn ToUint32(cx: *mut JSContext, v: HandleValue, + out: *mut u32) -> u8 { + _ZN2JS8ToUint32EP9JSContextNS_6HandleINS_5ValueEEEPj(cx, v, out) +} +pub unsafe extern "C" fn ToUint16(cx: *mut JSContext, v: HandleValue, + out: *mut u16) -> u8 { + _ZN2JS8ToUint16EP9JSContextNS_6HandleINS_5ValueEEEPt(cx, v, out) +} +pub unsafe extern "C" fn ToInt64(cx: *mut JSContext, v: HandleValue, + out: *mut i64) -> u8 { + _ZN2JS7ToInt64EP9JSContextNS_6HandleINS_5ValueEEEPx(cx, v, out) +} +pub unsafe extern "C" fn ToUint64(cx: *mut JSContext, v: HandleValue, + out: *mut u64) -> u8 { + _ZN2JS8ToUint64EP9JSContextNS_6HandleINS_5ValueEEEPy(cx, v, out) +} +pub unsafe extern "C" fn ToString(cx: *mut JSContext, v: HandleValue) + -> *mut JSString { + _ZN2JS8ToStringEP9JSContextNS_6HandleINS_5ValueEEE(cx, v) +} +pub unsafe extern "C" fn ToObject(cx: *mut JSContext, v: HandleValue) + -> *mut JSObject { + _ZN2JS8ToObjectEP9JSContextNS_6HandleINS_5ValueEEE(cx, v) +} +pub unsafe extern "C" fn ToInt321(d: f64) -> i32 { _ZN2JS7ToInt32Ed(d) } +pub unsafe extern "C" fn ToUint321(d: f64) -> u32 { _ZN2JS8ToUint32Ed(d) } +pub unsafe extern "C" fn ToInt641(d: f64) -> i64 { _ZN2JS7ToInt64Ed(d) } +pub unsafe extern "C" fn ToUint641(d: f64) -> u64 { _ZN2JS8ToUint64Ed(d) } +/* automatically generated by rust-bindgen */ -pub fn JS_DecodeInterpretedFunction(cx: *mut JSContext, data: *const c_void, length: uint32_t, principals: *mut JSPrincipals, originPrincipals: *mut JSPrincipals) -> *mut JSObject; +#[repr(i32)] +#[derive(Copy, Clone)] +pub enum TransferableOwnership { + SCTAG_TMO_UNFILLED = 0, + SCTAG_TMO_UNOWNED = 1, + SCTAG_TMO_ALLOC_DATA = 2, + SCTAG_TMO_SHARED_BUFFER = 3, + SCTAG_TMO_MAPPED_DATA = 4, + SCTAG_TMO_CUSTOM = 5, + SCTAG_TMO_USER_MIN = 6, +} +pub type ReadStructuredCloneOp = + ::std::option::Option *mut JSObject>; +pub type WriteStructuredCloneOp = + ::std::option::Option u8>; +pub type StructuredCloneErrorOp = + ::std::option::Option; +pub type ReadTransferStructuredCloneOp = + ::std::option::Option u8>; +pub type TransferStructuredCloneOp = + ::std::option::Option, + closure: *mut ::libc::c_void, tag: *mut u32, + ownership: *mut TransferableOwnership, + content: *mut *mut ::libc::c_void, + extraData: *mut u64) -> u8>; +pub type FreeTransferStructuredCloneOp = + ::std::option::Option; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct JSStructuredCloneCallbacks { + pub read: ReadStructuredCloneOp, + pub write: WriteStructuredCloneOp, + pub reportError: StructuredCloneErrorOp, + pub readTransfer: ReadTransferStructuredCloneOp, + pub writeTransfer: TransferStructuredCloneOp, + pub freeTransfer: FreeTransferStructuredCloneOp, +} +impl ::std::default::Default for JSStructuredCloneCallbacks { + fn default() -> JSStructuredCloneCallbacks { + unsafe { ::std::mem::zeroed() } + } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct JSAutoStructuredCloneBuffer { + pub data_: *mut u64, + pub nbytes_: u32, + pub version_: u32, + pub callbacks_: *const JSStructuredCloneCallbacks, + pub closure_: *mut ::libc::c_void, +} +impl ::std::default::Default for JSAutoStructuredCloneBuffer { + fn default() -> JSAutoStructuredCloneBuffer { + unsafe { ::std::mem::zeroed() } + } +} +extern "C" { + #[cfg(target_pointer_width = "64")] + fn _Z22JS_ReadStructuredCloneP9JSContextPmmjN2JS13MutableHandleINS2_5ValueEEEPK26JSStructuredCloneCallbacksPv(cx: + *mut JSContext, + data: + *mut u64, + nbytes: + ::libc::size_t, + version: + u32, + vp: + MutableHandleValue, + optionalCallbacks: + *const JSStructuredCloneCallbacks, + closure: + *mut ::libc::c_void) + -> u8; + #[cfg(target_pointer_width = "32")] + fn _Z22JS_ReadStructuredCloneP9JSContextPyjjN2JS13MutableHandleINS2_5ValueEEEPK26JSStructuredCloneCallbacksPv(cx: + *mut JSContext, + data: + *mut u64, + nbytes: + ::libc::size_t, + version: + u32, + vp: + MutableHandleValue, + optionalCallbacks: + *const JSStructuredCloneCallbacks, + closure: + *mut ::libc::c_void) + -> u8; + #[cfg(target_pointer_width = "64")] + fn _Z23JS_WriteStructuredCloneP9JSContextN2JS6HandleINS1_5ValueEEEPPmS5_PK26JSStructuredCloneCallbacksPvS4_(cx: + *mut JSContext, + v: + HandleValue, + datap: + *mut *mut u64, + nbytesp: + *mut ::libc::size_t, + optionalCallbacks: + *const JSStructuredCloneCallbacks, + closure: + *mut ::libc::c_void, + transferable: + HandleValue) + -> u8; + #[cfg(target_pointer_width = "32")] + fn _Z23JS_WriteStructuredCloneP9JSContextN2JS6HandleINS1_5ValueEEEPPyPjPK26JSStructuredCloneCallbacksPvS4_(cx: + *mut JSContext, + v: + HandleValue, + datap: + *mut *mut u64, + nbytesp: + *mut ::libc::size_t, + optionalCallbacks: + *const JSStructuredCloneCallbacks, + closure: + *mut ::libc::c_void, + transferable: + HandleValue) + -> u8; + fn _Z23JS_ClearStructuredClonePyjPK26JSStructuredCloneCallbacksPv(data: + *mut u64, + nbytes: + u32, + optionalCallbacks: + *const JSStructuredCloneCallbacks, + closure: + *mut ::libc::c_void) + -> u8; + fn _Z34JS_StructuredCloneHasTransferablesPKyjPb(data: *const u64, + nbytes: u32, + hasTransferable: *mut u8) + -> u8; + fn _Z18JS_StructuredCloneP9JSContextN2JS6HandleINS1_5ValueEEENS1_13MutableHandleIS3_EEPK26JSStructuredCloneCallbacksPv(cx: + *mut JSContext, + v: + HandleValue, + vp: + MutableHandleValue, + optionalCallbacks: + *const JSStructuredCloneCallbacks, + closure: + *mut ::libc::c_void) + -> u8; + fn _Z30JS_SetStructuredCloneCallbacksP9JSRuntimePK26JSStructuredCloneCallbacks(rt: + *mut JSRuntime, + callbacks: + *const JSStructuredCloneCallbacks); + fn _Z17JS_ReadUint32PairP23JSStructuredCloneReaderPjS1_(r: + *mut JSStructuredCloneReader, + p1: *mut u32, + p2: *mut u32) + -> u8; + fn _Z12JS_ReadBytesP23JSStructuredCloneReaderPvj(r: + *mut JSStructuredCloneReader, + p: *mut ::libc::c_void, + len: u32) -> u8; + fn _Z17JS_ReadTypedArrayP23JSStructuredCloneReaderN2JS13MutableHandleINS1_5ValueEEE(r: + *mut JSStructuredCloneReader, + vp: + MutableHandleValue) + -> u8; + fn _Z18JS_WriteUint32PairP23JSStructuredCloneWriterjj(w: + *mut JSStructuredCloneWriter, + tag: u32, data: u32) + -> u8; + fn _Z13JS_WriteBytesP23JSStructuredCloneWriterPKvj(w: + *mut JSStructuredCloneWriter, + p: + *const ::libc::c_void, + len: u32) -> u8; + fn _Z14JS_WriteStringP23JSStructuredCloneWriterN2JS6HandleIP8JSStringEE(w: + *mut JSStructuredCloneWriter, + str: + HandleString) + -> u8; + fn _Z18JS_WriteTypedArrayP23JSStructuredCloneWriterN2JS6HandleINS1_5ValueEEE(w: + *mut JSStructuredCloneWriter, + v: + HandleValue) + -> u8; +} +#[cfg(target_pointer_width = "64")] +pub unsafe extern "C" fn JS_ReadStructuredClone(cx: *mut JSContext, + data: *mut u64, nbytes: ::libc::size_t, + version: u32, + vp: MutableHandleValue, + optionalCallbacks: + *const JSStructuredCloneCallbacks, + closure: *mut ::libc::c_void) + -> u8 { + _Z22JS_ReadStructuredCloneP9JSContextPmmjN2JS13MutableHandleINS2_5ValueEEEPK26JSStructuredCloneCallbacksPv(cx, + data, + nbytes, + version, + vp, + optionalCallbacks, + closure) +} +#[cfg(target_pointer_width = "32")] +pub unsafe extern "C" fn JS_ReadStructuredClone(cx: *mut JSContext, + data: *mut u64, nbytes: ::libc::size_t, + version: u32, + vp: MutableHandleValue, + optionalCallbacks: + *const JSStructuredCloneCallbacks, + closure: *mut ::libc::c_void) + -> u8 { + _Z22JS_ReadStructuredCloneP9JSContextPyjjN2JS13MutableHandleINS2_5ValueEEEPK26JSStructuredCloneCallbacksPv(cx, + data, + nbytes, + version, + vp, + optionalCallbacks, + closure) +} +#[cfg(target_pointer_width = "64")] +pub unsafe extern "C" fn JS_WriteStructuredClone(cx: *mut JSContext, + v: HandleValue, + datap: *mut *mut u64, + nbytesp: *mut ::libc::size_t, + optionalCallbacks: + *const JSStructuredCloneCallbacks, + closure: *mut ::libc::c_void, + transferable: HandleValue) + -> u8 { + _Z23JS_WriteStructuredCloneP9JSContextN2JS6HandleINS1_5ValueEEEPPmS5_PK26JSStructuredCloneCallbacksPvS4_(cx, + v, + datap, + nbytesp, + optionalCallbacks, + closure, + transferable) +} +#[cfg(target_pointer_width = "32")] +pub unsafe extern "C" fn JS_WriteStructuredClone(cx: *mut JSContext, + v: HandleValue, + datap: *mut *mut u64, + nbytesp: *mut ::libc::size_t, + optionalCallbacks: + *const JSStructuredCloneCallbacks, + closure: *mut ::libc::c_void, + transferable: HandleValue) + -> u8 { + _Z23JS_WriteStructuredCloneP9JSContextN2JS6HandleINS1_5ValueEEEPPyPjPK26JSStructuredCloneCallbacksPvS4_(cx, + v, + datap, + nbytesp, + optionalCallbacks, + closure, + transferable) +} +pub unsafe extern "C" fn JS_ClearStructuredClone(data: *mut u64, nbytes: u32, + optionalCallbacks: + *const JSStructuredCloneCallbacks, + closure: *mut ::libc::c_void) + -> u8 { + _Z23JS_ClearStructuredClonePyjPK26JSStructuredCloneCallbacksPv(data, + nbytes, + optionalCallbacks, + closure) +} +pub unsafe extern "C" fn JS_StructuredCloneHasTransferables(data: *const u64, + nbytes: u32, + hasTransferable: + *mut u8) + -> u8 { + _Z34JS_StructuredCloneHasTransferablesPKyjPb(data, nbytes, + hasTransferable) +} +pub unsafe extern "C" fn JS_StructuredClone(cx: *mut JSContext, + v: HandleValue, + vp: MutableHandleValue, + optionalCallbacks: + *const JSStructuredCloneCallbacks, + closure: *mut ::libc::c_void) + -> u8 { + _Z18JS_StructuredCloneP9JSContextN2JS6HandleINS1_5ValueEEENS1_13MutableHandleIS3_EEPK26JSStructuredCloneCallbacksPv(cx, + v, + vp, + optionalCallbacks, + closure) +} +pub unsafe extern "C" fn JS_SetStructuredCloneCallbacks(rt: *mut JSRuntime, + callbacks: + *const JSStructuredCloneCallbacks) { + _Z30JS_SetStructuredCloneCallbacksP9JSRuntimePK26JSStructuredCloneCallbacks(rt, + callbacks) +} +pub unsafe extern "C" fn JS_ReadUint32Pair(r: *mut JSStructuredCloneReader, + p1: *mut u32, p2: *mut u32) -> u8 { + _Z17JS_ReadUint32PairP23JSStructuredCloneReaderPjS1_(r, p1, p2) +} +pub unsafe extern "C" fn JS_ReadBytes(r: *mut JSStructuredCloneReader, + p: *mut ::libc::c_void, len: u32) + -> u8 { + _Z12JS_ReadBytesP23JSStructuredCloneReaderPvj(r, p, len) +} +pub unsafe extern "C" fn JS_ReadTypedArray(r: *mut JSStructuredCloneReader, + vp: MutableHandleValue) -> u8 { + _Z17JS_ReadTypedArrayP23JSStructuredCloneReaderN2JS13MutableHandleINS1_5ValueEEE(r, + vp) +} +pub unsafe extern "C" fn JS_WriteUint32Pair(w: *mut JSStructuredCloneWriter, + tag: u32, data: u32) -> u8 { + _Z18JS_WriteUint32PairP23JSStructuredCloneWriterjj(w, tag, data) +} +pub unsafe extern "C" fn JS_WriteBytes(w: *mut JSStructuredCloneWriter, + p: *const ::libc::c_void, len: u32) + -> u8 { + _Z13JS_WriteBytesP23JSStructuredCloneWriterPKvj(w, p, len) +} +pub unsafe extern "C" fn JS_WriteString(w: *mut JSStructuredCloneWriter, + str: HandleString) -> u8 { + _Z14JS_WriteStringP23JSStructuredCloneWriterN2JS6HandleIP8JSStringEE(w, + str) +} +pub unsafe extern "C" fn JS_WriteTypedArray(w: *mut JSStructuredCloneWriter, + v: HandleValue) -> u8 { + _Z18JS_WriteTypedArrayP23JSStructuredCloneWriterN2JS6HandleINS1_5ValueEEE(w, + v) } diff --git a/src/jsfriendapi.rs b/src/jsfriendapi.rs deleted file mode 100644 index b7fe1c4e9..000000000 --- a/src/jsfriendapi.rs +++ /dev/null @@ -1,68 +0,0 @@ -/* This Source Code Form is subject to the terms of the Mozilla Public - * License, v. 2.0. If a copy of the MPL was not distributed with this file, - * You can obtain one at http://mozilla.org/MPL/2.0/. */ - -use jsapi::{JSContext, JSObject, JSPropertyDescriptor, JSBool}; - -pub type JSJitPropertyOp = *const u8; - -pub struct JSJitInfo { - pub op: JSJitPropertyOp, - pub protoID: u32, - pub depth: u32, - pub isInfallible: bool, - pub isConstant: bool -} - -extern { -pub fn JS_ObjectToOuterObject(cx: *mut JSContext, - obj: *mut JSObject) -> *mut JSObject; -pub fn JS_WrapPropertyDescriptor(cx: *mut JSContext, - desc: *mut JSPropertyDescriptor) -> JSBool; -} - -//pub type JSJitInfo = JSJitInfo_struct; - -pub mod bindgen { - use jsapi::{JSContext, JSObject, JSClass, JSRuntime}; - use libc::{uintptr_t, int8_t, uint8_t, int16_t, uint16_t, int32_t, uint32_t, c_float, c_double}; - - extern { - pub fn JS_NewObjectWithUniqueType(cx: *mut JSContext, clasp: *const JSClass, - proto: *const JSObject, parent: *const JSObject) -> *mut JSObject; - pub fn JS_GetAddressableObject(rt: *mut JSRuntime, candidateObj: uintptr_t) -> *mut JSObject; - - pub fn JS_NewInt8Array(cx: *mut JSContext, nelements: uint32_t) -> *mut JSObject; - pub fn JS_GetInt8ArrayData(obj: *mut JSObject, cx: *mut JSContext) -> *mut int8_t; - - pub fn JS_NewUint8Array(cx: *mut JSContext, nelements: uint32_t) -> *mut JSObject; - pub fn JS_GetUint8ArrayData(obj: *mut JSObject, cx: *mut JSContext) -> *mut uint8_t; - - pub fn JS_NewUint8ClampedArray(cx: *mut JSContext, nelements: uint32_t) -> *mut JSObject; - pub fn JS_GetUint8ClampedArrayData(obj: *mut JSObject, cx: *mut JSContext) -> *mut uint8_t; - - pub fn JS_NewInt16Array(cx: *mut JSContext, nelements: uint32_t) -> *mut JSObject; - pub fn JS_GetInt16ArrayData(obj: *mut JSObject, cx: *mut JSContext) -> *mut int16_t; - - pub fn JS_NewUint16Array(cx: *mut JSContext, nelements: uint32_t) -> *mut JSObject; - pub fn JS_GetUint16ArrayData(obj: *mut JSObject, cx: *mut JSContext) -> *mut uint16_t; - - pub fn JS_NewInt32Array(cx: *mut JSContext, nelements: uint32_t) -> *mut JSObject; - pub fn JS_GetInt32ArrayData(obj: *mut JSObject, cx: *mut JSContext) -> *mut int32_t; - - pub fn JS_NewUint32Array(cx: *mut JSContext, nelements: uint32_t) -> *mut JSObject; - pub fn JS_GetUint32ArrayData(obj: *mut JSObject, cx: *mut JSContext) -> *mut uint32_t; - - pub fn JS_NewFloat32Array(cx: *mut JSContext, nelements: uint32_t) -> *mut JSObject; - pub fn JS_GetFloat32ArrayData(obj: *mut JSObject, cx: *mut JSContext) -> *mut c_float; - - pub fn JS_NewFloat64Array(cx: *mut JSContext, nelements: uint32_t) -> *mut JSObject; - pub fn JS_GetFloat64ArrayData(obj: *mut JSObject, cx: *mut JSContext) -> *mut c_double; - - pub fn JS_GetObjectAsArrayBufferView(cx: *mut JSContext, - obj: *mut JSObject, - length: *mut uint32_t, - data: *mut *mut uint8_t) - -> *mut JSObject; - } -} diff --git a/src/jsglue.cpp b/src/jsglue.cpp index 91ee7cb32..2df5923f0 100644 --- a/src/jsglue.cpp +++ b/src/jsglue.cpp @@ -2,279 +2,343 @@ * License, v. 2.0. If a copy of the MPL was not distributed with this file, * You can obtain one at http://mozilla.org/MPL/2.0/. */ -//XXXjdm whyyyyyyyyyyy -#define UINT32_MAX ((uint32_t)-1) +#define __STDC_LIMIT_MACROS +#include + +#include "js-config.h" + +#ifdef JS_DEBUG +// A hack for MFBT. Guard objects need this to work. +#define DEBUG 1 +#endif #include "jsapi.h" #include "jsfriendapi.h" -#include "jsproxy.h" -#include "jsclass.h" +#include "js/Proxy.h" +#include "js/Class.h" #include "jswrapper.h" #include "assert.h" struct ProxyTraps { - bool (*getPropertyDescriptor)(JSContext *cx, JSObject *proxy, jsid id, - bool set, JSPropertyDescriptor *desc); - bool (*getOwnPropertyDescriptor)(JSContext *cx, JSObject *proxy, - jsid id, bool set, - JSPropertyDescriptor *desc); - bool (*defineProperty)(JSContext *cx, JSObject *proxy, jsid id, - JSPropertyDescriptor *desc); - bool (*getOwnPropertyNames)(JSContext *cx, JSObject *proxy, - JS::AutoIdVector *props); - bool (*delete_)(JSContext *cx, JSObject *proxy, jsid id, bool *bp); - bool (*enumerate)(JSContext *cx, JSObject *proxy, - JS::AutoIdVector *props); - - bool (*has)(JSContext *cx, JSObject *proxy, jsid id, bool *bp); - bool (*hasOwn)(JSContext *cx, JSObject *proxy, jsid id, bool *bp); - bool (*get)(JSContext *cx, JSObject *proxy, JSObject *receiver, - jsid id, JS::Value *vp); - bool (*set)(JSContext *cx, JSObject *proxy, JSObject *receiver, - jsid id, bool strict, JS::Value *vp); - bool (*keys)(JSContext *cx, JSObject *proxy, JS::AutoIdVector *props); - bool (*iterate)(JSContext *cx, JSObject *proxy, unsigned flags, - JS::Value *vp); - - bool (*call)(JSContext *cx, JSObject *proxy, unsigned argc, JS::Value *vp); - bool (*construct)(JSContext *cx, JSObject *proxy, unsigned argc, JS::Value *argv, JS::Value *rval); - bool (*nativeCall)(JSContext *cx, JS::IsAcceptableThis test, JS::NativeImpl impl, JS::CallArgs args); - bool (*hasInstance)(JSContext *cx, JSObject *proxy, const JS::Value *vp, bool *bp); - JSType (*typeOf)(JSContext *cx, JSObject *proxy); - bool (*objectClassIs)(JSObject *obj, js::ESClassValue classValue, JSContext *cx); - JSString *(*obj_toString)(JSContext *cx, JSObject *proxy); - JSString *(*fun_toString)(JSContext *cx, JSObject *proxy, unsigned indent); - //bool (*regexp_toShared)(JSContext *cx, JSObject *proxy, RegExpGuard *g); - bool (*defaultValue)(JSContext *cx, JSObject *obj, JSType hint, JS::Value *vp); - bool (*iteratorNext)(JSContext *cx, JSObject *proxy, JS::Value *vp); - void (*finalize)(JSFreeOp *fop, JSObject *proxy); - bool (*getElementIfPresent)(JSContext *cx, JSObject *obj, JSObject *receiver, - uint32_t index, JS::Value *vp, bool *present); - bool (*getPrototypeOf)(JSContext *cx, JSObject *proxy, JSObject **proto); + bool (*enter)(JSContext *cx, JS::HandleObject proxy, JS::HandleId id, + js::BaseProxyHandler::Action action, bool *bp); + + bool (*getOwnPropertyDescriptor)(JSContext *cx, JS::HandleObject proxy, + JS::HandleId id, + JS::MutableHandle desc); + bool (*defineProperty)(JSContext *cx, JS::HandleObject proxy, + JS::HandleId id, + JS::Handle desc, + JS::ObjectOpResult &result); + bool (*ownPropertyKeys)(JSContext *cx, JS::HandleObject proxy, + JS::AutoIdVector &props); + bool (*delete_)(JSContext *cx, JS::HandleObject proxy, + JS::HandleId id, JS::ObjectOpResult &result); + + bool (*enumerate)(JSContext *cx, JS::HandleObject proxy, + JS::MutableHandleObject objp); + + // getPrototype + // setPrototype + // setImmutablePrototype + + bool (*preventExtensions)(JSContext *cx, JS::HandleObject proxy, + JS::ObjectOpResult &result); + + bool (*isExtensible)(JSContext *cx, JS::HandleObject proxy, bool *succeeded); + + bool (*has)(JSContext *cx, JS::HandleObject proxy, + JS::HandleId id, bool *bp); + bool (*get)(JSContext *cx, JS::HandleObject proxy, JS::HandleObject receiver, + JS::HandleId id, JS::MutableHandleValue vp); + bool (*set)(JSContext *cx, JS::HandleObject proxy, JS::HandleObject receiver, + JS::HandleId id, JS::MutableHandleValue vp, + JS::ObjectOpResult &result); + + bool (*call)(JSContext *cx, JS::HandleObject proxy, + const JS::CallArgs &args); + bool (*construct)(JSContext *cx, JS::HandleObject proxy, + const JS::CallArgs &args); + + bool (*getPropertyDescriptor)(JSContext *cx, JS::HandleObject proxy, + JS::HandleId id, + JS::MutableHandle desc); + bool (*hasOwn)(JSContext *cx, JS::HandleObject proxy, + JS::HandleId id, bool *bp); + bool (*getOwnEnumerablePropertyKeys)(JSContext *cx, JS::HandleObject proxy, + JS::AutoIdVector &props); + bool (*nativeCall)(JSContext *cx, JS::IsAcceptableThis test, + JS::NativeImpl impl, JS::CallArgs args); + bool (*hasInstance)(JSContext *cx, JS::HandleObject proxy, + JS::MutableHandleValue v, bool *bp); + bool (*objectClassIs)(JS::HandleObject obj, js::ESClassValue classValue, + JSContext *cx); + const char *(*className)(JSContext *cx, JS::HandleObject proxy); + JSString *(*fun_toString)(JSContext *cx, JS::HandleObject proxy, + unsigned indent); + //bool (*regexp_toShared)(JSContext *cx, JS::HandleObject proxy, RegExpGuard *g); + bool (*boxedValue_unbox)(JSContext *cx, JS::HandleObject proxy, + JS::MutableHandleValue vp); + bool (*defaultValue)(JSContext *cx, JS::HandleObject obj, JSType hint, JS::MutableHandleValue vp); void (*trace)(JSTracer *trc, JSObject *proxy); + void (*finalize)(JSFreeOp *fop, JSObject *proxy); + void (*objectMoved)(JSObject *proxy, const JSObject *old); + + bool (*isCallable)(JSObject *obj); + bool (*isConstructor)(JSObject *obj); + + // watch + // unwatch + // getElements + + // weakmapKeyDelegate + // isScripted }; -int HandlerFamily = js::JSSLOT_PROXY_EXTRA + 0 /*JSPROXYSLOT_EXPANDO*/; +static int HandlerFamily; #define DEFER_TO_TRAP_OR_BASE_CLASS(_base) \ - /* ES5 Harmony derived proxy traps. */ \ - virtual bool has(JSContext* cx, JSObject* proxy, jsid id, bool* bp) \ + \ + virtual bool enter(JSContext *cx, JS::HandleObject proxy, JS::HandleId id, \ + _base::Action action, bool *bp) const override \ { \ - return mTraps.has \ - ? mTraps.has(cx, proxy, id, bp) \ - : _base::has(cx, proxy, id, bp); \ + return mTraps.enter \ + ? mTraps.enter(cx, proxy, id, action, bp) \ + : _base::enter(cx, proxy, id, action, bp); \ } \ \ - virtual bool hasOwn(JSContext* cx, JSObject* proxy, jsid id, bool* bp) \ + /* Standard internal methods. */ \ + virtual bool enumerate(JSContext *cx, JS::HandleObject proxy, \ + JS::MutableHandleObject objp) const override \ { \ - return mTraps.hasOwn \ - ? mTraps.hasOwn(cx, proxy, id, bp) \ - : _base::hasOwn(cx, proxy, id, bp); \ + return mTraps.enumerate \ + ? mTraps.enumerate(cx, proxy, objp) \ + : _base::enumerate(cx, proxy, objp); \ + } \ + \ + virtual bool has(JSContext* cx, JS::HandleObject proxy, \ + JS::HandleId id, bool *bp) const override \ + { \ + return mTraps.has \ + ? mTraps.has(cx, proxy, id, bp) \ + : _base::has(cx, proxy, id, bp); \ } \ \ - virtual bool get(JSContext* cx, JSObject* proxy, JSObject* receiver, \ - jsid id, JS::Value* vp) \ + virtual bool get(JSContext* cx, JS::HandleObject proxy, \ + JS::HandleObject receiver, \ + JS::HandleId id, JS::MutableHandleValue vp) const override \ { \ return mTraps.get \ ? mTraps.get(cx, proxy, receiver, id, vp) \ : _base::get(cx, proxy, receiver, id, vp); \ } \ \ - virtual bool set(JSContext* cx, JSObject* proxy, JSObject* receiver, \ - jsid id, bool strict, JS::Value* vp) \ + virtual bool set(JSContext* cx, JS::HandleObject proxy, \ + JS::HandleObject receiver, \ + JS::HandleId id, JS::MutableHandleValue vp, \ + JS::ObjectOpResult &result) const override \ { \ return mTraps.set \ - ? mTraps.set(cx, proxy, receiver, id, strict, vp) \ - : _base::set(cx, proxy, receiver, id, strict, vp); \ + ? mTraps.set(cx, proxy, receiver, id, vp, result) \ + : _base::set(cx, proxy, receiver, id, vp, result); \ } \ \ - virtual bool keys(JSContext* cx, JSObject* proxy, JS::AutoIdVector& props) \ + virtual bool call(JSContext* cx, JS::HandleObject proxy, \ + const JS::CallArgs &args) const override \ { \ - return mTraps.keys \ - ? mTraps.keys(cx, proxy, &props) \ - : _base::keys(cx, proxy, props); \ + return mTraps.call \ + ? mTraps.call(cx, proxy, args) \ + : _base::call(cx, proxy, args); \ } \ \ - virtual bool iterate(JSContext* cx, JSObject* proxy, unsigned flags, \ - JS::Value* vp) \ + virtual bool construct(JSContext* cx, JS::HandleObject proxy, \ + const JS::CallArgs &args) const override \ { \ - return mTraps.iterate \ - ? mTraps.iterate(cx, proxy, flags, vp) \ - : _base::iterate(cx, proxy, flags, vp); \ + return mTraps.construct \ + ? mTraps.construct(cx, proxy, args) \ + : _base::construct(cx, proxy, args); \ } \ \ /* Spidermonkey extensions. */ \ - virtual bool call(JSContext* cx, JSObject* proxy, unsigned argc, \ - JS::Value* vp) \ + virtual bool hasOwn(JSContext* cx, JS::HandleObject proxy, JS::HandleId id, \ + bool* bp) const override \ { \ - return mTraps.call \ - ? mTraps.call(cx, proxy, argc, vp) \ - : _base::call(cx, proxy, argc, vp); \ + return mTraps.hasOwn \ + ? mTraps.hasOwn(cx, proxy, id, bp) \ + : _base::hasOwn(cx, proxy, id, bp); \ } \ \ - virtual bool construct(JSContext* cx, JSObject* proxy, unsigned argc, \ - JS::Value* argv, JS::Value* rval) \ + virtual bool getOwnEnumerablePropertyKeys(JSContext* cx, \ + JS::HandleObject proxy, \ + JS::AutoIdVector &props) const override \ { \ - return mTraps.construct \ - ? mTraps.construct(cx, proxy, argc, argv, rval) \ - : _base::construct(cx, proxy, argc, argv, rval); \ + return mTraps.getOwnEnumerablePropertyKeys \ + ? mTraps.getOwnEnumerablePropertyKeys(cx, proxy, props) \ + : _base::getOwnEnumerablePropertyKeys(cx, proxy, props); \ } \ \ virtual bool nativeCall(JSContext* cx, JS::IsAcceptableThis test, \ - JS::NativeImpl impl, JS::CallArgs args) \ + JS::NativeImpl impl, \ + JS::CallArgs args) const override \ { \ return mTraps.nativeCall \ ? mTraps.nativeCall(cx, test, impl, args) \ : _base::nativeCall(cx, test, impl, args); \ } \ \ - virtual bool hasInstance(JSContext* cx, JSObject* proxy, \ - const JS::Value* vp, bool* bp) \ + virtual bool hasInstance(JSContext* cx, JS::HandleObject proxy, \ + JS::MutableHandleValue v, bool* bp) const override \ { \ return mTraps.hasInstance \ - ? mTraps.hasInstance(cx, proxy, vp, bp) \ - : _base::hasInstance(cx, proxy, vp, bp); \ - } \ - \ - virtual JSType typeOf(JSContext* cx, JSObject* proxy) \ - { \ - return mTraps.typeOf \ - ? mTraps.typeOf(cx, proxy) \ - : _base::typeOf(cx, proxy); \ + ? mTraps.hasInstance(cx, proxy, v, bp) \ + : _base::hasInstance(cx, proxy, v, bp); \ } \ \ - virtual bool objectClassIs(JSObject* obj, js::ESClassValue classValue, \ - JSContext* cx) \ + virtual bool objectClassIs(JS::HandleObject obj, \ + js::ESClassValue classValue, \ + JSContext* cx) const override \ { \ return mTraps.objectClassIs \ ? mTraps.objectClassIs(obj, classValue, cx) \ : _base::objectClassIs(obj, classValue, cx); \ } \ \ - virtual JSString* obj_toString(JSContext* cx, JSObject* proxy) \ + virtual const char *className(JSContext *cx, JS::HandleObject proxy) const override\ { \ - return mTraps.obj_toString \ - ? mTraps.obj_toString(cx, proxy) \ - : _base::obj_toString(cx, proxy); \ + return mTraps.className \ + ? mTraps.className(cx, proxy) \ + : _base::className(cx, proxy); \ } \ \ - virtual JSString* fun_toString(JSContext* cx, JSObject* proxy, \ - unsigned indent) \ + virtual JSString* fun_toString(JSContext* cx, JS::HandleObject proxy, \ + unsigned indent) const override \ { \ return mTraps.fun_toString \ ? mTraps.fun_toString(cx, proxy, indent) \ : _base::fun_toString(cx, proxy, indent); \ } \ \ - virtual bool defaultValue(JSContext* cx, JSObject* obj, JSType hint, \ - JS::Value* vp) \ + virtual bool boxedValue_unbox(JSContext* cx, JS::HandleObject proxy, \ + JS::MutableHandleValue vp) const override \ + { \ + return mTraps.boxedValue_unbox \ + ? mTraps.boxedValue_unbox(cx, proxy, vp) \ + : _base::boxedValue_unbox(cx, proxy, vp); \ + } \ + \ + virtual bool defaultValue(JSContext* cx, JS::HandleObject obj, JSType hint, \ + JS::MutableHandleValue vp) const override \ { \ return mTraps.defaultValue \ ? mTraps.defaultValue(cx, obj, hint, vp) \ : _base::defaultValue(cx, obj, hint, vp); \ } \ \ - virtual bool iteratorNext(JSContext* cx, JSObject* proxy, JS::Value* vp) \ + virtual void trace(JSTracer* trc, JSObject* proxy) const override \ { \ - return mTraps.iteratorNext \ - ? mTraps.iteratorNext(cx, proxy, vp) \ - : _base::iteratorNext(cx, proxy, vp); \ + mTraps.trace \ + ? mTraps.trace(trc, proxy) \ + : _base::trace(trc, proxy); \ } \ \ - virtual void finalize(JSFreeOp* fop, JSObject* proxy) \ + virtual void finalize(JSFreeOp* fop, JSObject* proxy) const override \ { \ - return mTraps.finalize \ - ? mTraps.finalize(fop, proxy) \ - : _base::finalize(fop, proxy); \ + mTraps.finalize \ + ? mTraps.finalize(fop, proxy) \ + : _base::finalize(fop, proxy); \ } \ \ - virtual bool getElementIfPresent(JSContext* cx, JSObject* obj, \ - JSObject* receiver, uint32_t index, \ - JS::Value* vp, bool* present) \ + virtual void objectMoved(JSObject* proxy, \ + const JSObject *old) const override \ { \ - return mTraps.getElementIfPresent \ - ? mTraps.getElementIfPresent(cx, obj, receiver, index, vp, \ - present) \ - : _base::getElementIfPresent(cx, obj, receiver, index, vp, \ - present); \ + mTraps.objectMoved \ + ? mTraps.objectMoved(proxy, old) \ + : _base::objectMoved(proxy, old); \ } \ \ - virtual bool getPrototypeOf(JSContext* cx, JSObject* proxy, \ - JSObject** proto) \ + virtual bool isCallable(JSObject* obj) const override \ { \ - return mTraps.getPrototypeOf \ - ? mTraps.getPrototypeOf(cx, proxy, proto) \ - : _base::getPrototypeOf(cx, proxy, proto); \ + return mTraps.isCallable \ + ? mTraps.isCallable(obj) \ + : _base::isCallable(obj); \ } \ \ - virtual void trace(JSTracer* trc, JSObject* proxy) \ + virtual bool isConstructor(JSObject* obj) const override \ { \ - return mTraps.trace \ - ? mTraps.trace(trc, proxy) \ - : _base::trace(trc, proxy); \ + return mTraps.isConstructor \ + ? mTraps.isConstructor(obj) \ + : _base::isConstructor(obj); \ } -class WrapperProxyHandler : public js::DirectWrapper +class WrapperProxyHandler : public js::Wrapper { ProxyTraps mTraps; public: WrapperProxyHandler(const ProxyTraps& aTraps) - : js::DirectWrapper(0), mTraps(aTraps) {} + : js::Wrapper(0), mTraps(aTraps) {} - virtual bool isOuterWindow() { - return true; - } + DEFER_TO_TRAP_OR_BASE_CLASS(js::Wrapper) - virtual bool getPropertyDescriptor(JSContext *cx, JSObject *proxy, jsid id, - bool set, JSPropertyDescriptor *desc) + virtual bool getOwnPropertyDescriptor(JSContext *cx, JS::HandleObject proxy, + JS::HandleId id, + JS::MutableHandle desc) const override { - return mTraps.getPropertyDescriptor ? - mTraps.getPropertyDescriptor(cx, proxy, id, set, desc) : - DirectWrapper::getPropertyDescriptor(cx, proxy, id, set, desc); + return mTraps.getOwnPropertyDescriptor + ? mTraps.getOwnPropertyDescriptor(cx, proxy, id, desc) + : js::Wrapper::getOwnPropertyDescriptor(cx, proxy, id, desc); } - virtual bool getOwnPropertyDescriptor(JSContext *cx, JSObject *proxy, - jsid id, bool set, - JSPropertyDescriptor *desc) + virtual bool defineProperty(JSContext *cx, + JS::HandleObject proxy, JS::HandleId id, + JS::MutableHandle desc, + JS::ObjectOpResult &result) const override { - return mTraps.getOwnPropertyDescriptor ? - mTraps.getOwnPropertyDescriptor(cx, proxy, id, set, desc) : - DirectWrapper::getOwnPropertyDescriptor(cx, proxy, id, set, desc); + return mTraps.defineProperty + ? mTraps.defineProperty(cx, proxy, id, desc, result) + : js::Wrapper::defineProperty(cx, proxy, id, desc, result); } - virtual bool defineProperty(JSContext *cx, JSObject *proxy, jsid id, - JSPropertyDescriptor *desc) + virtual bool ownPropertyKeys(JSContext *cx, JS::HandleObject proxy, + JS::AutoIdVector &props) const override { - return mTraps.defineProperty ? - mTraps.defineProperty(cx, proxy, id, desc) : - DirectWrapper::defineProperty(cx, proxy, id, desc); + return mTraps.ownPropertyKeys + ? mTraps.ownPropertyKeys(cx, proxy, props) + : js::Wrapper::ownPropertyKeys(cx, proxy, props); } - virtual bool getOwnPropertyNames(JSContext *cx, JSObject *proxy, - JS::AutoIdVector &props) + virtual bool delete_(JSContext *cx, JS::HandleObject proxy, JS::HandleId id, + JS::ObjectOpResult &result) const override { - return mTraps.getOwnPropertyNames ? - mTraps.getOwnPropertyNames(cx, proxy, &props) : - DirectWrapper::getOwnPropertyNames(cx, proxy, props); + return mTraps.delete_ + ? mTraps.delete_(cx, proxy, id, result) + : js::Wrapper::delete_(cx, proxy, id, result); } - virtual bool delete_(JSContext *cx, JSObject *proxy, jsid id, bool *bp) + virtual bool preventExtensions(JSContext *cx, JS::HandleObject proxy, + JS::ObjectOpResult &result) const override { - return mTraps.delete_ ? - mTraps.delete_(cx, proxy, id, bp) : - DirectWrapper::delete_(cx, proxy, id, bp); + return mTraps.preventExtensions + ? mTraps.preventExtensions(cx, proxy, result) + : js::Wrapper::preventExtensions(cx, proxy, result); } - virtual bool enumerate(JSContext *cx, JSObject *proxy, - JS::AutoIdVector &props) + virtual bool isExtensible(JSContext *cx, JS::HandleObject proxy, + bool *succeeded) const override { - return mTraps.enumerate ? - mTraps.enumerate(cx, proxy, &props) : - DirectWrapper::enumerate(cx, proxy, props); + return mTraps.isExtensible + ? mTraps.isExtensible(cx, proxy, succeeded) + : js::Wrapper::isExtensible(cx, proxy, succeeded); } - DEFER_TO_TRAP_OR_BASE_CLASS(DirectWrapper) + virtual bool getPropertyDescriptor(JSContext *cx, JS::HandleObject proxy, + JS::HandleId id, + JS::MutableHandle desc) const override + { + return mTraps.getPropertyDescriptor + ? mTraps.getPropertyDescriptor(cx, proxy, id, desc) + : js::Wrapper::getPropertyDescriptor(cx, proxy, id, desc); + } }; class ForwardingProxyHandler : public js::BaseProxyHandler @@ -285,61 +349,69 @@ class ForwardingProxyHandler : public js::BaseProxyHandler ForwardingProxyHandler(const ProxyTraps& aTraps, const void* aExtra) : js::BaseProxyHandler(&HandlerFamily), mTraps(aTraps), mExtra(aExtra) {} - const void* getExtra() { + const void* getExtra() const { return mExtra; } - virtual bool getPropertyDescriptor(JSContext *cx, JSObject *proxy, jsid id, - bool set, JSPropertyDescriptor *desc) + DEFER_TO_TRAP_OR_BASE_CLASS(BaseProxyHandler) + + virtual bool getOwnPropertyDescriptor(JSContext *cx, JS::HandleObject proxy, + JS::HandleId id, + JS::MutableHandle desc) const override { - return mTraps.getPropertyDescriptor(cx, proxy, id, set, desc); + return mTraps.getOwnPropertyDescriptor(cx, proxy, id, desc); } - virtual bool getOwnPropertyDescriptor(JSContext *cx, JSObject *proxy, - jsid id, bool set, - JSPropertyDescriptor *desc) + virtual bool defineProperty(JSContext *cx, + JS::HandleObject proxy, JS::HandleId id, + JS::MutableHandle desc, + JS::ObjectOpResult &result) const override { - return mTraps.getOwnPropertyDescriptor(cx, proxy, id, set, desc); + return mTraps.defineProperty(cx, proxy, id, desc, result); } - virtual bool defineProperty(JSContext *cx, JSObject *proxy, jsid id, - JSPropertyDescriptor *desc) + virtual bool ownPropertyKeys(JSContext *cx, JS::HandleObject proxy, + JS::AutoIdVector &props) const override { - return mTraps.defineProperty(cx, proxy, id, desc); + return mTraps.ownPropertyKeys(cx, proxy, props); } - virtual bool getOwnPropertyNames(JSContext *cx, JSObject *proxy, - JS::AutoIdVector &props) + virtual bool delete_(JSContext *cx, JS::HandleObject proxy, JS::HandleId id, + JS::ObjectOpResult &result) const override { - return mTraps.getOwnPropertyNames(cx, proxy, &props); + return mTraps.delete_(cx, proxy, id, result); } - virtual bool delete_(JSContext *cx, JSObject *proxy, jsid id, bool *bp) + virtual bool preventExtensions(JSContext *cx, JS::HandleObject proxy, + JS::ObjectOpResult &result) const override { - return mTraps.delete_(cx, proxy, id, bp); + return mTraps.preventExtensions(cx, proxy, result); } - virtual bool enumerate(JSContext *cx, JSObject *proxy, - JS::AutoIdVector &props) + virtual bool isExtensible(JSContext *cx, JS::HandleObject proxy, + bool *succeeded) const override { - return mTraps.enumerate(cx, proxy, &props); + return mTraps.isExtensible(cx, proxy, succeeded); } - DEFER_TO_TRAP_OR_BASE_CLASS(BaseProxyHandler) + virtual bool getPropertyDescriptor(JSContext *cx, JS::HandleObject proxy, + JS::HandleId id, + JS::MutableHandle desc) const override + { + return mTraps.getPropertyDescriptor(cx, proxy, id, desc); + } }; extern "C" { bool InvokeGetOwnPropertyDescriptor( - void* handler, - JSContext *cx, JSObject *proxy, - jsid id, bool set, - JSPropertyDescriptor *desc) + const void *handler, + JSContext *cx, JS::HandleObject proxy, JS::HandleId id, + JS::MutableHandle desc) { - return static_cast(handler)->getOwnPropertyDescriptor(cx, proxy, - id, set, - desc); + return static_cast(handler)-> + getOwnPropertyDescriptor(cx, proxy, id, desc); } jsval @@ -354,38 +426,35 @@ RUST_FUNCTION_VALUE_TO_JITINFO(jsval v) return FUNCTION_VALUE_TO_JITINFO(v); } -JSBool -CallJitPropertyOp(const JSJitInfo *info, JSContext* cx, JSObject* thisObj, void *specializedThis, jsval *vp) -{ - struct { - JSObject** obj; - } tmp = { &thisObj }; - return ((JSJitPropertyOp)info->op)(cx, *reinterpret_cast(&tmp), specializedThis, vp); -} - -JSBool -CallJitMethodOp(JSJitInfo *info, JSContext* cx, JSObject* thisObj, void *specializedThis, uint32_t argc, jsval *vp) +bool +CallJitGetterOp(const JSJitInfo* info, JSContext* cx, + JS::HandleObject thisObj, void* specializedThis, + unsigned argc, JS::Value* vp) { - struct { - JSObject** obj; - } tmp = { &thisObj }; - return ((JSJitMethodOp)info->op)(cx, *reinterpret_cast(&tmp), specializedThis, argc, vp); + JS::CallArgs args = JS::CallArgsFromVp(argc, vp); + return info->getter(cx, thisObj, specializedThis, JSJitGetterCallArgs(args)); } -void -SetFunctionNativeReserved(JSObject* fun, size_t which, js::Value* val) +bool +CallJitSetterOp(const JSJitInfo* info, JSContext* cx, + JS::HandleObject thisObj, void* specializedThis, + unsigned argc, JS::Value* vp) { - js::SetFunctionNativeReserved(fun, which, *val); + JS::CallArgs args = JS::CallArgsFromVp(argc, vp); + return info->setter(cx, thisObj, specializedThis, JSJitSetterCallArgs(args)); } -const js::Value* -GetFunctionNativeReserved(JSObject* fun, size_t which) +bool +CallJitMethodOp(const JSJitInfo* info, JSContext* cx, + JS::HandleObject thisObj, void* specializedThis, + uint32_t argc, JS::Value* vp) { - return &js::GetFunctionNativeReserved(fun, which); + JS::CallArgs args = JS::CallArgsFromVp(argc, vp); + return info->method(cx, thisObj, specializedThis, JSJitMethodCallArgs(args)); } const void* -CreateProxyHandler(const ProxyTraps* aTraps, void* aExtra) +CreateProxyHandler(const ProxyTraps* aTraps, const void* aExtra) { return new ForwardingProxyHandler(*aTraps, aExtra); } @@ -396,20 +465,35 @@ CreateWrapperProxyHandler(const ProxyTraps* aTraps) return new WrapperProxyHandler(*aTraps); } +JS::ReadOnlyCompileOptions* +NewCompileOptions(JSContext* aCx, const char* aFile, unsigned aLine) +{ + JS::OwningCompileOptions *opts = new JS::OwningCompileOptions(aCx); + opts->setFileAndLine(aCx, aFile, aLine); + opts->setVersion(JSVERSION_DEFAULT); + return opts; +} + +void +DeleteCompileOptions(JS::ReadOnlyCompileOptions *aOpts) +{ + delete static_cast(aOpts); +} + JSObject* -NewProxyObject(JSContext* aCx, void* aHandler, const js::Value* aPriv, +NewProxyObject(JSContext* aCx, const void* aHandler, JS::HandleValue aPriv, JSObject* proto, JSObject* parent, JSObject* call, JSObject* construct) { - const js::Value &priv = aPriv ? *aPriv : JS::NullValue(); - return js::NewProxyObject(aCx, (js::BaseProxyHandler*)aHandler, priv, proto, - parent, call, construct); + js::ProxyOptions options; + return js::NewProxyObject(aCx, (js::BaseProxyHandler*)aHandler, aPriv, proto, + options); } JSObject* -WrapperNew(JSContext* aCx, JSObject* aParent, void* aHandler) +WrapperNew(JSContext* aCx, JS::HandleObject aObj, const void* aHandler) { - return js::Wrapper::New(aCx, aParent, js::GetObjectProto(aParent), aParent, (js::Wrapper*)aHandler); + return js::Wrapper::New(aCx, aObj, (const js::Wrapper*)aHandler); } jsval @@ -430,38 +514,26 @@ SetProxyExtra(JSObject* obj, uint32_t slot, jsval val) return js::SetProxyExtra(obj, slot, val); } -JSObject* -GetObjectProto(JSObject* obj) -{ - return js::GetObjectProto(obj); -} - -JSObject* -GetObjectParent(JSObject* obj) -{ - return js::GetObjectParent(obj); -} - -JSBool -RUST_JSID_IS_INT(jsid id) +bool +RUST_JSID_IS_INT(JS::HandleId id) { return JSID_IS_INT(id); } int -RUST_JSID_TO_INT(jsid id) +RUST_JSID_TO_INT(JS::HandleId id) { return JSID_TO_INT(id); } -JSBool -RUST_JSID_IS_STRING(jsid id) +bool +RUST_JSID_IS_STRING(JS::HandleId id) { return JSID_IS_STRING(id); } JSString* -RUST_JSID_TO_STRING(jsid id) +RUST_JSID_TO_STRING(JS::HandleId id) { return JSID_TO_STRING(id); } @@ -476,35 +548,10 @@ RUST_INTERNED_STRING_TO_JSID(JSContext* cx, JSString* str) { return INTERNED_STRING_TO_JSID(cx, str); } -JSFunction* -DefineFunctionWithReserved(JSContext* cx, JSObject* obj, const char* name, JSNative call, - uint32_t nargs, uint32_t attrs) -{ - return js::DefineFunctionWithReserved(cx, obj, name, call, nargs, attrs); -} - -JSClass* -GetObjectJSClass(JSObject* obj) -{ - return js::GetObjectJSClass(obj); -} - const JSErrorFormatString* -RUST_js_GetErrorMessage(void* userRef, const char* locale, uint32_t errorNumber) +RUST_js_GetErrorMessage(void* userRef, uint32_t errorNumber) { - return js_GetErrorMessage(userRef, locale, errorNumber); -} - -JSBool -js_IsObjectProxyClass(JSObject* obj) -{ - return js::IsObjectProxyClass(js::GetObjectClass(obj)); -} - -JSBool -js_IsFunctionProxyClass(JSObject* obj) -{ - return js::IsFunctionProxyClass(js::GetObjectClass(obj)); + return js::GetErrorMessage(userRef, errorNumber); } bool @@ -516,25 +563,19 @@ IsProxyHandlerFamily(JSObject* obj) const void* GetProxyHandlerExtra(JSObject* obj) { - js::BaseProxyHandler* handler = js::GetProxyHandler(obj); + const js::BaseProxyHandler* handler = js::GetProxyHandler(obj); assert(handler->family() == &HandlerFamily); - return static_cast(handler)->getExtra(); + return static_cast(handler)->getExtra(); } -void* +const void* GetProxyHandler(JSObject* obj) { - js::BaseProxyHandler* handler = js::GetProxyHandler(obj); + const js::BaseProxyHandler* handler = js::GetProxyHandler(obj); assert(handler->family() == &HandlerFamily); return handler; } -JSObject* -GetGlobalForObjectCrossCompartment(JSObject* obj) -{ - return js::GetGlobalForObjectCrossCompartment(obj); -} - void ReportError(JSContext* aCx, const char* aError) { @@ -546,16 +587,16 @@ ReportError(JSContext* aCx, const char* aError) JS_ReportError(aCx, aError); } -JSBool +bool IsWrapper(JSObject* obj) { return js::IsWrapper(obj); } JSObject* -UnwrapObject(JSObject* obj, JSBool stopAtOuter, unsigned* flags) +UnwrapObject(JSObject* obj, bool stopAtOuter) { - return js::UnwrapObject(obj, stopAtOuter, flags); + return js::CheckedUnwrap(obj, stopAtOuter); } bool @@ -564,4 +605,23 @@ AppendToAutoIdVector(JS::AutoIdVector* v, jsid id) return v->append(id); } +JS::AutoObjectVector* +CreateAutoObjectVector(JSContext* aCx) +{ + JS::AutoObjectVector* vec = new JS::AutoObjectVector(aCx); + return vec; +} + +bool +AppendToAutoObjectVector(JS::AutoObjectVector* v, JSObject* obj) +{ + return v->append(obj); +} + +void +DeleteAutoObjectVector(JS::AutoObjectVector* v) +{ + delete v; +} + } // extern "C" diff --git a/src/jsval.rs b/src/jsval.rs index 45ae2df84..7eb48752a 100644 --- a/src/jsval.rs +++ b/src/jsval.rs @@ -4,28 +4,16 @@ use jsapi::{JSObject, JSString, JSGCTraceKind}; use jsapi::JSGCTraceKind::{JSTRACE_OBJECT, JSTRACE_STRING}; +use jsapi::Value; +use jsapi::jsval_layout; use libc::c_void; use std::mem; -#[cfg(target_pointer_width = "64")] -const JSVAL_TAG_SHIFT: u32 = 47; +pub type JSVal = Value; -#[allow(dead_code)] -mod ValueType { - pub const DOUBLE: u8 = 0x00; - pub const INT32: u8 = 0x01; - pub const UNDEFINED: u8 = 0x02; - pub const BOOLEAN: u8 = 0x03; - pub const MAGIC: u8 = 0x04; - pub const STRING: u8 = 0x05; - pub const NULL: u8 = 0x06; - pub const OBJECT: u8 = 0x07; - - /* These never appear in a jsval; they are only provided as an out-of-band value. */ - pub const UNKNOWN: u8 = 0x20; - pub const MISSING: u8 = 0x21; -} +#[cfg(target_pointer_width = "64")] +const JSVAL_TAG_SHIFT: usize = 47; #[cfg(target_pointer_width = "64")] const JSVAL_TAG_MAX_DOUBLE: u32 = 0x1FFF0u32; @@ -36,31 +24,34 @@ const JSVAL_TAG_CLEAR: u32 = 0xFFFFFF80; #[cfg(target_pointer_width = "64")] #[allow(dead_code)] mod ValueTag { - use super::{JSVAL_TAG_MAX_DOUBLE, ValueType}; - - pub const DOUBLE: u32 = JSVAL_TAG_MAX_DOUBLE | (ValueType::DOUBLE as u32); - pub const INT32: u32 = JSVAL_TAG_MAX_DOUBLE | (ValueType::INT32 as u32); - pub const UNDEFINED: u32 = JSVAL_TAG_MAX_DOUBLE | (ValueType::UNDEFINED as u32); - pub const STRING: u32 = JSVAL_TAG_MAX_DOUBLE | (ValueType::STRING as u32); - pub const BOOLEAN: u32 = JSVAL_TAG_MAX_DOUBLE | (ValueType::BOOLEAN as u32); - pub const MAGIC: u32 = JSVAL_TAG_MAX_DOUBLE | (ValueType::MAGIC as u32); - pub const NULL: u32 = JSVAL_TAG_MAX_DOUBLE | (ValueType::NULL as u32); - pub const OBJECT: u32 = JSVAL_TAG_MAX_DOUBLE | (ValueType::OBJECT as u32); + use jsapi::JSValueType; + use super::JSVAL_TAG_MAX_DOUBLE; + + pub const INT32: u32 = JSVAL_TAG_MAX_DOUBLE | (JSValueType::JSVAL_TYPE_INT32 as u32); + pub const UNDEFINED: u32 = JSVAL_TAG_MAX_DOUBLE | (JSValueType::JSVAL_TYPE_UNDEFINED as u32); + pub const STRING: u32 = JSVAL_TAG_MAX_DOUBLE | (JSValueType::JSVAL_TYPE_STRING as u32); + pub const SYMBOL: u32 = JSVAL_TAG_MAX_DOUBLE | (JSValueType::JSVAL_TYPE_SYMBOL as u32); + pub const BOOLEAN: u32 = JSVAL_TAG_MAX_DOUBLE | (JSValueType::JSVAL_TYPE_BOOLEAN as u32); + pub const MAGIC: u32 = JSVAL_TAG_MAX_DOUBLE | (JSValueType::JSVAL_TYPE_MAGIC as u32); + pub const NULL: u32 = JSVAL_TAG_MAX_DOUBLE | (JSValueType::JSVAL_TYPE_NULL as u32); + pub const OBJECT: u32 = JSVAL_TAG_MAX_DOUBLE | (JSValueType::JSVAL_TYPE_OBJECT as u32); } #[cfg(target_pointer_width = "32")] #[allow(dead_code)] mod ValueTag { - use super::{JSVAL_TAG_CLEAR, ValueType}; + use jsapi::JSValueType; + use super::JSVAL_TAG_CLEAR; pub const PRIVATE: u32 = 0; - pub const INT32: u32 = JSVAL_TAG_CLEAR as u32 | (ValueType::INT32 as u32); - pub const UNDEFINED: u32 = JSVAL_TAG_CLEAR as u32 | (ValueType::UNDEFINED as u32); - pub const STRING: u32 = JSVAL_TAG_CLEAR as u32 | (ValueType::STRING as u32); - pub const BOOLEAN: u32 = JSVAL_TAG_CLEAR as u32 | (ValueType::BOOLEAN as u32); - pub const MAGIC: u32 = JSVAL_TAG_CLEAR as u32 | (ValueType::MAGIC as u32); - pub const NULL: u32 = JSVAL_TAG_CLEAR as u32 | (ValueType::NULL as u32); - pub const OBJECT: u32 = JSVAL_TAG_CLEAR as u32 | (ValueType::OBJECT as u32); + pub const INT32: u32 = JSVAL_TAG_CLEAR as u32 | (JSValueType::JSVAL_TYPE_INT32 as u32); + pub const UNDEFINED: u32 = JSVAL_TAG_CLEAR as u32 | (JSValueType::JSVAL_TYPE_UNDEFINED as u32); + pub const STRING: u32 = JSVAL_TAG_CLEAR as u32 | (JSValueType::JSVAL_TYPE_STRING as u32); + pub const SYMBOL: u32 = JSVAL_TAG_CLEAR as u32 | (JSValueType::JSVAL_TYPE_SYMBOL as u32); + pub const BOOLEAN: u32 = JSVAL_TAG_CLEAR as u32 | (JSValueType::JSVAL_TYPE_BOOLEAN as u32); + pub const MAGIC: u32 = JSVAL_TAG_CLEAR as u32 | (JSValueType::JSVAL_TYPE_MAGIC as u32); + pub const NULL: u32 = JSVAL_TAG_CLEAR as u32 | (JSValueType::JSVAL_TYPE_NULL as u32); + pub const OBJECT: u32 = JSVAL_TAG_CLEAR as u32 | (JSValueType::JSVAL_TYPE_OBJECT as u32); } #[cfg(target_pointer_width = "64")] @@ -72,6 +63,7 @@ mod ValueShiftedTag { pub const INT32: u64 = ((ValueTag::INT32 as u64) << JSVAL_TAG_SHIFT); pub const UNDEFINED: u64 = ((ValueTag::UNDEFINED as u64) << JSVAL_TAG_SHIFT); pub const STRING: u64 = ((ValueTag::STRING as u64) << JSVAL_TAG_SHIFT); + pub const SYMBOL: u64 = ((ValueTag::SYMBOL as u64) << JSVAL_TAG_SHIFT); pub const BOOLEAN: u64 = ((ValueTag::BOOLEAN as u64) << JSVAL_TAG_SHIFT); pub const MAGIC: u64 = ((ValueTag::MAGIC as u64) << JSVAL_TAG_SHIFT); pub const NULL: u64 = ((ValueTag::NULL as u64) << JSVAL_TAG_SHIFT); @@ -82,27 +74,24 @@ mod ValueShiftedTag { #[cfg(target_pointer_width = "64")] const JSVAL_PAYLOAD_MASK: u64 = 0x00007FFFFFFFFFFF; -// JSVal was originally type of u64. -// now this become {u64} because of the union abi issue on ARM arch. See #398. -#[derive(PartialEq, Clone, Copy)] -pub struct JSVal { - pub v: u64 +fn AsJSVal(val: u64) -> JSVal { + JSVal { + data: jsval_layout { + _bindgen_data_: [val] + } + } } #[cfg(target_pointer_width = "64")] #[inline(always)] fn BuildJSVal(tag: u32, payload: u64) -> JSVal { - JSVal { - v: ((tag as u32 as u64) << JSVAL_TAG_SHIFT) | payload - } + AsJSVal(((tag as u32 as u64) << JSVAL_TAG_SHIFT) | payload) } #[cfg(target_pointer_width = "32")] #[inline(always)] fn BuildJSVal(tag: u32, payload: u64) -> JSVal { - JSVal { - v: ((tag as u32 as u64) << 32) | payload - } + AsJSVal(((tag as u32 as u64) << 32) | payload) } #[inline(always)] @@ -125,18 +114,14 @@ pub fn Int32Value(i: i32) -> JSVal { pub fn DoubleValue(f: f64) -> JSVal { let bits: u64 = unsafe { mem::transmute(f) }; assert!(bits <= ValueShiftedTag::MAX_DOUBLE as u64); - JSVal { - v: bits - } + AsJSVal(bits) } #[cfg(target_pointer_width = "32")] #[inline(always)] pub fn DoubleValue(f: f64) -> JSVal { let bits: u64 = unsafe { mem::transmute(f) }; - let val = JSVal { - v: bits - }; + let val = AsJSVal(bits); assert!(val.is_double()); val } @@ -199,9 +184,7 @@ pub fn ObjectOrNullValue(o: *mut JSObject) -> JSVal { pub fn PrivateValue(o: *const c_void) -> JSVal { let ptrBits = o as usize as u64; assert!((ptrBits & 1) == 0); - JSVal { - v: ptrBits >> 1 - } + AsJSVal(ptrBits >> 1) } #[cfg(target_pointer_width = "32")] @@ -213,24 +196,28 @@ pub fn PrivateValue(o: *const c_void) -> JSVal { } impl JSVal { + fn asBits(&self) -> u64 { + self.data._bindgen_data_[0] + } + #[cfg(target_pointer_width = "64")] pub fn is_undefined(&self) -> bool { - self.v == ValueShiftedTag::UNDEFINED as u64 + self.asBits() == ValueShiftedTag::UNDEFINED as u64 } #[cfg(target_pointer_width = "32")] pub fn is_undefined(&self) -> bool { - (self.v >> 32) == ValueTag::UNDEFINED as u64 + (self.asBits() >> 32) == ValueTag::UNDEFINED as u64 } #[cfg(target_pointer_width = "64")] pub fn is_null(&self) -> bool { - self.v == ValueShiftedTag::NULL as u64 + self.asBits() == ValueShiftedTag::NULL as u64 } #[cfg(target_pointer_width = "32")] pub fn is_null(&self) -> bool { - (self.v >> 32) == ValueTag::NULL as u64 + (self.asBits() >> 32) == ValueTag::NULL as u64 } pub fn is_null_or_undefined(&self) -> bool { @@ -239,66 +226,117 @@ impl JSVal { #[cfg(target_pointer_width = "64")] pub fn is_boolean(&self) -> bool { - (self.v >> JSVAL_TAG_SHIFT) == ValueTag::BOOLEAN as u64 + (self.asBits() >> JSVAL_TAG_SHIFT) == ValueTag::BOOLEAN as u64 } #[cfg(target_pointer_width = "32")] pub fn is_boolean(&self) -> bool { - (self.v >> 32) == ValueTag::BOOLEAN as u64 + (self.asBits() >> 32) == ValueTag::BOOLEAN as u64 + } + + #[cfg(target_pointer_width = "64")] + pub fn is_int32(&self) -> bool { + (self.asBits() >> JSVAL_TAG_SHIFT) == ValueTag::INT32 as u64 + } + + #[cfg(target_pointer_width = "32")] + pub fn is_int32(&self) -> bool { + (self.asBits() >> 32) == ValueTag::INT32 as u64 } #[cfg(target_pointer_width = "64")] pub fn is_double(&self) -> bool { - self.v <= ValueShiftedTag::MAX_DOUBLE as u64 + self.asBits() <= ValueShiftedTag::MAX_DOUBLE as u64 } #[cfg(target_pointer_width = "32")] pub fn is_double(&self) -> bool { - (self.v >> 32) <= JSVAL_TAG_CLEAR as u64 + (self.asBits() >> 32) <= JSVAL_TAG_CLEAR as u64 + } + + #[cfg(target_pointer_width = "64")] + pub fn is_number(&self) -> bool { + const JSVAL_UPPER_EXCL_SHIFTED_TAG_OF_NUMBER_SET: u64 = ValueShiftedTag::UNDEFINED as u64; + self.asBits() < JSVAL_UPPER_EXCL_SHIFTED_TAG_OF_NUMBER_SET + } + + #[cfg(target_pointer_width = "32")] + pub fn is_number(&self) -> bool { + const JSVAL_UPPER_INCL_TAG_OF_NUMBER_SET: u64 = ValueTag::INT32 as u64; + (self.asBits() >> 32) <= JSVAL_UPPER_INCL_TAG_OF_NUMBER_SET } #[cfg(target_pointer_width = "64")] pub fn is_primitive(&self) -> bool { const JSVAL_UPPER_EXCL_SHIFTED_TAG_OF_PRIMITIVE_SET: u64 = ValueShiftedTag::OBJECT as u64; - self.v < JSVAL_UPPER_EXCL_SHIFTED_TAG_OF_PRIMITIVE_SET + self.asBits() < JSVAL_UPPER_EXCL_SHIFTED_TAG_OF_PRIMITIVE_SET } #[cfg(target_pointer_width = "32")] pub fn is_primitive(&self) -> bool { const JSVAL_UPPER_EXCL_TAG_OF_PRIMITIVE_SET: u64 = ValueTag::OBJECT as u64; - (self.v >> 32) < JSVAL_UPPER_EXCL_TAG_OF_PRIMITIVE_SET + (self.asBits() >> 32) < JSVAL_UPPER_EXCL_TAG_OF_PRIMITIVE_SET } #[cfg(target_pointer_width = "64")] pub fn is_string(&self) -> bool { - (self.v >> JSVAL_TAG_SHIFT) == ValueTag::STRING as u64 + (self.asBits() >> JSVAL_TAG_SHIFT) == ValueTag::STRING as u64 } #[cfg(target_pointer_width = "32")] pub fn is_string(&self) -> bool { - (self.v >> 32) == ValueTag::STRING as u64 + (self.asBits() >> 32) == ValueTag::STRING as u64 } #[cfg(target_pointer_width = "64")] pub fn is_object(&self) -> bool { - assert!((self.v >> JSVAL_TAG_SHIFT) <= ValueTag::OBJECT as u64); - self.v >= ValueShiftedTag::OBJECT as u64 + assert!((self.asBits() >> JSVAL_TAG_SHIFT) <= ValueTag::OBJECT as u64); + self.asBits() >= ValueShiftedTag::OBJECT as u64 } #[cfg(target_pointer_width = "32")] pub fn is_object(&self) -> bool { - (self.v >> 32) == ValueTag::OBJECT as u64 + (self.asBits() >> 32) == ValueTag::OBJECT as u64 + } + + #[cfg(target_pointer_width = "64")] + pub fn is_symbol(&self) -> bool { + self.asBits() == ValueShiftedTag::SYMBOL as u64 + } + + #[cfg(target_pointer_width = "32")] + pub fn is_symbol(&self) -> bool { + (self.asBits() >> 32) == ValueTag::SYMBOL as u64 } #[cfg(target_pointer_width = "64")] pub fn to_boolean(&self) -> bool { assert!(self.is_boolean()); - (self.v & JSVAL_PAYLOAD_MASK) != 0 + (self.asBits() & JSVAL_PAYLOAD_MASK) != 0 } #[cfg(target_pointer_width = "32")] pub fn to_boolean(&self) -> bool { - (self.v & 0x00000000FFFFFFFF) != 0 + (self.asBits() & 0x00000000FFFFFFFF) != 0 + } + + pub fn to_int32(&self) -> i32 { + assert!(self.is_int32()); + (self.asBits() & 0x00000000FFFFFFFF) as i32 + } + + pub fn to_double(&self) -> f64 { + assert!(self.is_double()); + self.asBits() as f64 + } + + pub fn to_number(&self) -> f64 { + assert!(self.is_number()); + if self.is_double() { + self.to_double() + } else { + self.to_int32() as f64 + } } pub fn to_object(&self) -> *mut JSObject { @@ -306,24 +344,38 @@ impl JSVal { self.to_object_or_null() } + #[cfg(target_pointer_width = "64")] + pub fn to_string(&self) -> *mut JSString { + assert!(self.is_string()); + let ptrBits = self.asBits() & JSVAL_PAYLOAD_MASK; + ptrBits as usize as *mut JSString + } + + #[cfg(target_pointer_width = "32")] + pub fn to_string(&self) -> *mut JSString { + assert!(self.is_string()); + let ptrBits: u32 = (self.asBits() & 0x00000000FFFFFFFF) as u32; + ptrBits as *mut JSString + } + #[cfg(target_pointer_width = "64")] pub fn is_object_or_null(&self) -> bool { const JSVAL_LOWER_INCL_SHIFTED_TAG_OF_OBJ_OR_NULL_SET: u64 = ValueShiftedTag::NULL as u64; - assert!((self.v >> JSVAL_TAG_SHIFT) <= ValueTag::OBJECT as u64); - self.v >= JSVAL_LOWER_INCL_SHIFTED_TAG_OF_OBJ_OR_NULL_SET + assert!((self.asBits() >> JSVAL_TAG_SHIFT) <= ValueTag::OBJECT as u64); + self.asBits() >= JSVAL_LOWER_INCL_SHIFTED_TAG_OF_OBJ_OR_NULL_SET } #[cfg(target_pointer_width = "32")] pub fn is_object_or_null(&self) -> bool { const JSVAL_LOWER_INCL_TAG_OF_OBJ_OR_NULL_SET: u64 = ValueTag::NULL as u64; - assert!((self.v >> 32) <= ValueTag::OBJECT as u64); - (self.v >> 32) >= JSVAL_LOWER_INCL_TAG_OF_OBJ_OR_NULL_SET + assert!((self.asBits() >> 32) <= ValueTag::OBJECT as u64); + (self.asBits() >> 32) >= JSVAL_LOWER_INCL_TAG_OF_OBJ_OR_NULL_SET } #[cfg(target_pointer_width = "64")] pub fn to_object_or_null(&self) -> *mut JSObject { assert!(self.is_object_or_null()); - let ptrBits = self.v & JSVAL_PAYLOAD_MASK; + let ptrBits = self.asBits() & JSVAL_PAYLOAD_MASK; assert!((ptrBits & 0x7) == 0); ptrBits as usize as *mut JSObject } @@ -331,39 +383,39 @@ impl JSVal { #[cfg(target_pointer_width = "32")] pub fn to_object_or_null(&self) -> *mut JSObject { assert!(self.is_object_or_null()); - let ptrBits: u32 = (self.v & 0x00000000FFFFFFFF) as u32; + let ptrBits: u32 = (self.asBits() & 0x00000000FFFFFFFF) as u32; ptrBits as *mut JSObject } #[cfg(target_pointer_width = "64")] pub fn to_private(&self) -> *const c_void { assert!(self.is_double()); - assert!((self.v & 0x8000000000000000u64) == 0); - (self.v << 1) as usize as *const c_void + assert!((self.asBits() & 0x8000000000000000u64) == 0); + (self.asBits() << 1) as usize as *const c_void } #[cfg(target_pointer_width = "32")] pub fn to_private(&self) -> *const c_void { - let ptrBits: u32 = (self.v & 0x00000000FFFFFFFF) as u32; + let ptrBits: u32 = (self.asBits() & 0x00000000FFFFFFFF) as u32; ptrBits as *const c_void } #[cfg(target_pointer_width = "64")] pub fn is_gcthing(&self) -> bool { const JSVAL_LOWER_INCL_SHIFTED_TAG_OF_GCTHING_SET: u64 = ValueShiftedTag::STRING as u64; - self.v >= JSVAL_LOWER_INCL_SHIFTED_TAG_OF_GCTHING_SET + self.asBits() >= JSVAL_LOWER_INCL_SHIFTED_TAG_OF_GCTHING_SET } #[cfg(target_pointer_width = "32")] pub fn is_gcthing(&self) -> bool { const JSVAL_LOWER_INCL_TAG_OF_GCTHING_SET: u64 = ValueTag::STRING as u64; - (self.v >> 32) >= JSVAL_LOWER_INCL_TAG_OF_GCTHING_SET + (self.asBits() >> 32) >= JSVAL_LOWER_INCL_TAG_OF_GCTHING_SET } #[cfg(target_pointer_width = "64")] pub fn to_gcthing(&self) -> *mut c_void { assert!(self.is_gcthing()); - let ptrBits = self.v & JSVAL_PAYLOAD_MASK; + let ptrBits = self.asBits() & JSVAL_PAYLOAD_MASK; assert!((ptrBits & 0x7) == 0); ptrBits as *mut c_void } @@ -371,7 +423,7 @@ impl JSVal { #[cfg(target_pointer_width = "32")] pub fn to_gcthing(&self) -> *mut c_void { assert!(self.is_gcthing()); - let ptrBits: u32 = (self.v & 0x00000000FFFFFFFF) as u32; + let ptrBits: u32 = (self.asBits() & 0x00000000FFFFFFFF) as u32; ptrBits as *mut c_void } diff --git a/src/lib.rs b/src/lib.rs index 2aa9e68c8..a83764af9 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -5,53 +5,35 @@ #![crate_name = "js"] #![crate_type = "rlib"] -#![feature(link_args, collections)] +#![feature(link_args, collections, core)] #![allow(non_upper_case_globals, non_camel_case_types, non_snake_case, improper_ctypes, raw_pointer_derive)] extern crate libc; #[macro_use] extern crate log; +extern crate num; extern crate rustc_serialize as serialize; use libc::c_uint; -use libc::types::common::c99::uint32_t; -use jsapi::{JSBool, JSContext, JSPropertyOp, JSStrictPropertyOp, JSEnumerateOp, - JSObject, jsid, JSResolveOp, JSConvertOp, JSFinalizeOp, JSTraceOp, - JSProto_LIMIT, JSHandleObject, JSCheckAccessOp, JSNative, JSHasInstanceOp}; -use jsapi::JS_ComputeThis; -use jsval::JSVal; -// These are just macros in jsapi.h -pub use jsapi::JS_Init as JS_NewRuntime; -pub use jsapi::JS_Finish as JS_DestroyRuntime; /* FIXME: Not sure where JS_Lock is pub use jsapi::bindgen::JS_Lock as JS_LockRuntime; pub use jsapi::bindgen::JS_Unlock as JS_UnlockRuntime; */ -pub use jsfriendapi::JSJitInfo; - pub mod jsapi; pub mod linkhack; pub mod rust; pub mod glue; pub mod jsval; -pub mod jsfriendapi; -// FIXME: Add the remaining options -pub const JSOPTION_STRICT: uint32_t = 0b00000000000001u32; -pub const JSOPTION_WERROR: uint32_t = 0b00000000000010u32; -pub const JSOPTION_VAROBJFIX: uint32_t = 0b00000000000100u32; -pub const JSOPTION_DONT_REPORT_UNCAUGHT: uint32_t = (1u32 << 8) as u32; -pub const JSOPTION_AUTOJSAPI_OWNS_ERROR_REPORTING: uint32_t = (1u32 << 10) as u32; -pub const JSOPTION_METHODJIT: uint32_t = (1u32 << 14) as u32; -pub const JSOPTION_TYPE_INFERENCE: uint32_t = (1u32 << 18) as u32; +use jsapi::{JSContext, JSObject, JS_ComputeThis, JSProtoKey}; +use jsval::JSVal; pub const default_heapsize: u32 = 32_u32 * 1024_u32 * 1024_u32; pub const default_stacksize: usize = 8192; -pub const ERR: JSBool = 0_i32; pub const JSID_TYPE_STRING: i64 = 0; pub const JSID_TYPE_INT: i64 = 1; @@ -60,9 +42,7 @@ pub const JSID_TYPE_OBJECT: i64 = 4; pub const JSID_TYPE_DEFAULT_XML_NAMESPACE: i64 = 6; pub const JSID_TYPE_MASK: i64 = 7; -pub const JSID_VOID: jsid = JSID_TYPE_VOID as jsid; - -pub const JSFUN_CONSTRUCTOR: u32 = 0x200; /* native that can be called as a ctor */ +pub const JSFUN_CONSTRUCTOR: u32 = 0x400; /* native that can be called as a ctor */ pub const JSPROP_ENUMERATE: c_uint = 0x01; pub const JSPROP_READONLY: c_uint = 0x02; @@ -79,37 +59,35 @@ pub const JSCLASS_RESERVED_SLOTS_MASK: c_uint = ((1 << JSCLASS_RESERVED_SLOTS_WI pub const JSCLASS_HIGH_FLAGS_SHIFT: c_uint = JSCLASS_RESERVED_SLOTS_SHIFT + JSCLASS_RESERVED_SLOTS_WIDTH; pub const JSCLASS_IS_GLOBAL: c_uint = 1 << (JSCLASS_HIGH_FLAGS_SHIFT + 1); - -pub const JSCLASS_GLOBAL_SLOT_COUNT: c_uint = JSProto_LIMIT * 3 + 24; +pub const JSCLASS_GLOBAL_APPLICATION_SLOTS: c_uint = 4; +pub const JSCLASS_GLOBAL_SLOT_COUNT: c_uint = JSCLASS_GLOBAL_APPLICATION_SLOTS + JSProtoKey::JSProto_LIMIT as u32 * 3 + 31; pub const JSCLASS_IS_DOMJSCLASS: u32 = 1 << 4; +pub const JSCLASS_IMPLEMENTS_BARRIERS: u32 = 1 << 5; pub const JSCLASS_USERBIT1: u32 = 1 << 7; +pub const JSCLASS_IS_PROXY: u32 = 1 << (JSCLASS_HIGH_FLAGS_SHIFT+4); + pub const JSSLOT_PROXY_PRIVATE: u32 = 1; -pub const JSRESOLVE_QUALIFIED: u32 = 0x01; -pub const JSRESOLVE_ASSIGNING: u32 = 0x02; -pub const JSRESOLVE_DETECTING: u32 = 0x04; +pub const JS_DEFAULT_ZEAL_FREQ: u32 = 100; -pub enum JSGCTraceKind { - JSTRACE_OBJECT, - JSTRACE_STRING, - JSTRACE_SCRIPT -} +#[link(name = "jsglue")] +extern { } -pub fn JSCLASS_HAS_RESERVED_SLOTS(n: c_uint) -> c_uint { - (n & JSCLASS_RESERVED_SLOTS_MASK) << JSCLASS_RESERVED_SLOTS_SHIFT -} +#[cfg(target_os = "android")] +#[link(name = "stdc++")] +extern { } + +#[cfg(target_os = "android")] +#[link(name = "gcc")] +extern { } #[inline(always)] pub unsafe fn JS_ARGV(_cx: *mut JSContext, vp: *mut JSVal) -> *mut JSVal { vp.offset(2) } -pub unsafe fn JS_SET_RVAL(_cx: *mut JSContext, vp: *mut JSVal, v: JSVal) { - *vp = v; -} - #[inline(always)] pub unsafe fn JS_THIS_OBJECT(cx: *mut JSContext, vp: *mut JSVal) -> *mut JSObject { let val = *vp.offset(1); @@ -126,74 +104,3 @@ pub unsafe fn JS_THIS_OBJECT(cx: *mut JSContext, vp: *mut JSVal) -> *mut JSObjec pub unsafe fn JS_CALLEE(_cx: *mut JSContext, vp: *mut JSVal) -> JSVal { *vp } - -pub type JSObjectOp = extern "C" fn(*mut JSContext, JSHandleObject) -> *mut JSObject; - -#[derive(Copy, Clone)] -pub struct Class { - pub name: *const libc::c_char, - pub flags: uint32_t, - pub addProperty: JSPropertyOp, - pub delProperty: JSPropertyOp, - pub getProperty: JSPropertyOp, - pub setProperty: JSStrictPropertyOp, - pub enumerate: JSEnumerateOp, - pub resolve: JSResolveOp, - pub convert: JSConvertOp, - pub finalize: JSFinalizeOp, - pub checkAccess: JSCheckAccessOp, - pub call: JSNative, - pub hasInstance: JSHasInstanceOp, - pub construct: JSNative, - pub trace: JSTraceOp, - - pub ext: ClassExtension, - pub ops: ObjectOps, -} - -#[derive(Copy, Clone)] -pub struct ClassExtension { - pub equality: *const u8, - pub outerObject: Option, - pub innerObject: Option, - pub iteratorObject: *const u8, - pub unused: *const u8, - pub isWrappedNative: *const u8, -} - -#[derive(Copy, Clone)] -pub struct ObjectOps { - pub lookupGeneric: *const u8, - pub lookupProperty: *const u8, - pub lookupElement: *const u8, - pub lookupSpecial: *const u8, - pub defineGeneric: *const u8, - pub defineProperty: *const u8, - pub defineElement: *const u8, - pub defineSpecial: *const u8, - pub getGeneric: *const u8, - pub getProperty: *const u8, - pub getElement: *const u8, - pub getElementIfPresent: *const u8, - pub getSpecial: *const u8, - pub setGeneric: *const u8, - pub setProperty: *const u8, - pub setElement: *const u8, - pub setSpecial: *const u8, - pub getGenericAttributes: *const u8, - pub getPropertyAttributes: *const u8, - pub getElementAttributes: *const u8, - pub getSpecialAttributes: *const u8, - pub setGenericAttributes: *const u8, - pub setPropertyAttributes: *const u8, - pub setElementAttributes: *const u8, - pub setSpecialAttributes: *const u8, - pub deleteProperty: *const u8, - pub deleteElement: *const u8, - pub deleteSpecial: *const u8, - - pub enumerate: *const u8, - pub typeOf: *const u8, - pub thisObject: Option, - pub clear: *const u8, -} diff --git a/src/linkhack.rs b/src/linkhack.rs index 4e74e7d87..cd19cabc3 100644 --- a/src/linkhack.rs +++ b/src/linkhack.rs @@ -7,12 +7,14 @@ #[cfg(target_os = "linux")] #[link(name = "pthread")] #[link(name = "js_static", kind = "static")] +#[link(name = "mozglue", kind = "static")] #[link(name = "stdc++")] #[link(name = "z")] extern { } #[cfg(target_os = "macos")] #[link(name = "js_static", kind = "static")] +#[link(name = "mozglue", kind = "static")] #[link(name = "stdc++")] #[link(name = "z")] extern { } diff --git a/src/rust.rs b/src/rust.rs index 3a29fd5ee..93057d940 100644 --- a/src/rust.rs +++ b/src/rust.rs @@ -8,18 +8,33 @@ use libc::types::os::arch::c95::{size_t, c_uint}; use libc::c_char; use std::ffi; use std::str; +use std::ptr; +use std::mem; use std::u32; -use jsapi::*; -use jsapi::JSVersion::JSVERSION_LATEST; -use jsval::{JSVal, NullValue}; +use std::default::Default; +use std::intrinsics::return_address; +use num::NumCast; +use jsapi::{JS_NewContext, JS_DestroyContext, JS_NewRuntime, JS_DestroyRuntime}; +use jsapi::{JSContext, JSRuntime, JSObject, JSFlatString, JSFunction, JSString, Symbol, JSScript, jsid, Value}; +use jsapi::{RuntimeOptionsRef, ContextOptionsRef, ReadOnlyCompileOptions}; +use jsapi::{JS_SetErrorReporter, Evaluate3, JSErrorReport}; +use jsapi::{JS_SetGCParameter, JS_SetGCZeal, JSGCParamKey}; +use jsapi::{Heap, Cell, HeapCellPostBarrier, HeapCellRelocate, HeapValuePostBarrier, HeapValueRelocate}; +use jsapi::{ThingRootKind, ContextFriendFields}; +use jsapi::{Rooted, RootedValue, Handle, MutableHandle, MutableHandleValue, HandleValue}; +use jsapi::AutoObjectVector; +use jsapi::{ToBooleanSlow, ToNumberSlow, ToStringSlow}; +use jsapi::{ToInt32Slow, ToUint32Slow, ToUint16Slow, ToInt64Slow, ToUint64Slow}; +use jsapi::{JSAutoRequest, JS_BeginRequest, JS_EndRequest}; +use jsapi::{JSAutoCompartment, JS_EnterCompartment, JS_LeaveCompartment}; +use jsapi::{JSJitMethodCallArgs, JSJitGetterCallArgs, JSJitSetterCallArgs, CallArgs}; +use jsapi::{JSVAL_NULL, JSVAL_VOID, JSID_VOID}; +use jsval::UndefinedValue; +use glue::{CreateAutoObjectVector, AppendToAutoObjectVector, DeleteAutoObjectVector}; +use glue::{NewCompileOptions, DeleteCompileOptions}; +use JS_DEFAULT_ZEAL_FREQ; use default_stacksize; use default_heapsize; -use JSOPTION_VAROBJFIX; -use JSOPTION_METHODJIT; -use JSOPTION_TYPE_INFERENCE; -use JSOPTION_DONT_REPORT_UNCAUGHT; -use JSOPTION_AUTOJSAPI_OWNS_ERROR_REPORTING; -use ERR; // ___________________________________________________________________________ // friendly Rustic API to runtimes @@ -33,7 +48,9 @@ pub struct Runtime { impl Runtime { /// Creates a new `JSRuntime` and `JSContext`. pub fn new() -> Runtime { - let js_runtime = unsafe { JS_Init(default_heapsize) }; + let js_runtime = unsafe { + JS_NewRuntime(default_heapsize, ChunkSize as u32, ptr::null_mut()) + }; assert!(!js_runtime.is_null()); // Unconstrain the runtime's threshold on nominal heap size, to avoid @@ -42,7 +59,7 @@ impl Runtime { // still in effect to cause periodical, and we hope hygienic, // last-ditch GCs from within the GC's allocator. unsafe { - JS_SetGCParameter(js_runtime, JSGC_MAX_BYTES, u32::MAX); + JS_SetGCParameter(js_runtime, JSGCParamKey::JSGC_MAX_BYTES, u32::MAX); } let js_context = unsafe { @@ -51,17 +68,16 @@ impl Runtime { assert!(!js_context.is_null()); unsafe { - JS_SetOptions(js_context, - JSOPTION_VAROBJFIX | - JSOPTION_METHODJIT | - JSOPTION_TYPE_INFERENCE | - JSOPTION_DONT_REPORT_UNCAUGHT | - JSOPTION_AUTOJSAPI_OWNS_ERROR_REPORTING); - - JS_SetVersion(js_context, JSVERSION_LATEST); - JS_SetErrorReporter(js_context, - Some(reportError as unsafe extern "C" - fn(*mut JSContext, *const c_char, *mut JSErrorReport))); + let runtimeopts = RuntimeOptionsRef(js_runtime); + let contextopts = ContextOptionsRef(js_context); + + (*runtimeopts).set_varObjFix_(true); + (*runtimeopts).set_baseline_(true); + (*runtimeopts).set_ion_(true); + + (*contextopts).set_dontReportUncaught_(true); + (*contextopts).set_autoJSAPIOwnsErrorReporting_(true); + JS_SetErrorReporter(js_runtime, Some(reportError)); JS_SetGCZeal(js_context, 0, JS_DEFAULT_ZEAL_FREQ); } @@ -81,13 +97,11 @@ impl Runtime { self.cx } - pub fn evaluate_script(&self, global: *mut JSObject, script: String, - filename: String, line_num: usize) - -> Result<(), ()> { + pub fn evaluate_script(&self, glob: *mut JSObject, script: String, filename: String, line_num: u32) + -> Result<(),()> { let script_utf16: Vec = script.utf16_units().collect(); let filename_cstr = ffi::CString::new(filename.as_bytes()).unwrap(); debug!("Evaluating script from {} with content {}", filename, script); - // SpiderMonkey does not approve of null pointers. let (ptr, len) = if script_utf16.len() == 0 { static empty: &'static [u16] = &[]; @@ -96,22 +110,25 @@ impl Runtime { (script_utf16.as_ptr(), script_utf16.len() as c_uint) }; assert!(!ptr.is_null()); + let options = CompileOptionsWrapper::new(self.cx(), filename_cstr.as_ptr(), line_num); - let mut rval: JSVal = NullValue(); - let result = unsafe { - JS_EvaluateUCScript(self.cx(), global, ptr, len, - filename_cstr.as_ptr(), line_num as c_uint, - &mut rval) - }; + let scopechain = AutoObjectVectorWrapper::new(self.cx()); + scopechain.append(glob); - if result == ERR { - debug!("...err!"); - Err(()) - } else { - // we could return the script result but then we'd have - // to root it and so forth and, really, who cares? - debug!("...ok!"); - Ok(()) + let mut rval = RootedValue::new(self.cx(), UndefinedValue()); + + unsafe { + if 0 == Evaluate3(self.cx(), scopechain.ptr, options.ptr, + ptr as *const i16, len as size_t, + rval.handle_mut()) { + debug!("...err!"); + Err(()) + } else { + // we could return the script result but then we'd have + // to root it and so forth and, really, who cares? + debug!("...ok!"); + Ok(()) + } } } } @@ -120,11 +137,515 @@ impl Drop for Runtime { fn drop(&mut self) { unsafe { JS_DestroyContext(self.cx); - JS_Finish(self.rt); + JS_DestroyRuntime(self.rt); + } + } +} + +// ___________________________________________________________________________ +// Rooting API for standard JS things + +trait RootKind { + fn rootKind() -> ThingRootKind; +} + +impl RootKind for *mut JSObject { + fn rootKind() -> ThingRootKind { ThingRootKind::THING_ROOT_OBJECT } +} + +impl RootKind for *mut JSFlatString { + fn rootKind() -> ThingRootKind { ThingRootKind::THING_ROOT_STRING } +} + +impl RootKind for *mut JSFunction { + fn rootKind() -> ThingRootKind { ThingRootKind::THING_ROOT_OBJECT } +} + +impl RootKind for *mut JSString { + fn rootKind() -> ThingRootKind { ThingRootKind::THING_ROOT_STRING } +} + +impl RootKind for *mut Symbol { + fn rootKind() -> ThingRootKind { ThingRootKind::THING_ROOT_OBJECT } +} + +impl RootKind for *mut JSScript { + fn rootKind() -> ThingRootKind { ThingRootKind::THING_ROOT_SCRIPT } +} + +impl RootKind for jsid { + fn rootKind() -> ThingRootKind { ThingRootKind::THING_ROOT_ID } +} + +impl RootKind for Value { + fn rootKind() -> ThingRootKind { ThingRootKind::THING_ROOT_VALUE } +} + +impl Rooted { + pub fn new(cx: *mut JSContext, initial: T) -> Rooted { + let ctxfriend: &mut ContextFriendFields = unsafe { + mem::transmute(cx) + }; + + let kind = T::rootKind() as usize; + let root = Rooted:: { + stack: &mut ctxfriend.thingGCRooters[kind], + prev: ctxfriend.thingGCRooters[kind], + ptr: initial, + }; + + ctxfriend.thingGCRooters[kind] = unsafe { mem::transmute(return_address()) }; + root + } + + pub fn handle(&self) -> Handle { + Handle:: { + ptr: &self.ptr + } + } + + pub fn handle_mut(&mut self) -> MutableHandle { + MutableHandle:: { + ptr: &mut self.ptr + } + } +} + +impl Handle { + pub fn get(&self) -> T { + unsafe { *self.ptr } + } +} + +impl HandleValue { + pub fn null() -> HandleValue { + HandleValue { + ptr: &JSVAL_NULL + } + } + + pub fn undefined() -> HandleValue { + HandleValue { + ptr: &JSVAL_VOID + } + } +} + +impl MutableHandle { + pub fn get(&self) -> T { + unsafe { *self.ptr } + } + + pub fn set(&mut self, v: T) { + unsafe { *self.ptr = v } + } +} + +impl Drop for Rooted { + fn drop(&mut self) { + unsafe { + assert!(*self.stack == mem::transmute(&*self)); + *self.stack = self.prev; + } + } +} + +impl Default for jsid { + fn default() -> jsid { JSID_VOID } +} + +impl Default for Value { + fn default() -> Value { UndefinedValue() } +} + +const ChunkShift: usize = 20; +const ChunkSize: usize = 1 << ChunkShift; +const ChunkMask: usize = ChunkSize - 1; + +#[cfg(target_pointer_width = "32")] +const ChunkLocationOffset: usize = ChunkSize - 2 * 4 - 8; + +#[cfg(target_pointer_width = "64")] +const ChunkLocationOffset: usize = ChunkSize - 2 * 8 - 8; + +const ChunkLocationBitNursery: usize = 1; + +fn IsInsideNursery(p: *mut Cell) -> bool { + if p.is_null() { + return false; + } + + let mut addr: usize = unsafe { mem::transmute(p) }; + addr = (addr & !ChunkMask) | ChunkLocationOffset; + + let location: *const u32 = unsafe { mem::transmute(addr) }; + let location = unsafe { *location }; + assert!(location != 0); + (location & ChunkLocationBitNursery as u32) != 0 +} + +pub trait GCMethods { + fn needs_post_barrier(v: T) -> bool; + unsafe fn post_barrier(v: *mut T); + unsafe fn relocate(v: *mut T); +} + +impl GCMethods for jsid { + fn needs_post_barrier(_: jsid) -> bool { return false; } + unsafe fn post_barrier(_: *mut jsid) { unreachable!() } + unsafe fn relocate(_: *mut jsid) { unreachable!() } +} + +impl GCMethods<*mut JSObject> for *mut JSObject { + fn needs_post_barrier(v: *mut JSObject) -> bool { + return unsafe { IsInsideNursery(mem::transmute(v)) }; + } + unsafe fn post_barrier(v: *mut *mut JSObject) { + HeapCellPostBarrier(mem::transmute(v)); + } + unsafe fn relocate(v: *mut *mut JSObject) { + HeapCellRelocate(mem::transmute(v)); + } +} + +impl GCMethods<*mut JSString> for *mut JSString { + fn needs_post_barrier(v: *mut JSString) -> bool { + return unsafe { IsInsideNursery(mem::transmute(v)) }; + } + unsafe fn post_barrier(v: *mut *mut JSString) { + HeapCellPostBarrier(mem::transmute(v)); + } + unsafe fn relocate(v: *mut *mut JSString) { + HeapCellRelocate(mem::transmute(v)); + } +} + +impl GCMethods<*mut JSScript> for *mut JSScript { + fn needs_post_barrier(v: *mut JSScript) -> bool { + return unsafe { IsInsideNursery(mem::transmute(v)) }; + } + unsafe fn post_barrier(v: *mut *mut JSScript) { + HeapCellPostBarrier(mem::transmute(v)); + } + unsafe fn relocate(v: *mut *mut JSScript) { + HeapCellRelocate(mem::transmute(v)); + } +} + +impl GCMethods<*mut JSFunction> for *mut JSFunction { + fn needs_post_barrier(v: *mut JSFunction) -> bool { + return unsafe { IsInsideNursery(mem::transmute(v)) }; + } + unsafe fn post_barrier(v: *mut *mut JSFunction) { + HeapCellPostBarrier(mem::transmute(v)); + } + unsafe fn relocate(v: *mut *mut JSFunction) { + HeapCellRelocate(mem::transmute(v)); + } +} + +impl GCMethods for Value { + fn needs_post_barrier(v: Value) -> bool { + return v.is_object() && + unsafe { IsInsideNursery(mem::transmute(v.to_object())) }; + } + unsafe fn post_barrier(v: *mut Value) { + HeapValuePostBarrier(v); + } + unsafe fn relocate(v: *mut Value) { + HeapValueRelocate(v); + } +} + +impl + Copy> Heap { + pub fn set(&mut self, v: T) { + if T::needs_post_barrier(v) { + self.ptr = v; + unsafe { T::post_barrier(&mut self.ptr) }; + } else if T::needs_post_barrier(self.ptr) { + unsafe { T::relocate(&mut self.ptr) }; + self.ptr = v; + } else { + self.ptr = v; + } + } + + pub fn get(&self) -> T { + self.ptr + } +} + +// XXX derive Default instead? +impl + Copy> Default for Heap { + fn default() -> Heap { + Heap:: { + ptr: T::default() + } + } +} + +impl + Copy> Drop for Heap { + fn drop(&mut self) { + if T::needs_post_barrier(self.ptr) { + unsafe { T::relocate(&mut self.ptr) }; + } + } +} + + +// ___________________________________________________________________________ +// Implementations for various things in jsapi.rs + +impl JSAutoRequest { + pub fn new(cx: *mut JSContext) -> JSAutoRequest { + unsafe { JS_BeginRequest(cx); } + JSAutoRequest { + mContext: cx + } + } +} + +impl Drop for JSAutoRequest { + fn drop(&mut self) { + unsafe { JS_EndRequest(self.mContext); } + } +} + +impl JSAutoCompartment { + pub fn new(cx: *mut JSContext, target: *mut JSObject) -> JSAutoCompartment { + JSAutoCompartment { + cx_: cx, + oldCompartment_: unsafe { JS_EnterCompartment(cx, target) } + } + } +} + +impl Drop for JSAutoCompartment { + fn drop(&mut self) { + unsafe { JS_LeaveCompartment(self.cx_, self.oldCompartment_); } + } +} + +impl JSJitMethodCallArgs { + pub fn get(&self, i: u32) -> HandleValue { + assert!(i < self.argc_); + HandleValue { + ptr: unsafe { self.argv_.offset(i as isize) } + } + } + + pub fn get_mut(&self, i: u32) -> MutableHandleValue { + assert!(i < self.argc_); + MutableHandleValue { + ptr: unsafe { self.argv_.offset(i as isize) } + } + } + + pub fn rval(&self) -> MutableHandleValue { + MutableHandleValue { + ptr: unsafe { self.argv_.offset(-2) } } } } +// XXX need to hack up bindgen to convert this better so we don't have +// to duplicate so much code here +impl CallArgs { + pub fn from_vp(vp: *mut Value, argc: u32) -> CallArgs { + CallArgs { + argv_: unsafe { vp.offset(2) }, + argc_: argc + } + } + + pub fn get(&self, i: u32) -> HandleValue { + assert!(i < self.argc_); + HandleValue { + ptr: unsafe { self.argv_.offset(i as isize) } + } + } + + pub fn get_mut(&self, i: u32) -> MutableHandleValue { + assert!(i < self.argc_); + MutableHandleValue { + ptr: unsafe { self.argv_.offset(i as isize) } + } + } + + pub fn rval(&self) -> MutableHandleValue { + MutableHandleValue { + ptr: unsafe { self.argv_.offset(-2) } + } + } +} + +impl JSJitGetterCallArgs { + pub fn rval(&self) -> MutableHandleValue { + self._base + } +} + +impl JSJitSetterCallArgs { + pub fn get(&self, i: u32) -> HandleValue { + assert!(i == 0); + self._base + } +} + +// ___________________________________________________________________________ +// Wrappers around things in jsglue.cpp + +pub struct AutoObjectVectorWrapper { + pub ptr: *mut AutoObjectVector +} + +impl AutoObjectVectorWrapper { + pub fn new(cx: *mut JSContext) -> AutoObjectVectorWrapper { + AutoObjectVectorWrapper { + ptr: unsafe { + CreateAutoObjectVector(cx) + } + } + } + + pub fn append(&self, obj: *mut JSObject) -> bool { + unsafe { + AppendToAutoObjectVector(self.ptr, obj) != 0 + } + } +} + +impl Drop for AutoObjectVectorWrapper { + fn drop(&mut self) { + unsafe { DeleteAutoObjectVector(self.ptr) } + } +} + +pub struct CompileOptionsWrapper { + pub ptr: *mut ReadOnlyCompileOptions +} + +impl CompileOptionsWrapper { + pub fn new(cx: *mut JSContext, file: *const i8, line: c_uint) -> CompileOptionsWrapper { + CompileOptionsWrapper { + ptr: unsafe { NewCompileOptions(cx, file, line) } + } + } +} + +impl Drop for CompileOptionsWrapper { + fn drop(&mut self) { + unsafe { DeleteCompileOptions(self.ptr) } + } +} + +// ___________________________________________________________________________ +// Fast inline converters + +#[inline] +pub fn ToBoolean(v: HandleValue) -> bool { + let val = unsafe { *v.ptr }; + + if val.is_boolean() { + return val.to_boolean(); + } + + if val.is_int32() { + return val.to_int32() != 0; + } + + if val.is_null_or_undefined() { + return false; + } + + if val.is_double() { + let d = val.to_double(); + return !d.is_nan() && d != 0f64; + } + + if val.is_symbol() { + return true; + } + + unsafe { ToBooleanSlow(v) != 0 } +} + +#[inline] +pub fn ToNumber(cx: *mut JSContext, v: HandleValue) -> Result { + let val = unsafe { *v.ptr }; + if val.is_number() { + return Ok(val.to_number()); + } + + let mut out = Default::default(); + unsafe { + if ToNumberSlow(cx, val, &mut out) == 0 { + Err(()) + } else { + Ok(out) + } + } +} + +#[inline] +fn convert_from_int32( + cx: *mut JSContext, + v: HandleValue, + conv_fn: unsafe extern "C" fn(*mut JSContext, HandleValue, *mut T) -> u8) + -> Result { + + let val = unsafe { *v.ptr }; + if val.is_int32() { + return Ok(T::from(val.to_int32()).unwrap()); + } + + let mut out = Default::default(); + unsafe { + if conv_fn(cx, v, &mut out) == 0 { + Err(()) + } else { + Ok(out) + } + } +} + +#[inline] +pub fn ToInt32(cx: *mut JSContext, v: HandleValue) -> Result { + convert_from_int32::(cx, v, ToInt32Slow) +} + +#[inline] +pub fn ToUint32(cx: *mut JSContext, v: HandleValue) -> Result { + convert_from_int32::(cx, v, ToUint32Slow) +} + +#[inline] +pub fn ToUint16(cx: *mut JSContext, v: HandleValue) -> Result { + convert_from_int32::(cx, v, ToUint16Slow) +} + +#[inline] +pub fn ToInt64(cx: *mut JSContext, v: HandleValue) -> Result { + convert_from_int32::(cx, v, ToInt64Slow) +} + +#[inline] +pub fn ToUint64(cx: *mut JSContext, v: HandleValue) -> Result { + convert_from_int32::(cx, v, ToUint64Slow) +} + +#[inline] +pub fn ToString(cx: *mut JSContext, v: HandleValue) -> *mut JSString { + let val = unsafe { *v.ptr }; + if val.is_string() { + return val.to_string(); + } + + unsafe { + ToStringSlow(cx, v) + } +} + pub unsafe extern fn reportError(_cx: *mut JSContext, msg: *const c_char, report: *mut JSErrorReport) { let fnptr = (*report).filename; let fname = if !fnptr.is_null() { @@ -139,15 +660,6 @@ pub unsafe extern fn reportError(_cx: *mut JSContext, msg: *const c_char, report error!("Error at {}:{}: {}\n", fname, lineno, msg); } -pub fn with_compartment R>(cx: *mut JSContext, object: *mut JSObject, mut cb: F) -> R { - unsafe { - let call = JS_EnterCrossCompartmentCall(cx, object); - let result = cb(); - JS_LeaveCrossCompartmentCall(call); - result - } -} - #[cfg(test)] pub mod test { use super::Runtime; From b4df2606d5aab33e82812bda4871cb7ba419decc Mon Sep 17 00:00:00 2001 From: Michael Wu Date: Sat, 16 May 2015 23:24:16 -0400 Subject: [PATCH 2/2] Don't set gc zeal by default --- src/rust.rs | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/src/rust.rs b/src/rust.rs index 93057d940..f07b9ef0c 100644 --- a/src/rust.rs +++ b/src/rust.rs @@ -18,7 +18,7 @@ use jsapi::{JS_NewContext, JS_DestroyContext, JS_NewRuntime, JS_DestroyRuntime}; use jsapi::{JSContext, JSRuntime, JSObject, JSFlatString, JSFunction, JSString, Symbol, JSScript, jsid, Value}; use jsapi::{RuntimeOptionsRef, ContextOptionsRef, ReadOnlyCompileOptions}; use jsapi::{JS_SetErrorReporter, Evaluate3, JSErrorReport}; -use jsapi::{JS_SetGCParameter, JS_SetGCZeal, JSGCParamKey}; +use jsapi::{JS_SetGCParameter, JSGCParamKey}; use jsapi::{Heap, Cell, HeapCellPostBarrier, HeapCellRelocate, HeapValuePostBarrier, HeapValueRelocate}; use jsapi::{ThingRootKind, ContextFriendFields}; use jsapi::{Rooted, RootedValue, Handle, MutableHandle, MutableHandleValue, HandleValue}; @@ -32,7 +32,6 @@ use jsapi::{JSVAL_NULL, JSVAL_VOID, JSID_VOID}; use jsval::UndefinedValue; use glue::{CreateAutoObjectVector, AppendToAutoObjectVector, DeleteAutoObjectVector}; use glue::{NewCompileOptions, DeleteCompileOptions}; -use JS_DEFAULT_ZEAL_FREQ; use default_stacksize; use default_heapsize; @@ -78,7 +77,6 @@ impl Runtime { (*contextopts).set_dontReportUncaught_(true); (*contextopts).set_autoJSAPIOwnsErrorReporting_(true); JS_SetErrorReporter(js_runtime, Some(reportError)); - JS_SetGCZeal(js_context, 0, JS_DEFAULT_ZEAL_FREQ); } Runtime {