Skip to content

Instantly share code, notes, and snippets.

@michaelwu

michaelwu/jsapi.rs

Created July 23, 2015 21:35
Show Gist options
  • Star 0 You must be signed in to star a gist
  • Fork 0 You must be signed in to fork a gist
  • Save michaelwu/a9525f07112a8224a540 to your computer and use it in GitHub Desktop.
Save michaelwu/a9525f07112a8224a540 to your computer and use it in GitHub Desktop.
Download ZIP
jsapi.rs (char fixed)
Raw
jsapi.rs
This file has been truncated, but you can view the full file.
/* automatically generated by rust-bindgen */
pub type MallocSizeOf =
::std::option::Option<unsafe extern "C" fn(p: *const ::libc::c_void)
-> size_t>;
pub type MozMallocSizeOf =
::std::option::Option<unsafe extern "C" fn(p: *const ::libc::c_void)
-> size_t>;
/**
* UniquePtr is a smart pointer that wholly owns a resource. Ownership may be
* transferred out of a UniquePtr through explicit action, but otherwise the
* resource is destroyed when the UniquePtr is destroyed.
*
* UniquePtr is similar to C++98's std::auto_ptr, but it improves upon auto_ptr
* in one crucial way: it's impossible to copy a UniquePtr. Copying an auto_ptr
* obviously *can't* copy ownership of its singly-owned resource. So what
* happens if you try to copy one? Bizarrely, ownership is implicitly
* *transferred*, preserving single ownership but breaking code that assumes a
* copy of an object is identical to the original. (This is why auto_ptr is
* prohibited in STL containers.)
*
* UniquePtr solves this problem by being *movable* rather than copyable.
* Instead of passing a |UniquePtr u| directly to the constructor or assignment
* operator, you pass |Move(u)|. In doing so you indicate that you're *moving*
* ownership out of |u|, into the target of the construction/assignment. After
* the transfer completes, |u| contains |nullptr| and may be safely destroyed.
* This preserves single ownership but also allows UniquePtr to be moved by
* algorithms that have been made move-safe. (Note: if |u| is instead a
* temporary expression, don't use |Move()|: just pass the expression, because
* it's already move-ready. For more information see Move.h.)
*
* UniquePtr is also better than std::auto_ptr in that the deletion operation is
* customizable. An optional second template parameter specifies a class that
* (through its operator()(T*)) implements the desired deletion policy. If no
* policy is specified, mozilla::DefaultDelete<T> is used -- which will either
* |delete| or |delete[]| the resource, depending whether the resource is an
* array. Custom deletion policies ideally should be empty classes (no member
* fields, no member fields in base classes, no virtual methods/inheritance),
* because then UniquePtr can be just as efficient as a raw pointer.
*
* Use of UniquePtr proceeds like so:
*
* UniquePtr<int> g1; // initializes to nullptr
* g1.reset(new int); // switch resources using reset()
* g1 = nullptr; // clears g1, deletes the int
*
* UniquePtr<int> g2(new int); // owns that int
* int* p = g2.release(); // g2 leaks its int -- still requires deletion
* delete p; // now freed
*
* struct S { int x; S(int x) : x(x) {} };
* UniquePtr<S> g3, g4(new S(5));
* g3 = Move(g4); // g3 owns the S, g4 cleared
* S* p = g3.get(); // g3 still owns |p|
* assert(g3->x == 5); // operator-> works (if .get() != nullptr)
* assert((*g3).x == 5); // also operator* (again, if not cleared)
* Swap(g3, g4); // g4 now owns the S, g3 cleared
* g3.swap(g4); // g3 now owns the S, g4 cleared
* UniquePtr<S> g5(Move(g3)); // g5 owns the S, g3 cleared
* g5.reset(); // deletes the S, g5 cleared
*
* struct FreePolicy { void operator()(void* p) { free(p); } };
* UniquePtr<int, FreePolicy> g6(static_cast<int*>(malloc(sizeof(int))));
* int* ptr = g6.get();
* g6 = nullptr; // calls free(ptr)
*
* Now, carefully note a few things you *can't* do:
*
* UniquePtr<int> b1;
* b1 = new int; // BAD: can only assign another UniquePtr
* int* ptr = b1; // BAD: no auto-conversion to pointer, use get()
*
* UniquePtr<int> b2(b1); // BAD: can't copy a UniquePtr
* UniquePtr<int> b3 = b1; // BAD: can't copy-assign a UniquePtr
*
* (Note that changing a UniquePtr to store a direct |new| expression is
* permitted, but usually you should use MakeUnique, defined at the end of this
* header.)
*
* A few miscellaneous notes:
*
* UniquePtr, when not instantiated for an array type, can be move-constructed
* and move-assigned, not only from itself but from "derived" UniquePtr<U, E>
* instantiations where U converts to T and E converts to D. If you want to use
* this, you're going to have to specify a deletion policy for both UniquePtr
* instantations, and T pretty much has to have a virtual destructor. In other
* words, this doesn't work:
*
* struct Base { virtual ~Base() {} };
* struct Derived : Base {};
*
* UniquePtr<Base> b1;
* // BAD: DefaultDelete<Base> and DefaultDelete<Derived> don't interconvert
* UniquePtr<Derived> d1(Move(b));
*
* UniquePtr<Base> b2;
* UniquePtr<Derived, DefaultDelete<Base>> d2(Move(b2)); // okay
*
* UniquePtr is specialized for array types. Specializing with an array type
* creates a smart-pointer version of that array -- not a pointer to such an
* array.
*
* UniquePtr<int[]> arr(new int[5]);
* arr[0] = 4;
*
* What else is different? Deletion of course uses |delete[]|. An operator[]
* is provided. Functionality that doesn't make sense for arrays is removed.
* The constructors and mutating methods only accept array pointers (not T*, U*
* that converts to T*, or UniquePtr<U[]> or UniquePtr<U>) or |nullptr|.
*
* It's perfectly okay to return a UniquePtr from a method to assure the related
* resource is properly deleted. You'll need to use |Move()| when returning a
* local UniquePtr. Otherwise you can return |nullptr|, or you can return
* |UniquePtr(ptr)|.
*
* UniquePtr will commonly be a member of a class, with lifetime equivalent to
* that of that class. If you want to expose the related resource, you could
* expose a raw pointer via |get()|, but ownership of a raw pointer is
* inherently unclear. So it's better to expose a |const UniquePtr&| instead.
* This prohibits mutation but still allows use of |get()| when needed (but
* operator-> is preferred). Of course, you can only use this smart pointer as
* long as the enclosing class instance remains live -- no different than if you
* exposed the |get()| raw pointer.
*
* To pass a UniquePtr-managed resource as a pointer, use a |const UniquePtr&|
* argument. To specify an inout parameter (where the method may or may not
* take ownership of the resource, or reset it), or to specify an out parameter
* (where simply returning a |UniquePtr| isn't possible), use a |UniquePtr&|
* argument. To unconditionally transfer ownership of a UniquePtr
* into a method, use a |UniquePtr| argument. To conditionally transfer
* ownership of a resource into a method, should the method want it, use a
* |UniquePtr&&| argument.
*/
#[repr(C)]
#[derive(Copy)]
pub struct UniquePtr<T, D> {
pub mTuple: Pair,
}
/** A default deletion policy using plain old operator delete. */
#[repr(C)]
#[derive(Copy)]
pub struct DefaultDelete<T>;
#[repr(C)]
#[derive(Copy)]
pub struct UniqueSelector<T>;
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<jsid>;
pub type HandleObject = Handle<*mut JSObject>;
pub type HandleScript = Handle<*mut JSScript>;
pub enum Handle { }
pub type HandleString = Handle<*mut JSString>;
pub type HandleSymbol = Handle<*mut Symbol>;
pub type HandleValue = Handle<Value>;
pub type MutableHandleFunction = MutableHandle<*mut JSFunction>;
pub type MutableHandleId = MutableHandle<jsid>;
pub type MutableHandleObject = MutableHandle<*mut JSObject>;
pub type MutableHandleScript = MutableHandle<*mut JSScript>;
pub enum MutableHandle { }
pub type MutableHandleString = MutableHandle<*mut JSString>;
pub type MutableHandleSymbol = MutableHandle<*mut Symbol>;
pub type MutableHandleValue = MutableHandle<Value>;
pub type RootedObject = Rooted<*mut JSObject>;
pub type RootedFunction = Rooted<*mut JSFunction>;
pub enum Rooted { }
pub type RootedScript = Rooted<*mut JSScript>;
pub type RootedString = Rooted<*mut JSString>;
pub type RootedSymbol = Rooted<*mut Symbol>;
pub type RootedId = Rooted<jsid>;
pub type RootedValue = Rooted<Value>;
pub type PersistentRootedFunction = PersistentRooted<*mut JSFunction>;
pub enum PersistentRooted { }
pub type PersistentRootedId = PersistentRooted<jsid>;
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<Value>;
#[repr(C)]
#[derive(Copy)]
pub struct ScopedFreePtrTraits<T>;
#[repr(C)]
#[derive(Copy)]
pub struct ScopedJSFreePtr<Type> {
pub _base: Scoped,
}
#[repr(C)]
#[derive(Copy)]
pub struct ScopedDeletePtrTraits<T> {
pub _base: ScopedFreePtrTraits<T>,
}
#[repr(C)]
#[derive(Copy)]
pub struct ScopedJSDeletePtr<Type> {
pub _base: Scoped,
}
#[repr(C)]
#[derive(Copy)]
pub struct ScopedReleasePtrTraits<T> {
pub _base: ScopedFreePtrTraits<T>,
}
#[repr(C)]
#[derive(Copy)]
pub struct ScopedReleasePtr<Type> {
pub _base: Scoped,
}
#[repr(C)]
#[derive(Copy)]
pub struct DeletePolicy<T>;
#[repr(C)]
#[derive(Copy)]
pub struct FreePolicy;
impl ::std::default::Default for FreePolicy {
fn default() -> FreePolicy { unsafe { ::std::mem::zeroed() } }
}
pub type HashNumber = u32;
pub type UniqueChars = UniquePtr<::libc::c_char, FreePolicy>;
#[repr(i32)]
#[derive(Copy)]
pub enum AllocFunction { Malloc = 0, Calloc = 1, Realloc = 2, }
#[repr(C)]
#[derive(Copy)]
pub struct SystemAllocPolicy;
impl ::std::default::Default for SystemAllocPolicy {
fn default() -> SystemAllocPolicy { unsafe { ::std::mem::zeroed() } }
}
extern "C" {
fn _ZN2js17SystemAllocPolicy5free_EPv(this: *mut SystemAllocPolicy,
p: *mut ::libc::c_void);
fn _ZNK2js17SystemAllocPolicy19reportAllocOverflowEv(this:
*mut SystemAllocPolicy);
}
impl SystemAllocPolicy {
#[inline]
pub unsafe extern "C" fn free_(&mut self, p: *mut ::libc::c_void) {
_ZN2js17SystemAllocPolicy5free_EPv(&mut *self, p)
}
#[inline]
pub unsafe extern "C" fn reportAllocOverflow(&mut self) {
_ZNK2js17SystemAllocPolicy19reportAllocOverflowEv(&mut *self)
}
}
#[repr(C)]
#[derive(Copy)]
pub struct TempAllocPolicy {
pub cx_: *mut ContextFriendFields,
}
impl ::std::default::Default for TempAllocPolicy {
fn default() -> TempAllocPolicy { unsafe { ::std::mem::zeroed() } }
}
extern "C" {
fn _ZN2js15TempAllocPolicy13onOutOfMemoryENS_13AllocFunctionEjPv(this:
*mut TempAllocPolicy,
allocFunc:
AllocFunction,
nbytes:
size_t,
reallocPtr:
*mut ::libc::c_void)
-> *mut ::libc::c_void;
fn _ZN2js15TempAllocPolicy5free_EPv(this: *mut TempAllocPolicy,
p: *mut ::libc::c_void);
fn _ZNK2js15TempAllocPolicy19reportAllocOverflowEv(this:
*mut TempAllocPolicy);
}
impl TempAllocPolicy {
#[inline]
pub unsafe extern "C" fn onOutOfMemory(&mut self,
allocFunc: AllocFunction,
nbytes: size_t,
reallocPtr: *mut ::libc::c_void)
-> *mut ::libc::c_void {
_ZN2js15TempAllocPolicy13onOutOfMemoryENS_13AllocFunctionEjPv(&mut *self,
allocFunc,
nbytes,
reallocPtr)
}
#[inline]
pub unsafe extern "C" fn free_(&mut self, p: *mut ::libc::c_void) {
_ZN2js15TempAllocPolicy5free_EPv(&mut *self, p)
}
#[inline]
pub unsafe extern "C" fn reportAllocOverflow(&mut self) {
_ZNK2js15TempAllocPolicy19reportAllocOverflowEv(&mut *self)
}
}
#[repr(C)]
#[derive(Copy)]
pub struct LinkedListElement<T> {
pub mNext: *mut LinkedListElement,
pub mPrev: *mut LinkedListElement,
pub mIsSentinel: bool,
}
#[repr(i32)]
#[derive(Copy)]
pub enum LinkedListElement_NodeKind {
NODE_KIND_NORMAL = 0,
NODE_KIND_SENTINEL = 0,
}
#[repr(C)]
#[derive(Copy)]
pub struct LinkedList<T> {
pub sentinel: LinkedListElement<T>,
}
#[repr(C)]
#[derive(Copy)]
pub struct AutoCleanLinkedList<T> {
pub _base: LinkedList<T>,
}
pub type AutoIdVector = AutoVectorRooter<jsid>;
pub enum AutoVectorRooter { }
pub enum Zone { }
pub enum Shape { }
#[repr(i32)]
#[derive(Copy)]
pub enum JSVersion {
JSVERSION_ECMA_3 = 148,
JSVERSION_1_6 = 160,
JSVERSION_1_7 = 170,
JSVERSION_1_8 = 180,
JSVERSION_ECMA_5 = 185,
JSVERSION_DEFAULT = 0,
JSVERSION_UNKNOWN = -1,
JSVERSION_LATEST = 185,
}
#[repr(i32)]
#[derive(Copy)]
pub enum JSType {
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(i32)]
#[derive(Copy)]
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_Reflect = 55,
JSProto_LIMIT = 56,
}
pub enum JSCompartment { }
pub enum JSCrossCompartmentCall { }
pub enum JSExceptionState { }
pub enum JSIdArray { }
pub enum JSObjectMap { }
pub enum JSPropertyName { }
pub enum JSRuntime { }
pub enum JSStructuredCloneCallbacks { }
pub enum JSStructuredCloneReader { }
pub enum JSStructuredCloneWriter { }
pub enum JSFlatString { }
pub enum PRCallOnceType { }
pub type JSCallOnceType = PRCallOnceType;
pub type JSInitCallback =
::std::option::Option<unsafe extern "C" fn() -> bool>;
pub type JSConstDoubleSpec = JSConstScalarSpec;
pub enum JSConstScalarSpec { }
pub type JSConstIntegerSpec = JSConstScalarSpec;
pub type JSTraceDataOp =
::std::option::Option<unsafe extern "C" fn(trc: *mut JSTracer,
data: *mut ::libc::c_void)>;
pub enum AutoTraceSession { }
pub enum StoreBuffer { }
pub type OffThreadCompileCallback =
::std::option::Option<unsafe extern "C" fn(token: *mut ::libc::c_void,
callbackData:
*mut ::libc::c_void)>;
#[repr(i32)]
#[derive(Copy)]
pub enum HeapState {
Idle = 0,
Tracing = 1,
MajorCollecting = 2,
MinorCollecting = 3,
}
#[repr(C)]
#[derive(Copy)]
pub struct Runtime {
pub heapState_: HeapState,
pub gcStoreBufferPtr_: *mut StoreBuffer,
pub functionPersistentRooteds: LinkedList<PersistentRooted<*mut JSFunction>>,
pub idPersistentRooteds: LinkedList<PersistentRooted<jsid>>,
pub objectPersistentRooteds: LinkedList<PersistentRooted<*mut JSObject>>,
pub scriptPersistentRooteds: LinkedList<PersistentRooted<*mut JSScript>>,
pub stringPersistentRooteds: LinkedList<PersistentRooted<*mut JSString>>,
pub valuePersistentRooteds: LinkedList<PersistentRooted<Value>>,
}
impl ::std::default::Default for Runtime {
fn default() -> Runtime { unsafe { ::std::mem::zeroed() } }
}
extern "C" {
fn _ZNK2JS6shadow7Runtime10isHeapBusyEv(this: *mut Runtime) -> bool;
fn _ZN2JS6shadow7Runtime16gcStoreBufferPtrEv(this: *mut Runtime)
-> *mut StoreBuffer;
fn _ZN2JS6shadow7Runtime15asShadowRuntimeEP9JSRuntime(rt: *mut JSRuntime)
-> *mut Runtime;
fn _ZN2JS6shadow7Runtime19setGCStoreBufferPtrEPN2js2gc11StoreBufferE(this:
*mut Runtime,
storeBuffer:
*mut StoreBuffer);
}
impl Runtime {
#[inline]
pub unsafe extern "C" fn isHeapBusy(&mut self) -> bool {
_ZNK2JS6shadow7Runtime10isHeapBusyEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn gcStoreBufferPtr(&mut self) -> *mut StoreBuffer {
_ZN2JS6shadow7Runtime16gcStoreBufferPtrEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn asShadowRuntime(rt: *mut JSRuntime)
-> *mut Runtime {
_ZN2JS6shadow7Runtime15asShadowRuntimeEP9JSRuntime(rt)
}
#[inline]
pub unsafe extern "C" fn setGCStoreBufferPtr(&mut self,
storeBuffer:
*mut StoreBuffer) {
_ZN2JS6shadow7Runtime19setGCStoreBufferPtrEPN2js2gc11StoreBufferE(&mut *self,
storeBuffer)
}
}
#[repr(C)]
#[derive(Copy)]
pub struct AutoGCRooter {
pub down: *mut AutoGCRooter,
pub tag_: ptrdiff_t,
pub stackTop: *mut *mut AutoGCRooter,
}
impl ::std::default::Default for AutoGCRooter {
fn default() -> AutoGCRooter { unsafe { ::std::mem::zeroed() } }
}
#[repr(i32)]
#[derive(Copy)]
pub enum AutoGCRooter_ {
VALARRAY = -2,
PARSER = -3,
SHAPEVECTOR = -4,
IDARRAY = -6,
DESCVECTOR = -7,
VALVECTOR = -10,
IDVECTOR = -11,
IDVALVECTOR = -12,
OBJVECTOR = -14,
STRINGVECTOR = -15,
SCRIPTVECTOR = -16,
NAMEVECTOR = -17,
HASHABLEVALUE = -18,
IONMASM = -19,
WRAPVECTOR = -20,
WRAPPER = -21,
OBJU32HASHMAP = -23,
JSONPARSER = -25,
CUSTOM = -26,
}
extern "C" {
fn _ZN2JS12AutoGCRooter5traceEP8JSTracer(this: *mut AutoGCRooter,
trc: *mut JSTracer);
fn _ZN2JS12AutoGCRooter8traceAllEP8JSTracer(trc: *mut JSTracer);
fn _ZN2JS12AutoGCRooter16traceAllWrappersEP8JSTracer(trc: *mut JSTracer);
fn _ZN2JS12AutoGCRooter6GetTagERKNS_5ValueE(value: &Value) -> ptrdiff_t;
fn _ZN2JS12AutoGCRooter6GetTagERK4jsid(id: &jsid) -> ptrdiff_t;
fn _ZN2JS12AutoGCRooter6GetTagEP8JSObject(obj: *mut JSObject)
-> ptrdiff_t;
fn _ZN2JS12AutoGCRooter6GetTagEP8JSScript(script: *mut JSScript)
-> ptrdiff_t;
fn _ZN2JS12AutoGCRooter6GetTagEP8JSString(string: *mut JSString)
-> ptrdiff_t;
fn _ZN2JS12AutoGCRooter6GetTagEPN2js5ShapeE(shape: *mut Shape)
-> ptrdiff_t;
fn _ZN2JS12AutoGCRooter6GetTagERK20JSPropertyDescriptor(pd:
&JSPropertyDescriptor)
-> ptrdiff_t;
}
impl AutoGCRooter {
#[inline]
pub unsafe extern "C" fn trace(&mut self, trc: *mut JSTracer) {
_ZN2JS12AutoGCRooter5traceEP8JSTracer(&mut *self, trc)
}
#[inline]
pub unsafe extern "C" fn traceAll(trc: *mut JSTracer) {
_ZN2JS12AutoGCRooter8traceAllEP8JSTracer(trc)
}
#[inline]
pub unsafe extern "C" fn traceAllWrappers(trc: *mut JSTracer) {
_ZN2JS12AutoGCRooter16traceAllWrappersEP8JSTracer(trc)
}
#[inline]
pub unsafe extern "C" fn GetTag(value: &Value) -> ptrdiff_t {
_ZN2JS12AutoGCRooter6GetTagERKNS_5ValueE(value)
}
#[inline]
pub unsafe extern "C" fn GetTag1(id: &jsid) -> ptrdiff_t {
_ZN2JS12AutoGCRooter6GetTagERK4jsid(id)
}
#[inline]
pub unsafe extern "C" fn GetTag2(obj: *mut JSObject) -> ptrdiff_t {
_ZN2JS12AutoGCRooter6GetTagEP8JSObject(obj)
}
#[inline]
pub unsafe extern "C" fn GetTag3(script: *mut JSScript) -> ptrdiff_t {
_ZN2JS12AutoGCRooter6GetTagEP8JSScript(script)
}
#[inline]
pub unsafe extern "C" fn GetTag4(string: *mut JSString) -> ptrdiff_t {
_ZN2JS12AutoGCRooter6GetTagEP8JSString(string)
}
#[inline]
pub unsafe extern "C" fn GetTag5(shape: *mut Shape) -> ptrdiff_t {
_ZN2JS12AutoGCRooter6GetTagEPN2js5ShapeE(shape)
}
#[inline]
pub unsafe extern "C" fn GetTag6(pd: &JSPropertyDescriptor) -> ptrdiff_t {
_ZN2JS12AutoGCRooter6GetTagERK20JSPropertyDescriptor(pd)
}
}
pub enum ExclusiveContext { }
#[repr(i32)]
#[derive(Copy)]
pub enum StackKind {
StackForSystemCode = 0,
StackForTrustedScript = 1,
StackForUntrustedScript = 2,
StackKindCount = 3,
}
#[repr(i32)]
#[derive(Copy)]
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_PROPERTY_DESCRIPTOR = 11,
THING_ROOT_PROP_DESC = 12,
THING_ROOT_STATIC_TRACEABLE = 13,
THING_ROOT_DYNAMIC_TRACEABLE = 14,
THING_ROOT_LIMIT = 15,
}
#[repr(C)]
#[derive(Copy)]
pub struct SpecificRootKind<T>;
#[repr(C)]
#[derive(Copy)]
pub struct RootKind {
pub _base: SpecificRootKind,
}
impl ::std::default::Default for RootKind {
fn default() -> RootKind { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct RootLists {
pub stackRoots_: [*mut Rooted<*mut ::libc::c_void>; 15usize],
pub autoGCRooters_: *mut AutoGCRooter,
}
impl ::std::default::Default for RootLists {
fn default() -> RootLists { unsafe { ::std::mem::zeroed() } }
}
extern "C" {
fn _ZN2js9RootLists16checkNoGCRootersEv(this: *mut RootLists);
}
impl RootLists {
#[inline]
pub unsafe extern "C" fn checkNoGCRooters(&mut self) {
_ZN2js9RootLists16checkNoGCRootersEv(&mut *self)
}
}
#[repr(C)]
#[derive(Copy)]
pub struct ContextFriendFields {
pub runtime_: *mut JSRuntime,
pub compartment_: *mut JSCompartment,
pub zone_: *mut Zone,
pub roots: RootLists,
}
impl ::std::default::Default for ContextFriendFields {
fn default() -> ContextFriendFields { unsafe { ::std::mem::zeroed() } }
}
extern "C" {
fn _ZN2js19ContextFriendFields3getEPK9JSContext(cx: *const JSContext)
-> *const ContextFriendFields;
fn _ZN2js19ContextFriendFields3getEP9JSContext(cx: *mut JSContext)
-> *mut ContextFriendFields;
}
impl ContextFriendFields {
#[inline]
pub unsafe extern "C" fn get(cx: *const JSContext)
-> *const ContextFriendFields {
_ZN2js19ContextFriendFields3getEPK9JSContext(cx)
}
#[inline]
pub unsafe extern "C" fn get1(cx: *mut JSContext)
-> *mut ContextFriendFields {
_ZN2js19ContextFriendFields3getEP9JSContext(cx)
}
}
pub enum PerThreadData { }
#[repr(C)]
#[derive(Copy)]
pub struct PerThreadDataFriendFields {
pub roots: RootLists,
pub nativeStackLimit: [uintptr_t; 3usize],
}
impl ::std::default::Default for PerThreadDataFriendFields {
fn default() -> PerThreadDataFriendFields {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Copy)]
pub struct RuntimeDummy {
pub _base: Runtime,
pub mainThread: PerThreadDummy,
}
impl ::std::default::Default for RuntimeDummy {
fn default() -> RuntimeDummy { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct PerThreadDummy {
pub field1: *mut ::libc::c_void,
pub field2: uintptr_t,
}
impl ::std::default::Default for PerThreadDummy {
fn default() -> PerThreadDummy { unsafe { ::std::mem::zeroed() } }
}
extern "C" {
fn _ZN2js25PerThreadDataFriendFields3getEPNS_13PerThreadDataE(pt:
*mut PerThreadData)
-> *mut PerThreadDataFriendFields;
fn _ZN2js25PerThreadDataFriendFields13getMainThreadEP9JSRuntime(rt:
*mut JSRuntime)
-> *mut PerThreadDataFriendFields;
fn _ZN2js25PerThreadDataFriendFields13getMainThreadEPK9JSRuntime(rt:
*const JSRuntime)
-> *const PerThreadDataFriendFields;
}
impl PerThreadDataFriendFields {
#[inline]
pub unsafe extern "C" fn get(pt: *mut PerThreadData)
-> *mut PerThreadDataFriendFields {
_ZN2js25PerThreadDataFriendFields3getEPNS_13PerThreadDataE(pt)
}
#[inline]
pub unsafe extern "C" fn getMainThread(rt: *mut JSRuntime)
-> *mut PerThreadDataFriendFields {
_ZN2js25PerThreadDataFriendFields13getMainThreadEP9JSRuntime(rt)
}
#[inline]
pub unsafe extern "C" fn getMainThread1(rt: *const JSRuntime)
-> *const PerThreadDataFriendFields {
_ZN2js25PerThreadDataFriendFields13getMainThreadEPK9JSRuntime(rt)
}
}
#[repr(i32)]
#[derive(Copy)]
pub enum TraceKind {
Object = 0,
String = 1,
Symbol = 2,
Script = 3,
Shape = 4,
ObjectGroup = 5,
Null = 6,
BaseShape = 15,
JitCode = 31,
LazyScript = 47,
}
pub enum Cell { }
#[repr(C)]
#[derive(Copy)]
pub struct Zone {
pub runtime_: *mut JSRuntime,
pub barrierTracer_: *mut JSTracer,
pub needsIncrementalBarrier_: bool,
}
impl ::std::default::Default for Zone {
fn default() -> Zone { unsafe { ::std::mem::zeroed() } }
}
extern "C" {
fn _ZNK2JS6shadow4Zone23needsIncrementalBarrierEv(this: *mut Zone)
-> bool;
fn _ZN2JS6shadow4Zone13barrierTracerEv(this: *mut Zone) -> *mut JSTracer;
fn _ZNK2JS6shadow4Zone21runtimeFromMainThreadEv(this: *mut Zone)
-> *mut JSRuntime;
fn _ZNK2JS6shadow4Zone20runtimeFromAnyThreadEv(this: *mut Zone)
-> *mut JSRuntime;
fn _ZN2JS6shadow4Zone12asShadowZoneEPNS_4ZoneE(zone: *mut Zone)
-> *mut Zone;
}
impl Zone {
#[inline]
pub unsafe extern "C" fn needsIncrementalBarrier(&mut self) -> bool {
_ZNK2JS6shadow4Zone23needsIncrementalBarrierEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn barrierTracer(&mut self) -> *mut JSTracer {
_ZN2JS6shadow4Zone13barrierTracerEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn runtimeFromMainThread(&mut self)
-> *mut JSRuntime {
_ZNK2JS6shadow4Zone21runtimeFromMainThreadEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn runtimeFromAnyThread(&mut self)
-> *mut JSRuntime {
_ZNK2JS6shadow4Zone20runtimeFromAnyThreadEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn asShadowZone(zone: *mut Zone) -> *mut Zone {
_ZN2JS6shadow4Zone12asShadowZoneEPNS_4ZoneE(zone)
}
}
#[repr(C)]
#[derive(Copy)]
pub struct GCCellPtr {
pub ptr: uintptr_t,
}
impl ::std::default::Default for GCCellPtr {
fn default() -> GCCellPtr { unsafe { ::std::mem::zeroed() } }
}
extern "C" {
fn _ZNK2JS9GCCellPtr4kindEv(this: *mut GCCellPtr) -> TraceKind;
fn _ZNK2JS9GCCellPtr8isObjectEv(this: *mut GCCellPtr) -> bool;
fn _ZNK2JS9GCCellPtr8isScriptEv(this: *mut GCCellPtr) -> bool;
fn _ZNK2JS9GCCellPtr8isStringEv(this: *mut GCCellPtr) -> bool;
fn _ZNK2JS9GCCellPtr8isSymbolEv(this: *mut GCCellPtr) -> bool;
fn _ZNK2JS9GCCellPtr7isShapeEv(this: *mut GCCellPtr) -> bool;
fn _ZNK2JS9GCCellPtr13isObjectGroupEv(this: *mut GCCellPtr) -> bool;
fn _ZNK2JS9GCCellPtr8toObjectEv(this: *mut GCCellPtr) -> *mut JSObject;
fn _ZNK2JS9GCCellPtr8toStringEv(this: *mut GCCellPtr) -> *mut JSString;
fn _ZNK2JS9GCCellPtr8toScriptEv(this: *mut GCCellPtr) -> *mut JSScript;
fn _ZNK2JS9GCCellPtr8toSymbolEv(this: *mut GCCellPtr) -> *mut Symbol;
fn _ZNK2JS9GCCellPtr6asCellEv(this: *mut GCCellPtr) -> *mut Cell;
fn _ZNK2JS9GCCellPtr15unsafeAsIntegerEv(this: *mut GCCellPtr) -> u64;
fn _ZNK2JS9GCCellPtr15unsafeAsUIntPtrEv(this: *mut GCCellPtr)
-> uintptr_t;
fn _ZNK2JS9GCCellPtr24mayBeOwnedByOtherRuntimeEv(this: *mut GCCellPtr)
-> bool;
fn _ZN2JS9GCCellPtr11checkedCastEPvNS_9TraceKindE(p: *mut ::libc::c_void,
traceKind: TraceKind)
-> uintptr_t;
fn _ZNK2JS9GCCellPtr13outOfLineKindEv(this: *mut GCCellPtr) -> TraceKind;
}
impl GCCellPtr {
#[inline]
pub unsafe extern "C" fn kind(&mut self) -> TraceKind {
_ZNK2JS9GCCellPtr4kindEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn isObject(&mut self) -> bool {
_ZNK2JS9GCCellPtr8isObjectEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn isScript(&mut self) -> bool {
_ZNK2JS9GCCellPtr8isScriptEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn isString(&mut self) -> bool {
_ZNK2JS9GCCellPtr8isStringEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn isSymbol(&mut self) -> bool {
_ZNK2JS9GCCellPtr8isSymbolEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn isShape(&mut self) -> bool {
_ZNK2JS9GCCellPtr7isShapeEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn isObjectGroup(&mut self) -> bool {
_ZNK2JS9GCCellPtr13isObjectGroupEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn toObject(&mut self) -> *mut JSObject {
_ZNK2JS9GCCellPtr8toObjectEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn toString(&mut self) -> *mut JSString {
_ZNK2JS9GCCellPtr8toStringEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn toScript(&mut self) -> *mut JSScript {
_ZNK2JS9GCCellPtr8toScriptEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn toSymbol(&mut self) -> *mut Symbol {
_ZNK2JS9GCCellPtr8toSymbolEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn asCell(&mut self) -> *mut Cell {
_ZNK2JS9GCCellPtr6asCellEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn unsafeAsInteger(&mut self) -> u64 {
_ZNK2JS9GCCellPtr15unsafeAsIntegerEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn unsafeAsUIntPtr(&mut self) -> uintptr_t {
_ZNK2JS9GCCellPtr15unsafeAsUIntPtrEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn mayBeOwnedByOtherRuntime(&mut self) -> bool {
_ZNK2JS9GCCellPtr24mayBeOwnedByOtherRuntimeEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn checkedCast(p: *mut ::libc::c_void,
traceKind: TraceKind) -> uintptr_t {
_ZN2JS9GCCellPtr11checkedCastEPvNS_9TraceKindE(p, traceKind)
}
#[inline]
pub unsafe extern "C" fn outOfLineKind(&mut self) -> TraceKind {
_ZNK2JS9GCCellPtr13outOfLineKindEv(&mut *self)
}
}
pub enum GCRuntime { }
pub enum Statistics { }
#[repr(i32)]
#[derive(Copy)]
pub enum JSGCMode {
JSGC_MODE_GLOBAL = 0,
JSGC_MODE_COMPARTMENT = 1,
JSGC_MODE_INCREMENTAL = 2,
}
#[repr(i32)]
#[derive(Copy)]
pub enum JSGCInvocationKind { GC_NORMAL = 0, GC_SHRINK = 1, }
#[repr(i32)]
#[derive(Copy)]
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,
ABORT_GC = 16,
RESERVED0 = 17,
RESERVED1 = 18,
RESERVED2 = 19,
RESERVED3 = 20,
RESERVED4 = 21,
RESERVED5 = 22,
RESERVED6 = 23,
RESERVED7 = 24,
RESERVED8 = 25,
RESERVED9 = 26,
RESERVED10 = 27,
RESERVED11 = 28,
RESERVED12 = 29,
RESERVED13 = 30,
RESERVED14 = 31,
RESERVED15 = 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,
XPCONNECT_SHUTDOWN = 53,
NO_REASON = 54,
NUM_REASONS = 55,
NUM_TELEMETRY_REASONS = 100,
}
#[repr(C)]
#[derive(Copy)]
pub struct GarbageCollectionEvent {
pub majorGCNumber_: u64,
pub reason: *const ::libc::c_char,
pub nonincrementalReason: *const ::libc::c_char,
pub collections: Vector<Collection, ::libc::c_void, MallocAllocPolicy>,
}
impl ::std::default::Default for GarbageCollectionEvent {
fn default() -> GarbageCollectionEvent { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct Collection {
pub startTimestamp: f64,
pub endTimestamp: f64,
}
impl ::std::default::Default for Collection {
fn default() -> Collection { unsafe { ::std::mem::zeroed() } }
}
extern "C" {
fn _ZN2JS3dbg22GarbageCollectionEvent6CreateEP9JSRuntimeRN2js7gcstats10StatisticsEy(rt:
*mut JSRuntime,
stats:
&mut Statistics,
majorGCNumber:
u64)
-> Ptr;
fn _ZNK2JS3dbg22GarbageCollectionEvent10toJSObjectEP9JSContext(this:
*mut GarbageCollectionEvent,
cx:
*mut JSContext)
-> *mut JSObject;
fn _ZNK2JS3dbg22GarbageCollectionEvent13majorGCNumberEv(this:
*mut GarbageCollectionEvent)
-> u64;
}
impl GarbageCollectionEvent {
#[inline]
pub unsafe extern "C" fn Create(rt: *mut JSRuntime,
stats: &mut Statistics,
majorGCNumber: u64) -> Ptr {
_ZN2JS3dbg22GarbageCollectionEvent6CreateEP9JSRuntimeRN2js7gcstats10StatisticsEy(rt,
stats,
majorGCNumber)
}
#[inline]
pub unsafe extern "C" fn toJSObject(&mut self, cx: *mut JSContext)
-> *mut JSObject {
_ZNK2JS3dbg22GarbageCollectionEvent10toJSObjectEP9JSContext(&mut *self,
cx)
}
#[inline]
pub unsafe extern "C" fn majorGCNumber(&mut self) -> u64 {
_ZNK2JS3dbg22GarbageCollectionEvent13majorGCNumberEv(&mut *self)
}
}
#[repr(i32)]
#[derive(Copy)]
pub enum GCProgress {
GC_CYCLE_BEGIN = 0,
GC_SLICE_BEGIN = 1,
GC_SLICE_END = 2,
GC_CYCLE_END = 3,
}
#[repr(C)]
#[derive(Copy)]
pub struct GCDescription {
pub isCompartment_: bool,
pub invocationKind_: JSGCInvocationKind,
pub reason_: Reason,
}
impl ::std::default::Default for GCDescription {
fn default() -> GCDescription { unsafe { ::std::mem::zeroed() } }
}
extern "C" {
fn _ZNK2JS13GCDescription18formatSliceMessageEP9JSRuntime(this:
*mut GCDescription,
rt:
*mut JSRuntime)
-> *mut u16;
fn _ZNK2JS13GCDescription20formatSummaryMessageEP9JSRuntime(this:
*mut GCDescription,
rt:
*mut JSRuntime)
-> *mut u16;
fn _ZNK2JS13GCDescription10formatJSONEP9JSRuntimey(this:
*mut GCDescription,
rt: *mut JSRuntime,
timestamp: u64)
-> *mut u16;
fn _ZNK2JS13GCDescription9toGCEventEP9JSRuntime(this: *mut GCDescription,
rt: *mut JSRuntime)
-> JS::dbg::GarbageCollectionEvent::Ptr;
}
impl GCDescription {
#[inline]
pub unsafe extern "C" fn formatSliceMessage(&mut self, rt: *mut JSRuntime)
-> *mut u16 {
_ZNK2JS13GCDescription18formatSliceMessageEP9JSRuntime(&mut *self, rt)
}
#[inline]
pub unsafe extern "C" fn formatSummaryMessage(&mut self,
rt: *mut JSRuntime)
-> *mut u16 {
_ZNK2JS13GCDescription20formatSummaryMessageEP9JSRuntime(&mut *self,
rt)
}
#[inline]
pub unsafe extern "C" fn formatJSON(&mut self, rt: *mut JSRuntime,
timestamp: u64) -> *mut u16 {
_ZNK2JS13GCDescription10formatJSONEP9JSRuntimey(&mut *self, rt,
timestamp)
}
#[inline]
pub unsafe extern "C" fn toGCEvent(&mut self, rt: *mut JSRuntime)
-> JS::dbg::GarbageCollectionEvent::Ptr {
_ZNK2JS13GCDescription9toGCEventEP9JSRuntime(&mut *self, rt)
}
}
pub type GCSliceCallback =
::std::option::Option<unsafe extern "C" fn(rt: *mut JSRuntime,
progress: GCProgress,
desc: &GCDescription)>;
#[repr(C)]
#[derive(Copy)]
pub struct AutoDisableGenerationalGC {
pub gc: *mut GCRuntime,
}
impl ::std::default::Default for AutoDisableGenerationalGC {
fn default() -> AutoDisableGenerationalGC {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Copy)]
pub struct AutoAssertOnGC;
impl ::std::default::Default for AutoAssertOnGC {
fn default() -> AutoAssertOnGC { unsafe { ::std::mem::zeroed() } }
}
extern "C" {
fn _ZN2JS14AutoAssertOnGC16VerifyIsSafeToGCEP9JSRuntime(rt:
*mut JSRuntime);
}
impl AutoAssertOnGC {
#[inline]
pub unsafe extern "C" fn VerifyIsSafeToGC(rt: *mut JSRuntime) {
_ZN2JS14AutoAssertOnGC16VerifyIsSafeToGCEP9JSRuntime(rt)
}
}
#[repr(C)]
#[derive(Copy)]
pub struct AutoAssertNoAlloc;
impl ::std::default::Default for AutoAssertNoAlloc {
fn default() -> AutoAssertNoAlloc { unsafe { ::std::mem::zeroed() } }
}
extern "C" {
fn _ZN2JS17AutoAssertNoAlloc13disallowAllocEP9JSRuntime(this:
*mut AutoAssertNoAlloc,
rt:
*mut JSRuntime);
}
impl AutoAssertNoAlloc {
#[inline]
pub unsafe extern "C" fn disallowAlloc(&mut self, rt: *mut JSRuntime) {
_ZN2JS17AutoAssertNoAlloc13disallowAllocEP9JSRuntime(&mut *self, rt)
}
}
#[repr(C)]
#[derive(Copy)]
pub struct AutoSuppressGCAnalysis {
pub _base: AutoAssertNoAlloc,
}
impl ::std::default::Default for AutoSuppressGCAnalysis {
fn default() -> AutoSuppressGCAnalysis { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct AutoAssertGCCallback {
pub _base: AutoSuppressGCAnalysis,
}
impl ::std::default::Default for AutoAssertGCCallback {
fn default() -> AutoAssertGCCallback { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct AutoCheckCannotGC {
pub _base: AutoAssertOnGC,
}
impl ::std::default::Default for AutoCheckCannotGC {
fn default() -> AutoCheckCannotGC { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct GCMethods<T>;
#[repr(C)]
#[derive(Copy)]
pub struct RootedBase<T>;
#[repr(C)]
#[derive(Copy)]
pub struct HandleBase<T>;
#[repr(C)]
#[derive(Copy)]
pub struct MutableHandleBase<T>;
#[repr(C)]
#[derive(Copy)]
pub struct HeapBase<T>;
#[repr(C)]
#[derive(Copy)]
pub struct PersistentRootedBase<T>;
pub enum PersistentRootedMarker { }
#[repr(C)]
#[derive(Copy)]
pub struct Heap<T> {
pub _base: HeapBase<T>,
pub ptr: T,
}
#[repr(i32)]
#[derive(Copy)]
pub enum Heap_ { crashOnTouchPointer = 0, }
#[repr(C)]
#[derive(Copy)]
pub struct TenuredHeap<T> {
pub _base: HeapBase<T>,
pub bits: uintptr_t,
}
#[repr(i32)]
#[derive(Copy)]
pub enum TenuredHeap_ { maskBits = 0, flagsMask = 0, }
#[repr(C)]
#[derive(Copy)]
pub struct Handle<T> {
pub _base: HandleBase<T>,
pub ptr: *const T,
}
#[repr(i32)]
#[derive(Copy)]
pub enum Handle_Disambiguator { DeliberatelyChoosingThisOverload = 0, }
#[repr(i32)]
#[derive(Copy)]
pub enum Handle_CallerIdentity {
ImUsingThisOnlyInFromFromMarkedLocation = 0,
}
#[repr(C)]
#[derive(Copy)]
pub struct MutableHandle<T> {
pub _base: MutableHandleBase<T>,
pub ptr: *mut T,
}
#[repr(C)]
#[derive(Copy)]
pub struct RootKind<T>;
#[repr(C)]
#[derive(Copy)]
pub struct GCMethods;
impl ::std::default::Default for GCMethods {
fn default() -> GCMethods { unsafe { ::std::mem::zeroed() } }
}
extern "C" {
fn _ZN2js9GCMethodsIP8JSObjectE7initialEv() -> *mut JSObject;
fn _ZN2js9GCMethodsIP8JSObjectE15asGCThingOrNullES2_(v: *mut JSObject)
-> *mut Cell;
fn _ZN2js9GCMethodsIP8JSObjectE11postBarrierEPS2_S2_S2_(vp:
*mut *mut JSObject,
prev:
*mut JSObject,
next:
*mut JSObject);
}
impl GCMethods {
#[inline]
pub unsafe extern "C" fn initial() -> *mut JSObject {
_ZN2js9GCMethodsIP8JSObjectE7initialEv()
}
#[inline]
pub unsafe extern "C" fn asGCThingOrNull(v: *mut JSObject) -> *mut Cell {
_ZN2js9GCMethodsIP8JSObjectE15asGCThingOrNullES2_(v)
}
#[inline]
pub unsafe extern "C" fn postBarrier(vp: *mut *mut JSObject,
prev: *mut JSObject,
next: *mut JSObject) {
_ZN2js9GCMethodsIP8JSObjectE11postBarrierEPS2_S2_S2_(vp, prev, next)
}
}
#[repr(C)]
#[derive(Copy)]
pub struct DynamicTraceable {
pub _vftable: *const _vftable_DynamicTraceable,
}
impl ::std::default::Default for DynamicTraceable {
fn default() -> DynamicTraceable { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
pub struct _vftable_DynamicTraceable {
pub trace: extern "C" fn(this: *mut ::libc::c_void, trc: *mut JSTracer),
}
extern "C" {
fn _ZN2JS16DynamicTraceable8rootKindEv() -> ThingRootKind;
}
impl DynamicTraceable {
#[inline]
pub unsafe extern "C" fn rootKind() -> ThingRootKind {
_ZN2JS16DynamicTraceable8rootKindEv()
}
}
#[repr(C)]
#[derive(Copy)]
pub struct StaticTraceable;
impl ::std::default::Default for StaticTraceable {
fn default() -> StaticTraceable { unsafe { ::std::mem::zeroed() } }
}
extern "C" {
fn _ZN2JS15StaticTraceable8rootKindEv() -> ThingRootKind;
}
impl StaticTraceable {
#[inline]
pub unsafe extern "C" fn rootKind() -> ThingRootKind {
_ZN2JS15StaticTraceable8rootKindEv()
}
}
#[repr(C)]
#[derive(Copy)]
pub struct DispatchWrapper<T> {
pub tracer: TraceFn,
pub padding: u32,
pub storage: T,
}
#[repr(C)]
#[derive(Copy)]
pub struct Rooted<T> {
pub _base: RootedBase<T>,
pub stack: *mut *mut Rooted<*mut ::libc::c_void>,
pub prev: *mut Rooted<*mut ::libc::c_void>,
pub ptr: MaybeWrapped,
}
#[repr(C)]
#[derive(Copy)]
pub struct RootedBase<>;
#[repr(C)]
#[derive(Copy)]
pub struct HandleBase<>;
#[repr(C)]
#[derive(Copy)]
pub struct FakeRooted<T> {
pub _base: RootedBase<T>,
pub ptr: T,
}
#[repr(C)]
#[derive(Copy)]
pub struct FakeMutableHandle<T> {
pub _base: MutableHandleBase<T>,
pub ptr: *mut T,
}
#[repr(i32)]
#[derive(Copy)]
pub enum AllowGC { NoGC = 0, CanGC = 1, }
#[repr(C)]
#[derive(Copy)]
pub struct MaybeRooted<T>;
#[repr(C)]
#[derive(Copy)]
pub struct PersistentRooted<T> {
pub _base: PersistentRootedBase<T>,
pub _base1: LinkedListElement<T>,
pub ptr: T,
}
#[repr(C)]
#[derive(Copy)]
pub struct ObjectPtr {
pub value: Heap<*mut JSObject>,
}
impl ::std::default::Default for ObjectPtr {
fn default() -> ObjectPtr { unsafe { ::std::mem::zeroed() } }
}
extern "C" {
fn _ZN2JS9ObjectPtr8finalizeEP9JSRuntime(this: *mut ObjectPtr,
rt: *mut JSRuntime);
fn _ZN2JS9ObjectPtr4initEP8JSObject(this: *mut ObjectPtr,
obj: *mut JSObject);
fn _ZNK2JS9ObjectPtr3getEv(this: *mut ObjectPtr) -> *mut JSObject;
fn _ZN2JS9ObjectPtr15writeBarrierPreEP9JSRuntime(this: *mut ObjectPtr,
rt: *mut JSRuntime);
fn _ZN2JS9ObjectPtr24updateWeakPointerAfterGCEv(this: *mut ObjectPtr);
fn _ZN2JS9ObjectPtr5traceEP8JSTracerPKc(this: *mut ObjectPtr,
trc: *mut JSTracer,
name: *const ::libc::c_char);
}
impl ObjectPtr {
#[inline]
pub unsafe extern "C" fn finalize(&mut self, rt: *mut JSRuntime) {
_ZN2JS9ObjectPtr8finalizeEP9JSRuntime(&mut *self, rt)
}
#[inline]
pub unsafe extern "C" fn init(&mut self, obj: *mut JSObject) {
_ZN2JS9ObjectPtr4initEP8JSObject(&mut *self, obj)
}
#[inline]
pub unsafe extern "C" fn get(&mut self) -> *mut JSObject {
_ZNK2JS9ObjectPtr3getEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn writeBarrierPre(&mut self, rt: *mut JSRuntime) {
_ZN2JS9ObjectPtr15writeBarrierPreEP9JSRuntime(&mut *self, rt)
}
#[inline]
pub unsafe extern "C" fn updateWeakPointerAfterGC(&mut self) {
_ZN2JS9ObjectPtr24updateWeakPointerAfterGCEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn trace(&mut self, trc: *mut JSTracer,
name: *const ::libc::c_char) {
_ZN2JS9ObjectPtr5traceEP8JSTracerPKc(&mut *self, trc, name)
}
}
#[repr(i32)]
#[derive(Copy)]
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)]
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)]
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(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)]
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)]
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 size_t {
::std::mem::transmute(&self._bindgen_data_)
}
pub unsafe fn uintptr(&mut self) -> *mut uintptr_t {
::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(Copy)]
pub struct Value {
pub data: jsval_layout,
}
impl ::std::default::Default for Value {
fn default() -> Value { unsafe { ::std::mem::zeroed() } }
}
extern "C" {
fn _ZN2JS5Value7setNullEv(this: *mut Value);
fn _ZN2JS5Value12setUndefinedEv(this: *mut Value);
fn _ZN2JS5Value8setInt32Ei(this: *mut Value, i: i32);
fn _ZN2JS5Value11getInt32RefEv(this: *mut Value) -> *mut i32;
fn _ZN2JS5Value9setDoubleEd(this: *mut Value, d: f64);
fn _ZN2JS5Value6setNaNEv(this: *mut Value);
fn _ZN2JS5Value12getDoubleRefEv(this: *mut Value) -> *mut f64;
fn _ZN2JS5Value9setStringEP8JSString(this: *mut Value,
str: *mut JSString);
fn _ZN2JS5Value9setSymbolEPNS_6SymbolE(this: *mut Value,
sym: *mut Symbol);
fn _ZN2JS5Value9setObjectER8JSObject(this: *mut Value,
obj: &mut JSObject);
fn _ZN2JS5Value10setBooleanEb(this: *mut Value, b: bool);
fn _ZN2JS5Value8setMagicE10JSWhyMagic(this: *mut Value, why: JSWhyMagic);
fn _ZN2JS5Value14setMagicUint32Ej(this: *mut Value, payload: u32);
fn _ZN2JS5Value9setNumberEj(this: *mut Value, ui: u32) -> bool;
fn _ZN2JS5Value9setNumberEd(this: *mut Value, d: f64) -> bool;
fn _ZN2JS5Value15setObjectOrNullEP8JSObject(this: *mut Value,
arg: *mut JSObject);
fn _ZN2JS5Value4swapERS0_(this: *mut Value, rhs: &mut Value);
fn _ZNK2JS5Value11isUndefinedEv(this: *mut Value) -> bool;
fn _ZNK2JS5Value6isNullEv(this: *mut Value) -> bool;
fn _ZNK2JS5Value17isNullOrUndefinedEv(this: *mut Value) -> bool;
fn _ZNK2JS5Value7isInt32Ev(this: *mut Value) -> bool;
fn _ZNK2JS5Value7isInt32Ei(this: *mut Value, i32: i32) -> bool;
fn _ZNK2JS5Value8isDoubleEv(this: *mut Value) -> bool;
fn _ZNK2JS5Value8isNumberEv(this: *mut Value) -> bool;
fn _ZNK2JS5Value8isStringEv(this: *mut Value) -> bool;
fn _ZNK2JS5Value8isSymbolEv(this: *mut Value) -> bool;
fn _ZNK2JS5Value8isObjectEv(this: *mut Value) -> bool;
fn _ZNK2JS5Value11isPrimitiveEv(this: *mut Value) -> bool;
fn _ZNK2JS5Value14isObjectOrNullEv(this: *mut Value) -> bool;
fn _ZNK2JS5Value9isGCThingEv(this: *mut Value) -> bool;
fn _ZNK2JS5Value9isBooleanEv(this: *mut Value) -> bool;
fn _ZNK2JS5Value6isTrueEv(this: *mut Value) -> bool;
fn _ZNK2JS5Value7isFalseEv(this: *mut Value) -> bool;
fn _ZNK2JS5Value7isMagicEv(this: *mut Value) -> bool;
fn _ZNK2JS5Value7isMagicE10JSWhyMagic(this: *mut Value, why: JSWhyMagic)
-> bool;
fn _ZNK2JS5Value10isMarkableEv(this: *mut Value) -> bool;
fn _ZNK2JS5Value9traceKindEv(this: *mut Value) -> TraceKind;
fn _ZNK2JS5Value8whyMagicEv(this: *mut Value) -> JSWhyMagic;
fn _ZNK2JS5Value11magicUint32Ev(this: *mut Value) -> u32;
fn _ZNK2JS5Value7toInt32Ev(this: *mut Value) -> i32;
fn _ZNK2JS5Value8toDoubleEv(this: *mut Value) -> f64;
fn _ZNK2JS5Value8toNumberEv(this: *mut Value) -> f64;
fn _ZNK2JS5Value8toStringEv(this: *mut Value) -> *mut JSString;
fn _ZNK2JS5Value8toSymbolEv(this: *mut Value) -> *mut Symbol;
fn _ZNK2JS5Value8toObjectEv(this: *mut Value) -> *mut JSObject;
fn _ZNK2JS5Value14toObjectOrNullEv(this: *mut Value) -> *mut JSObject;
fn _ZNK2JS5Value9toGCThingEv(this: *mut Value) -> *mut Cell;
fn _ZNK2JS5Value11toGCCellPtrEv(this: *mut Value) -> GCCellPtr;
fn _ZNK2JS5Value9toBooleanEv(this: *mut Value) -> bool;
fn _ZNK2JS5Value18payloadAsRawUint32Ev(this: *mut Value) -> u32;
fn _ZNK2JS5Value9asRawBitsEv(this: *mut Value) -> u64;
fn _ZNK2JS5Value20extractNonDoubleTypeEv(this: *mut Value) -> JSValueType;
fn _ZN2JS5Value10setPrivateEPv(this: *mut Value,
ptr: *mut ::libc::c_void);
fn _ZNK2JS5Value9toPrivateEv(this: *mut Value) -> *mut ::libc::c_void;
fn _ZN2JS5Value16setPrivateUint32Ej(this: *mut Value, ui: u32);
fn _ZNK2JS5Value15toPrivateUint32Ev(this: *mut Value) -> u32;
fn _ZN2JS5Value14setUnmarkedPtrEPv(this: *mut Value,
ptr: *mut ::libc::c_void);
fn _ZNK2JS5Value13toUnmarkedPtrEv(this: *mut Value)
-> *mut ::libc::c_void;
fn _ZNK2JS5Value11payloadWordEv(this: *mut Value) -> *const size_t;
fn _ZNK2JS5Value14payloadUIntPtrEv(this: *mut Value) -> *const uintptr_t;
fn _ZN2JS5Value16staticAssertionsEv(this: *mut Value);
}
impl Value {
/*** Mutators ***/
#[inline]
pub unsafe extern "C" fn setNull(&mut self) {
_ZN2JS5Value7setNullEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn setUndefined(&mut self) {
_ZN2JS5Value12setUndefinedEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn setInt32(&mut self, i: i32) {
_ZN2JS5Value8setInt32Ei(&mut *self, i)
}
#[inline]
pub unsafe extern "C" fn getInt32Ref(&mut self) -> *mut i32 {
_ZN2JS5Value11getInt32RefEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn setDouble(&mut self, d: f64) {
_ZN2JS5Value9setDoubleEd(&mut *self, d)
}
#[inline]
pub unsafe extern "C" fn setNaN(&mut self) {
_ZN2JS5Value6setNaNEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn getDoubleRef(&mut self) -> *mut f64 {
_ZN2JS5Value12getDoubleRefEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn setString(&mut self, str: *mut JSString) {
_ZN2JS5Value9setStringEP8JSString(&mut *self, str)
}
#[inline]
pub unsafe extern "C" fn setSymbol(&mut self, sym: *mut Symbol) {
_ZN2JS5Value9setSymbolEPNS_6SymbolE(&mut *self, sym)
}
#[inline]
pub unsafe extern "C" fn setObject(&mut self, obj: &mut JSObject) {
_ZN2JS5Value9setObjectER8JSObject(&mut *self, obj)
}
#[inline]
pub unsafe extern "C" fn setBoolean(&mut self, b: bool) {
_ZN2JS5Value10setBooleanEb(&mut *self, b)
}
#[inline]
pub unsafe extern "C" fn setMagic(&mut self, why: JSWhyMagic) {
_ZN2JS5Value8setMagicE10JSWhyMagic(&mut *self, why)
}
#[inline]
pub unsafe extern "C" fn setMagicUint32(&mut self, payload: u32) {
_ZN2JS5Value14setMagicUint32Ej(&mut *self, payload)
}
#[inline]
pub unsafe extern "C" fn setNumber(&mut self, ui: u32) -> bool {
_ZN2JS5Value9setNumberEj(&mut *self, ui)
}
#[inline]
pub unsafe extern "C" fn setNumber1(&mut self, d: f64) -> bool {
_ZN2JS5Value9setNumberEd(&mut *self, d)
}
#[inline]
pub unsafe extern "C" fn setObjectOrNull(&mut self, arg: *mut JSObject) {
_ZN2JS5Value15setObjectOrNullEP8JSObject(&mut *self, arg)
}
#[inline]
pub unsafe extern "C" fn swap(&mut self, rhs: &mut Value) {
_ZN2JS5Value4swapERS0_(&mut *self, rhs)
}
/*** Value type queries ***/
#[inline]
pub unsafe extern "C" fn isUndefined(&mut self) -> bool {
_ZNK2JS5Value11isUndefinedEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn isNull(&mut self) -> bool {
_ZNK2JS5Value6isNullEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn isNullOrUndefined(&mut self) -> bool {
_ZNK2JS5Value17isNullOrUndefinedEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn isInt32(&mut self) -> bool {
_ZNK2JS5Value7isInt32Ev(&mut *self)
}
#[inline]
pub unsafe extern "C" fn isInt321(&mut self, i32: i32) -> bool {
_ZNK2JS5Value7isInt32Ei(&mut *self, i32)
}
#[inline]
pub unsafe extern "C" fn isDouble(&mut self) -> bool {
_ZNK2JS5Value8isDoubleEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn isNumber(&mut self) -> bool {
_ZNK2JS5Value8isNumberEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn isString(&mut self) -> bool {
_ZNK2JS5Value8isStringEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn isSymbol(&mut self) -> bool {
_ZNK2JS5Value8isSymbolEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn isObject(&mut self) -> bool {
_ZNK2JS5Value8isObjectEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn isPrimitive(&mut self) -> bool {
_ZNK2JS5Value11isPrimitiveEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn isObjectOrNull(&mut self) -> bool {
_ZNK2JS5Value14isObjectOrNullEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn isGCThing(&mut self) -> bool {
_ZNK2JS5Value9isGCThingEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn isBoolean(&mut self) -> bool {
_ZNK2JS5Value9isBooleanEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn isTrue(&mut self) -> bool {
_ZNK2JS5Value6isTrueEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn isFalse(&mut self) -> bool {
_ZNK2JS5Value7isFalseEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn isMagic(&mut self) -> bool {
_ZNK2JS5Value7isMagicEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn isMagic1(&mut self, why: JSWhyMagic) -> bool {
_ZNK2JS5Value7isMagicE10JSWhyMagic(&mut *self, why)
}
#[inline]
pub unsafe extern "C" fn isMarkable(&mut self) -> bool {
_ZNK2JS5Value10isMarkableEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn traceKind(&mut self) -> TraceKind {
_ZNK2JS5Value9traceKindEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn whyMagic(&mut self) -> JSWhyMagic {
_ZNK2JS5Value8whyMagicEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn magicUint32(&mut self) -> u32 {
_ZNK2JS5Value11magicUint32Ev(&mut *self)
}
/*** Extract the value's typed payload ***/
#[inline]
pub unsafe extern "C" fn toInt32(&mut self) -> i32 {
_ZNK2JS5Value7toInt32Ev(&mut *self)
}
#[inline]
pub unsafe extern "C" fn toDouble(&mut self) -> f64 {
_ZNK2JS5Value8toDoubleEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn toNumber(&mut self) -> f64 {
_ZNK2JS5Value8toNumberEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn toString(&mut self) -> *mut JSString {
_ZNK2JS5Value8toStringEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn toSymbol(&mut self) -> *mut Symbol {
_ZNK2JS5Value8toSymbolEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn toObject(&mut self) -> *mut JSObject {
_ZNK2JS5Value8toObjectEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn toObjectOrNull(&mut self) -> *mut JSObject {
_ZNK2JS5Value14toObjectOrNullEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn toGCThing(&mut self) -> *mut Cell {
_ZNK2JS5Value9toGCThingEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn toGCCellPtr(&mut self) -> GCCellPtr {
_ZNK2JS5Value11toGCCellPtrEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn toBoolean(&mut self) -> bool {
_ZNK2JS5Value9toBooleanEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn payloadAsRawUint32(&mut self) -> u32 {
_ZNK2JS5Value18payloadAsRawUint32Ev(&mut *self)
}
#[inline]
pub unsafe extern "C" fn asRawBits(&mut self) -> u64 {
_ZNK2JS5Value9asRawBitsEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn extractNonDoubleType(&mut self) -> JSValueType {
_ZNK2JS5Value20extractNonDoubleTypeEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn setPrivate(&mut self, ptr: *mut ::libc::c_void) {
_ZN2JS5Value10setPrivateEPv(&mut *self, ptr)
}
#[inline]
pub unsafe extern "C" fn toPrivate(&mut self) -> *mut ::libc::c_void {
_ZNK2JS5Value9toPrivateEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn setPrivateUint32(&mut self, ui: u32) {
_ZN2JS5Value16setPrivateUint32Ej(&mut *self, ui)
}
#[inline]
pub unsafe extern "C" fn toPrivateUint32(&mut self) -> u32 {
_ZNK2JS5Value15toPrivateUint32Ev(&mut *self)
}
#[inline]
pub unsafe extern "C" fn setUnmarkedPtr(&mut self,
ptr: *mut ::libc::c_void) {
_ZN2JS5Value14setUnmarkedPtrEPv(&mut *self, ptr)
}
#[inline]
pub unsafe extern "C" fn toUnmarkedPtr(&mut self) -> *mut ::libc::c_void {
_ZNK2JS5Value13toUnmarkedPtrEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn payloadWord(&mut self) -> *const size_t {
_ZNK2JS5Value11payloadWordEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn payloadUIntPtr(&mut self) -> *const uintptr_t {
_ZNK2JS5Value14payloadUIntPtrEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn staticAssertions(&mut self) {
_ZN2JS5Value16staticAssertionsEv(&mut *self)
}
}
#[repr(C)]
#[derive(Copy)]
pub struct MakeNumberValue;
impl ::std::default::Default for MakeNumberValue {
fn default() -> MakeNumberValue { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct MakeNumberValue<>;
#[repr(C)]
#[derive(Copy)]
pub struct ValueOperations<Outer>;
#[repr(C)]
#[derive(Copy)]
pub struct MutableValueOperations<Outer> {
pub _base: ValueOperations<Outer>,
}
#[repr(C)]
#[derive(Copy)]
pub struct HeapBase<> {
pub _base: ValueOperations<Heap<Value>>,
}
#[repr(C)]
#[derive(Copy)]
pub struct HandleBase<> {
pub _base: ValueOperations<Handle<Value>>,
}
#[repr(C)]
#[derive(Copy)]
pub struct MutableHandleBase<> {
pub _base: MutableValueOperations<MutableHandle<Value>>,
}
#[repr(C)]
#[derive(Copy)]
pub struct RootedBase<> {
pub _base: MutableValueOperations<Rooted<Value>>,
}
#[repr(C)]
#[derive(Copy)]
pub struct PersistentRootedBase<> {
pub _base: MutableValueOperations<PersistentRooted<Value>>,
}
#[repr(C)]
#[derive(Copy)]
pub struct VoidDefaultAdaptor<S>;
#[repr(C)]
#[derive(Copy)]
pub struct IdentityDefaultAdaptor<S>;
#[repr(C)]
#[derive(Copy)]
pub struct BoolDefaultAdaptor<S>;
pub type JSNative =
::std::option::Option<unsafe extern "C" fn(cx: *mut JSContext, argc: u32,
vp: *mut Value) -> bool>;
#[repr(i32)]
#[derive(Copy)]
pub enum UsedRval { IncludeUsedRval = 0, NoUsedRval = 1, }
pub enum UsedRvalBase { }
#[repr(C)]
#[derive(Copy)]
pub struct UsedRvalBase<> {
pub usedRval_: bool,
}
#[repr(C)]
#[derive(Copy)]
pub struct CallReceiverBase {
pub _base: UsedRvalBase<::libc::c_void>,
pub argv_: *mut Value,
}
impl ::std::default::Default for CallReceiverBase {
fn default() -> CallReceiverBase { unsafe { ::std::mem::zeroed() } }
}
extern "C" {
fn _ZNK2JS6detail16CallReceiverBase6calleeEv(this: *mut CallReceiverBase)
-> *mut JSObject;
fn _ZNK2JS6detail16CallReceiverBase7calleevEv(this: *mut CallReceiverBase)
-> HandleValue;
fn _ZNK2JS6detail16CallReceiverBase5thisvEv(this: *mut CallReceiverBase)
-> HandleValue;
fn _ZNK2JS6detail16CallReceiverBase11computeThisEP9JSContext(this:
*mut CallReceiverBase,
cx:
*mut JSContext)
-> Value;
fn _ZNK2JS6detail16CallReceiverBase14isConstructingEv(this:
*mut CallReceiverBase)
-> bool;
fn _ZNK2JS6detail16CallReceiverBase4rvalEv(this: *mut CallReceiverBase)
-> MutableHandleValue;
fn _ZNK2JS6detail16CallReceiverBase4baseEv(this: *mut CallReceiverBase)
-> *mut Value;
fn _ZNK2JS6detail16CallReceiverBase11spAfterCallEv(this:
*mut CallReceiverBase)
-> *mut Value;
fn _ZNK2JS6detail16CallReceiverBase9setCalleeENS_5ValueE(this:
*mut CallReceiverBase,
aCalleev: Value);
fn _ZNK2JS6detail16CallReceiverBase7setThisENS_5ValueE(this:
*mut CallReceiverBase,
aThisv: Value);
fn _ZNK2JS6detail16CallReceiverBase12mutableThisvEv(this:
*mut CallReceiverBase)
-> MutableHandleValue;
}
impl CallReceiverBase {
#[inline]
pub unsafe extern "C" fn callee(&mut self) -> *mut JSObject {
_ZNK2JS6detail16CallReceiverBase6calleeEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn calleev(&mut self) -> HandleValue {
_ZNK2JS6detail16CallReceiverBase7calleevEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn thisv(&mut self) -> HandleValue {
_ZNK2JS6detail16CallReceiverBase5thisvEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn computeThis(&mut self, cx: *mut JSContext)
-> Value {
_ZNK2JS6detail16CallReceiverBase11computeThisEP9JSContext(&mut *self,
cx)
}
#[inline]
pub unsafe extern "C" fn isConstructing(&mut self) -> bool {
_ZNK2JS6detail16CallReceiverBase14isConstructingEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn rval(&mut self) -> MutableHandleValue {
_ZNK2JS6detail16CallReceiverBase4rvalEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn base(&mut self) -> *mut Value {
_ZNK2JS6detail16CallReceiverBase4baseEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn spAfterCall(&mut self) -> *mut Value {
_ZNK2JS6detail16CallReceiverBase11spAfterCallEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn setCallee(&mut self, aCalleev: Value) {
_ZNK2JS6detail16CallReceiverBase9setCalleeENS_5ValueE(&mut *self,
aCalleev)
}
#[inline]
pub unsafe extern "C" fn setThis(&mut self, aThisv: Value) {
_ZNK2JS6detail16CallReceiverBase7setThisENS_5ValueE(&mut *self,
aThisv)
}
#[inline]
pub unsafe extern "C" fn mutableThisv(&mut self) -> MutableHandleValue {
_ZNK2JS6detail16CallReceiverBase12mutableThisvEv(&mut *self)
}
}
#[repr(C)]
#[derive(Copy)]
pub struct CallReceiver {
pub _base: CallReceiverBase<::libc::c_void>,
}
impl ::std::default::Default for CallReceiver {
fn default() -> CallReceiver { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct CallArgsBase {
pub _base: mozilla::Conditional<WantUsedRval == detail::IncludeUsedRval, CallReceiver, CallReceiverBase<NoUsedRval> >::Type,
pub argc_: u32,
pub constructing_: bool,
}
impl ::std::default::Default for CallArgsBase {
fn default() -> CallArgsBase { unsafe { ::std::mem::zeroed() } }
}
extern "C" {
fn _ZNK2JS6detail12CallArgsBase6lengthEv(this: *mut CallArgsBase) -> u32;
fn _ZNK2JS6detail12CallArgsBase3getEj(this: *mut CallArgsBase, i: u32)
-> HandleValue;
fn _ZNK2JS6detail12CallArgsBase10hasDefinedEj(this: *mut CallArgsBase,
i: u32) -> bool;
fn _ZNK2JS6detail12CallArgsBase9newTargetEv(this: *mut CallArgsBase)
-> MutableHandleValue;
fn _ZNK2JS6detail12CallArgsBase5arrayEv(this: *mut CallArgsBase)
-> *mut Value;
fn _ZNK2JS6detail12CallArgsBase3endEv(this: *mut CallArgsBase)
-> *mut Value;
}
impl CallArgsBase {
#[inline]
pub unsafe extern "C" fn length(&mut self) -> u32 {
_ZNK2JS6detail12CallArgsBase6lengthEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn get(&mut self, i: u32) -> HandleValue {
_ZNK2JS6detail12CallArgsBase3getEj(&mut *self, i)
}
#[inline]
pub unsafe extern "C" fn hasDefined(&mut self, i: u32) -> bool {
_ZNK2JS6detail12CallArgsBase10hasDefinedEj(&mut *self, i)
}
#[inline]
pub unsafe extern "C" fn newTarget(&mut self) -> MutableHandleValue {
_ZNK2JS6detail12CallArgsBase9newTargetEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn array(&mut self) -> *mut Value {
_ZNK2JS6detail12CallArgsBase5arrayEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn end(&mut self) -> *mut Value {
_ZNK2JS6detail12CallArgsBase3endEv(&mut *self)
}
}
#[repr(C)]
#[derive(Copy)]
pub struct CallArgs {
pub _base: CallArgsBase<::libc::c_void>,
}
impl ::std::default::Default for CallArgs {
fn default() -> CallArgs { unsafe { ::std::mem::zeroed() } }
}
extern "C" {
fn _ZN2JS8CallArgs6createEjPNS_5ValueEb(argc: u32, argv: *mut Value,
constructing: bool) -> CallArgs;
fn _ZN2JS8CallArgs14requireAtLeastEP9JSContextPKcj(this: *mut CallArgs,
cx: *mut JSContext,
fnname:
*const ::libc::c_char,
required: u32) -> bool;
}
impl CallArgs {
#[inline]
pub unsafe extern "C" fn create(argc: u32, argv: *mut Value,
constructing: bool) -> CallArgs {
_ZN2JS8CallArgs6createEjPNS_5ValueEb(argc, argv, constructing)
}
#[inline]
pub unsafe extern "C" fn requireAtLeast(&mut self, cx: *mut JSContext,
fnname: *const ::libc::c_char,
required: u32) -> bool {
_ZN2JS8CallArgs14requireAtLeastEP9JSContextPKcj(&mut *self, cx,
fnname, required)
}
}
#[repr(C)]
#[derive(Copy)]
pub struct jsid {
pub asBits: size_t,
}
impl ::std::default::Default for jsid {
fn default() -> jsid { unsafe { ::std::mem::zeroed() } }
}
pub enum JSAtomState { }
pub enum FreeOp { }
#[repr(C)]
#[derive(Copy)]
pub struct ObjectOpResult {
pub code_: uintptr_t,
}
impl ::std::default::Default for ObjectOpResult {
fn default() -> ObjectOpResult { unsafe { ::std::mem::zeroed() } }
}
#[repr(i32)]
#[derive(Copy)]
pub enum ObjectOpResult_SpecialCodes { OkCode = 0, Uninitialized = -1, }
extern "C" {
fn _ZNK2JS14ObjectOpResult2okEv(this: *mut ObjectOpResult) -> bool;
fn _ZN2JS14ObjectOpResult7succeedEv(this: *mut ObjectOpResult) -> bool;
fn _ZN2JS14ObjectOpResult4failEj(this: *mut ObjectOpResult, msg: u32)
-> bool;
fn _ZN2JS14ObjectOpResult20failCantRedefinePropEv(this:
*mut ObjectOpResult)
-> bool;
fn _ZN2JS14ObjectOpResult12failReadOnlyEv(this: *mut ObjectOpResult)
-> bool;
fn _ZN2JS14ObjectOpResult14failGetterOnlyEv(this: *mut ObjectOpResult)
-> bool;
fn _ZN2JS14ObjectOpResult14failCantDeleteEv(this: *mut ObjectOpResult)
-> bool;
fn _ZN2JS14ObjectOpResult21failCantSetInterposedEv(this:
*mut ObjectOpResult)
-> bool;
fn _ZN2JS14ObjectOpResult27failCantDefineWindowElementEv(this:
*mut ObjectOpResult)
-> bool;
fn _ZN2JS14ObjectOpResult27failCantDeleteWindowElementEv(this:
*mut ObjectOpResult)
-> bool;
fn _ZN2JS14ObjectOpResult33failCantDeleteWindowNamedPropertyEv(this:
*mut ObjectOpResult)
-> bool;
fn _ZN2JS14ObjectOpResult25failCantPreventExtensionsEv(this:
*mut ObjectOpResult)
-> bool;
fn _ZN2JS14ObjectOpResult17failNoNamedSetterEv(this: *mut ObjectOpResult)
-> bool;
fn _ZN2JS14ObjectOpResult19failNoIndexedSetterEv(this:
*mut ObjectOpResult)
-> bool;
fn _ZNK2JS14ObjectOpResult11failureCodeEv(this: *mut ObjectOpResult)
-> u32;
fn _ZN2JS14ObjectOpResult25checkStrictErrorOrWarningEP9JSContextNS_6HandleIP8JSObjectEENS3_I4jsidEEb(this:
*mut ObjectOpResult,
cx:
*mut JSContext,
obj:
HandleObject,
id:
HandleId,
strict:
bool)
-> bool;
fn _ZN2JS14ObjectOpResult25checkStrictErrorOrWarningEP9JSContextNS_6HandleIP8JSObjectEEb(this:
*mut ObjectOpResult,
cx:
*mut JSContext,
obj:
HandleObject,
strict:
bool)
-> bool;
fn _ZN2JS14ObjectOpResult11reportErrorEP9JSContextNS_6HandleIP8JSObjectEENS3_I4jsidEE(this:
*mut ObjectOpResult,
cx:
*mut JSContext,
obj:
HandleObject,
id:
HandleId)
-> bool;
fn _ZN2JS14ObjectOpResult11reportErrorEP9JSContextNS_6HandleIP8JSObjectEE(this:
*mut ObjectOpResult,
cx:
*mut JSContext,
obj:
HandleObject)
-> bool;
fn _ZN2JS14ObjectOpResult26reportStrictErrorOrWarningEP9JSContextNS_6HandleIP8JSObjectEENS3_I4jsidEEb(this:
*mut ObjectOpResult,
cx:
*mut JSContext,
obj:
HandleObject,
id:
HandleId,
strict:
bool)
-> bool;
fn _ZN2JS14ObjectOpResult26reportStrictErrorOrWarningEP9JSContextNS_6HandleIP8JSObjectEEb(this:
*mut ObjectOpResult,
cx:
*mut JSContext,
obj:
HandleObject,
strict:
bool)
-> bool;
fn _ZN2JS14ObjectOpResult11checkStrictEP9JSContextNS_6HandleIP8JSObjectEENS3_I4jsidEE(this:
*mut ObjectOpResult,
cx:
*mut JSContext,
obj:
HandleObject,
id:
HandleId)
-> bool;
fn _ZN2JS14ObjectOpResult11checkStrictEP9JSContextNS_6HandleIP8JSObjectEE(this:
*mut ObjectOpResult,
cx:
*mut JSContext,
obj:
HandleObject)
-> bool;
}
impl ObjectOpResult {
#[inline]
pub unsafe extern "C" fn ok(&mut self) -> bool {
_ZNK2JS14ObjectOpResult2okEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn succeed(&mut self) -> bool {
_ZN2JS14ObjectOpResult7succeedEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn fail(&mut self, msg: u32) -> bool {
_ZN2JS14ObjectOpResult4failEj(&mut *self, msg)
}
#[inline]
pub unsafe extern "C" fn failCantRedefineProp(&mut self) -> bool {
_ZN2JS14ObjectOpResult20failCantRedefinePropEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn failReadOnly(&mut self) -> bool {
_ZN2JS14ObjectOpResult12failReadOnlyEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn failGetterOnly(&mut self) -> bool {
_ZN2JS14ObjectOpResult14failGetterOnlyEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn failCantDelete(&mut self) -> bool {
_ZN2JS14ObjectOpResult14failCantDeleteEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn failCantSetInterposed(&mut self) -> bool {
_ZN2JS14ObjectOpResult21failCantSetInterposedEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn failCantDefineWindowElement(&mut self) -> bool {
_ZN2JS14ObjectOpResult27failCantDefineWindowElementEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn failCantDeleteWindowElement(&mut self) -> bool {
_ZN2JS14ObjectOpResult27failCantDeleteWindowElementEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn failCantDeleteWindowNamedProperty(&mut self)
-> bool {
_ZN2JS14ObjectOpResult33failCantDeleteWindowNamedPropertyEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn failCantPreventExtensions(&mut self) -> bool {
_ZN2JS14ObjectOpResult25failCantPreventExtensionsEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn failNoNamedSetter(&mut self) -> bool {
_ZN2JS14ObjectOpResult17failNoNamedSetterEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn failNoIndexedSetter(&mut self) -> bool {
_ZN2JS14ObjectOpResult19failNoIndexedSetterEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn failureCode(&mut self) -> u32 {
_ZNK2JS14ObjectOpResult11failureCodeEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn checkStrictErrorOrWarning(&mut self,
cx: *mut JSContext,
obj: HandleObject,
id: HandleId,
strict: bool) -> bool {
_ZN2JS14ObjectOpResult25checkStrictErrorOrWarningEP9JSContextNS_6HandleIP8JSObjectEENS3_I4jsidEEb(&mut *self,
cx,
obj,
id,
strict)
}
#[inline]
pub unsafe extern "C" fn checkStrictErrorOrWarning1(&mut self,
cx: *mut JSContext,
obj: HandleObject,
strict: bool)
-> bool {
_ZN2JS14ObjectOpResult25checkStrictErrorOrWarningEP9JSContextNS_6HandleIP8JSObjectEEb(&mut *self,
cx,
obj,
strict)
}
#[inline]
pub unsafe extern "C" fn reportError(&mut self, cx: *mut JSContext,
obj: HandleObject, id: HandleId)
-> bool {
_ZN2JS14ObjectOpResult11reportErrorEP9JSContextNS_6HandleIP8JSObjectEENS3_I4jsidEE(&mut *self,
cx,
obj,
id)
}
#[inline]
pub unsafe extern "C" fn reportError1(&mut self, cx: *mut JSContext,
obj: HandleObject) -> bool {
_ZN2JS14ObjectOpResult11reportErrorEP9JSContextNS_6HandleIP8JSObjectEE(&mut *self,
cx,
obj)
}
#[inline]
pub unsafe extern "C" fn reportStrictErrorOrWarning(&mut self,
cx: *mut JSContext,
obj: HandleObject,
id: HandleId,
strict: bool)
-> bool {
_ZN2JS14ObjectOpResult26reportStrictErrorOrWarningEP9JSContextNS_6HandleIP8JSObjectEENS3_I4jsidEEb(&mut *self,
cx,
obj,
id,
strict)
}
#[inline]
pub unsafe extern "C" fn reportStrictErrorOrWarning1(&mut self,
cx: *mut JSContext,
obj: HandleObject,
strict: bool)
-> bool {
_ZN2JS14ObjectOpResult26reportStrictErrorOrWarningEP9JSContextNS_6HandleIP8JSObjectEEb(&mut *self,
cx,
obj,
strict)
}
#[inline]
pub unsafe extern "C" fn checkStrict(&mut self, cx: *mut JSContext,
obj: HandleObject, id: HandleId)
-> bool {
_ZN2JS14ObjectOpResult11checkStrictEP9JSContextNS_6HandleIP8JSObjectEENS3_I4jsidEE(&mut *self,
cx,
obj,
id)
}
#[inline]
pub unsafe extern "C" fn checkStrict1(&mut self, cx: *mut JSContext,
obj: HandleObject) -> bool {
_ZN2JS14ObjectOpResult11checkStrictEP9JSContextNS_6HandleIP8JSObjectEE(&mut *self,
cx,
obj)
}
}
pub type JSGetterOp =
::std::option::Option<unsafe extern "C" fn(cx: *mut JSContext,
obj: HandleObject,
id: HandleId,
vp: MutableHandleValue)
-> bool>;
pub type JSAddPropertyOp =
::std::option::Option<unsafe extern "C" fn(cx: *mut JSContext,
obj: HandleObject,
id: HandleId, v: HandleValue)
-> bool>;
pub type JSSetterOp =
::std::option::Option<unsafe extern "C" fn(cx: *mut JSContext,
obj: HandleObject,
id: HandleId,
vp: MutableHandleValue,
result: &mut ObjectOpResult)
-> bool>;
pub type JSDeletePropertyOp =
::std::option::Option<unsafe extern "C" fn(cx: *mut JSContext,
obj: HandleObject,
id: HandleId,
result: &mut ObjectOpResult)
-> bool>;
pub type JSNewEnumerateOp =
::std::option::Option<unsafe extern "C" fn(cx: *mut JSContext,
obj: HandleObject,
properties: &mut AutoIdVector)
-> bool>;
pub type JSEnumerateOp =
::std::option::Option<unsafe extern "C" fn(cx: *mut JSContext,
obj: HandleObject) -> bool>;
pub type JSResolveOp =
::std::option::Option<unsafe extern "C" fn(cx: *mut JSContext,
obj: HandleObject,
id: HandleId,
resolvedp: *mut bool) -> bool>;
pub type JSMayResolveOp =
::std::option::Option<unsafe extern "C" fn(names: &JSAtomState, id: jsid,
maybeObj: *mut JSObject)
-> bool>;
pub type JSConvertOp =
::std::option::Option<unsafe extern "C" fn(cx: *mut JSContext,
obj: HandleObject,
_type: JSType,
vp: MutableHandleValue)
-> bool>;
pub type JSFinalizeOp =
::std::option::Option<unsafe extern "C" fn(fop: *mut JSFreeOp,
obj: *mut JSObject)>;
#[repr(C)]
#[derive(Copy)]
pub struct JSStringFinalizer {
pub finalize: ::std::option::Option<unsafe extern "C" fn(fin:
*const JSStringFinalizer,
chars:
*mut u16)>,
}
impl ::std::default::Default for JSStringFinalizer {
fn default() -> JSStringFinalizer { unsafe { ::std::mem::zeroed() } }
}
pub type JSHasInstanceOp =
::std::option::Option<unsafe extern "C" fn(cx: *mut JSContext,
obj: HandleObject,
vp: MutableHandleValue,
bp: *mut bool) -> bool>;
pub type JSTraceOp =
::std::option::Option<unsafe extern "C" fn(trc: *mut JSTracer,
obj: *mut JSObject)>;
pub type JSWeakmapKeyDelegateOp =
::std::option::Option<unsafe extern "C" fn(obj: *mut JSObject)
-> *mut JSObject>;
pub type JSObjectMovedOp =
::std::option::Option<unsafe extern "C" fn(obj: *mut JSObject,
old: *const JSObject)>;
pub type LookupPropertyOp =
::std::option::Option<unsafe extern "C" fn(cx: *mut JSContext,
obj: HandleObject,
id: HandleId,
objp: MutableHandleObject,
propp:
MutableHandle<*mut Shape>)
-> bool>;
pub type DefinePropertyOp =
::std::option::Option<unsafe extern "C" fn(cx: *mut JSContext,
obj: HandleObject,
id: HandleId,
desc:
Handle<JSPropertyDescriptor>,
result: &mut ObjectOpResult)
-> bool>;
pub type HasPropertyOp =
::std::option::Option<unsafe extern "C" fn(cx: *mut JSContext,
obj: HandleObject,
id: HandleId,
foundp: *mut bool) -> bool>;
pub type GetPropertyOp =
::std::option::Option<unsafe extern "C" fn(cx: *mut JSContext,
obj: HandleObject,
receiver: HandleObject,
id: HandleId,
vp: MutableHandleValue)
-> bool>;
pub type SetPropertyOp =
::std::option::Option<unsafe extern "C" fn(cx: *mut JSContext,
obj: HandleObject,
id: HandleId, v: HandleValue,
receiver: HandleValue,
result: &mut ObjectOpResult)
-> bool>;
pub type GetOwnPropertyOp =
::std::option::Option<unsafe extern "C" fn(cx: *mut JSContext,
obj: HandleObject,
id: HandleId,
desc:
MutableHandle<JSPropertyDescriptor>)
-> bool>;
pub type DeletePropertyOp =
::std::option::Option<unsafe extern "C" fn(cx: *mut JSContext,
obj: HandleObject,
id: HandleId,
result: &mut ObjectOpResult)
-> bool>;
pub type WatchOp =
::std::option::Option<unsafe extern "C" fn(cx: *mut JSContext,
obj: HandleObject,
id: HandleId,
callable: HandleObject)
-> bool>;
pub type UnwatchOp =
::std::option::Option<unsafe extern "C" fn(cx: *mut JSContext,
obj: HandleObject,
id: HandleId) -> bool>;
#[repr(C)]
#[derive(Copy)]
pub struct ElementAdder {
pub resObj_: RootedObject,
pub vp_: *mut Value,
pub index_: u32,
pub length_: DebugOnly<u32>,
pub getBehavior_: GetBehavior,
}
impl ::std::default::Default for ElementAdder {
fn default() -> ElementAdder { unsafe { ::std::mem::zeroed() } }
}
#[repr(i32)]
#[derive(Copy)]
pub enum ElementAdder_GetBehavior {
CheckHasElemPreserveHoles = 0,
GetElement = 1,
}
extern "C" {
fn _ZNK2js12ElementAdder11getBehaviorEv(this: *mut ElementAdder)
-> GetBehavior;
fn _ZN2js12ElementAdder6appendEP9JSContextN2JS6HandleINS3_5ValueEEE(this:
*mut ElementAdder,
cx:
*mut JSContext,
v:
HandleValue)
-> bool;
fn _ZN2js12ElementAdder10appendHoleEv(this: *mut ElementAdder);
}
impl ElementAdder {
#[inline]
pub unsafe extern "C" fn getBehavior(&mut self) -> GetBehavior {
_ZNK2js12ElementAdder11getBehaviorEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn append(&mut self, cx: *mut JSContext,
v: HandleValue) -> bool {
_ZN2js12ElementAdder6appendEP9JSContextN2JS6HandleINS3_5ValueEEE(&mut *self,
cx,
v)
}
#[inline]
pub unsafe extern "C" fn appendHole(&mut self) {
_ZN2js12ElementAdder10appendHoleEv(&mut *self)
}
}
pub type GetElementsOp =
::std::option::Option<unsafe extern "C" fn(cx: *mut JSContext,
obj: HandleObject, begin: u32,
end: u32,
adder: *mut ElementAdder)
-> bool>;
pub type ObjectOp =
::std::option::Option<unsafe extern "C" fn(cx: *mut JSContext,
obj: HandleObject)
-> *mut JSObject>;
pub type InnerObjectOp =
::std::option::Option<unsafe extern "C" fn(obj: *mut JSObject)
-> *mut JSObject>;
pub type FinalizeOp =
::std::option::Option<unsafe extern "C" fn(fop: *mut FreeOp,
obj: *mut JSObject)>;
pub type ClassObjectCreationOp =
::std::option::Option<unsafe extern "C" fn(cx: *mut JSContext,
key: JSProtoKey)
-> *mut JSObject>;
pub type FinishClassInitOp =
::std::option::Option<unsafe extern "C" fn(cx: *mut JSContext,
ctor: HandleObject,
proto: HandleObject) -> bool>;
#[repr(C)]
#[derive(Copy)]
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: uintptr_t,
}
impl ::std::default::Default for ClassSpec {
fn default() -> ClassSpec { unsafe { ::std::mem::zeroed() } }
}
extern "C" {
fn _ZNK2js9ClassSpec7definedEv(this: *mut ClassSpec) -> bool;
fn _ZNK2js9ClassSpec9delegatedEv(this: *mut ClassSpec) -> bool;
fn _ZNK2js9ClassSpec9dependentEv(this: *mut ClassSpec) -> bool;
fn _ZNK2js9ClassSpec9parentKeyEv(this: *mut ClassSpec) -> JSProtoKey;
fn _ZNK2js9ClassSpec23shouldDefineConstructorEv(this: *mut ClassSpec)
-> bool;
fn _ZNK2js9ClassSpec18delegatedClassSpecEv(this: *mut ClassSpec)
-> *const ClassSpec;
fn _ZNK2js9ClassSpec21createConstructorHookEv(this: *mut ClassSpec)
-> ClassObjectCreationOp;
fn _ZNK2js9ClassSpec19createPrototypeHookEv(this: *mut ClassSpec)
-> ClassObjectCreationOp;
fn _ZNK2js9ClassSpec20constructorFunctionsEv(this: *mut ClassSpec)
-> *const JSFunctionSpec;
fn _ZNK2js9ClassSpec21constructorPropertiesEv(this: *mut ClassSpec)
-> *const JSPropertySpec;
fn _ZNK2js9ClassSpec18prototypeFunctionsEv(this: *mut ClassSpec)
-> *const JSFunctionSpec;
fn _ZNK2js9ClassSpec19prototypePropertiesEv(this: *mut ClassSpec)
-> *const JSPropertySpec;
fn _ZNK2js9ClassSpec14finishInitHookEv(this: *mut ClassSpec)
-> FinishClassInitOp;
}
impl ClassSpec {
#[inline]
pub unsafe extern "C" fn defined(&mut self) -> bool {
_ZNK2js9ClassSpec7definedEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn delegated(&mut self) -> bool {
_ZNK2js9ClassSpec9delegatedEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn dependent(&mut self) -> bool {
_ZNK2js9ClassSpec9dependentEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn parentKey(&mut self) -> JSProtoKey {
_ZNK2js9ClassSpec9parentKeyEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn shouldDefineConstructor(&mut self) -> bool {
_ZNK2js9ClassSpec23shouldDefineConstructorEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn delegatedClassSpec(&mut self)
-> *const ClassSpec {
_ZNK2js9ClassSpec18delegatedClassSpecEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn createConstructorHook(&mut self)
-> ClassObjectCreationOp {
_ZNK2js9ClassSpec21createConstructorHookEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn createPrototypeHook(&mut self)
-> ClassObjectCreationOp {
_ZNK2js9ClassSpec19createPrototypeHookEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn constructorFunctions(&mut self)
-> *const JSFunctionSpec {
_ZNK2js9ClassSpec20constructorFunctionsEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn constructorProperties(&mut self)
-> *const JSPropertySpec {
_ZNK2js9ClassSpec21constructorPropertiesEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn prototypeFunctions(&mut self)
-> *const JSFunctionSpec {
_ZNK2js9ClassSpec18prototypeFunctionsEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn prototypeProperties(&mut self)
-> *const JSPropertySpec {
_ZNK2js9ClassSpec19prototypePropertiesEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn finishInitHook(&mut self) -> FinishClassInitOp {
_ZNK2js9ClassSpec14finishInitHookEv(&mut *self)
}
}
#[repr(C)]
#[derive(Copy)]
pub struct ClassExtension {
pub outerObject: ObjectOp,
pub innerObject: InnerObjectOp,
pub isWrappedNative: bool,
pub weakmapKeyDelegateOp: JSWeakmapKeyDelegateOp,
pub objectMovedOp: JSObjectMovedOp,
}
impl ::std::default::Default for ClassExtension {
fn default() -> ClassExtension { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
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<unsafe extern "C" fn()>;
#[repr(C)]
#[derive(Copy)]
pub struct JSClass {
pub name: *const ::libc::c_char,
pub flags: u32,
pub addProperty: JSAddPropertyOp,
pub delProperty: JSDeletePropertyOp,
pub getProperty: JSGetterOp,
pub setProperty: JSSetterOp,
pub enumerate: JSEnumerateOp,
pub resolve: JSResolveOp,
pub mayResolve: JSMayResolveOp,
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)]
pub struct Class {
pub name: *const ::libc::c_char,
pub flags: u32,
pub addProperty: JSAddPropertyOp,
pub delProperty: JSDeletePropertyOp,
pub getProperty: JSGetterOp,
pub setProperty: JSSetterOp,
pub enumerate: JSEnumerateOp,
pub resolve: JSResolveOp,
pub mayResolve: JSMayResolveOp,
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() } }
}
extern "C" {
fn _ZNK2js5Class8isNativeEv(this: *mut Class) -> bool;
fn _ZNK2js5Class10hasPrivateEv(this: *mut Class) -> bool;
fn _ZNK2js5Class17emulatesUndefinedEv(this: *mut Class) -> bool;
fn _ZNK2js5Class12isJSFunctionEv(this: *mut Class) -> bool;
fn _ZNK2js5Class16nonProxyCallableEv(this: *mut Class) -> bool;
fn _ZNK2js5Class7isProxyEv(this: *mut Class) -> bool;
fn _ZNK2js5Class10isDOMClassEv(this: *mut Class) -> bool;
fn _ZNK2js5Class27shouldDelayMetadataCallbackEv(this: *mut Class) -> bool;
fn _ZN2js5Class13offsetOfFlagsEv() -> size_t;
}
impl Class {
#[inline]
pub unsafe extern "C" fn isNative(&mut self) -> bool {
_ZNK2js5Class8isNativeEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn hasPrivate(&mut self) -> bool {
_ZNK2js5Class10hasPrivateEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn emulatesUndefined(&mut self) -> bool {
_ZNK2js5Class17emulatesUndefinedEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn isJSFunction(&mut self) -> bool {
_ZNK2js5Class12isJSFunctionEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn nonProxyCallable(&mut self) -> bool {
_ZNK2js5Class16nonProxyCallableEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn isProxy(&mut self) -> bool {
_ZNK2js5Class7isProxyEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn isDOMClass(&mut self) -> bool {
_ZNK2js5Class10isDOMClassEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn shouldDelayMetadataCallback(&mut self) -> bool {
_ZNK2js5Class27shouldDelayMetadataCallbackEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn offsetOfFlags() -> size_t {
_ZN2js5Class13offsetOfFlagsEv()
}
}
#[repr(i32)]
#[derive(Copy)]
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(C)]
#[derive(Copy)]
pub struct HashMap<Key, Value, HashPolicy, AllocPolicy> {
pub _impl: Impl,
}
#[repr(C)]
#[derive(Copy)]
pub struct MapHashPolicy {
pub _base: HashPolicy,
}
impl ::std::default::Default for MapHashPolicy {
fn default() -> MapHashPolicy { unsafe { ::std::mem::zeroed() } }
}
extern "C" {
fn _ZN2js7HashMap13MapHashPolicy6getKeyERNS_12HashMapEntryIT_T0_EE(e:
&mut TableEntry)
-> *const Key;
fn _ZN2js7HashMap13MapHashPolicy6setKeyERNS_12HashMapEntryIT_T0_EERS3_(e:
&mut TableEntry,
k:
&mut Key);
}
impl MapHashPolicy {
#[inline]
pub unsafe extern "C" fn getKey(e: &mut TableEntry) -> *const Key {
_ZN2js7HashMap13MapHashPolicy6getKeyERNS_12HashMapEntryIT_T0_EE(e)
}
#[inline]
pub unsafe extern "C" fn setKey(e: &mut TableEntry, k: &mut Key) {
_ZN2js7HashMap13MapHashPolicy6setKeyERNS_12HashMapEntryIT_T0_EERS3_(e,
k)
}
}
/*****************************************************************************/
#[repr(C)]
#[derive(Copy)]
pub struct HashSet<T, HashPolicy, AllocPolicy> {
pub _impl: Impl,
}
#[repr(C)]
#[derive(Copy)]
pub struct SetOps {
pub _base: HashPolicy,
}
impl ::std::default::Default for SetOps {
fn default() -> SetOps { unsafe { ::std::mem::zeroed() } }
}
extern "C" {
fn _ZN2js7HashSet6SetOps6getKeyERKT_(t: &T) -> *const KeyType;
fn _ZN2js7HashSet6SetOps6setKeyERT_S3_(t: &mut T, k: &mut KeyType);
}
impl SetOps {
#[inline]
pub unsafe extern "C" fn getKey(t: &T) -> *const KeyType {
_ZN2js7HashSet6SetOps6getKeyERKT_(t)
}
#[inline]
pub unsafe extern "C" fn setKey(t: &mut T, k: &mut KeyType) {
_ZN2js7HashSet6SetOps6setKeyERT_S3_(t, k)
}
}
#[repr(C)]
#[derive(Copy)]
pub struct PointerHasher<Key>;
#[repr(C)]
#[derive(Copy)]
pub struct DefaultHasher<Key>;
#[repr(C)]
#[derive(Copy)]
pub struct DefaultHasher;
impl ::std::default::Default for DefaultHasher {
fn default() -> DefaultHasher { unsafe { ::std::mem::zeroed() } }
}
extern "C" {
fn _ZN2js13DefaultHasherIdE4hashEd(d: f64) -> HashNumber;
fn _ZN2js13DefaultHasherIdE5matchEdd(lhs: f64, rhs: f64) -> bool;
}
impl DefaultHasher {
#[inline]
pub unsafe extern "C" fn hash(d: f64) -> HashNumber {
_ZN2js13DefaultHasherIdE4hashEd(d)
}
#[inline]
pub unsafe extern "C" fn match(lhs: f64, rhs: f64) -> bool {
_ZN2js13DefaultHasherIdE5matchEdd(lhs, rhs)
}
}
#[repr(C)]
#[derive(Copy)]
pub struct HashMapEntry<Key, Value> {
pub key_: Key,
pub value_: Value,
}
#[repr(C)]
#[derive(Copy)]
pub struct HashTableEntry<T> {
pub keyHash: HashNumber,
pub mem: AlignedStorage2,
}
#[repr(C)]
#[derive(Copy)]
pub struct HashTable<T, HashPolicy, AllocPolicy> {
pub _base: AllocPolicy,
pub table: *mut Entry,
pub _bitfield_1: u32,
pub entryCount: u32,
pub removedCount: u32,
}
#[repr(C)]
#[derive(Copy)]
pub struct DoubleHash {
pub h2: HashNumber,
pub sizeMask: HashNumber,
}
impl ::std::default::Default for DoubleHash {
fn default() -> DoubleHash { unsafe { ::std::mem::zeroed() } }
}
#[repr(i32)]
#[derive(Copy)]
pub enum HashTable_RebuildStatus {
NotOverloaded = 0,
Rehashed = 0,
RehashFailed = 0,
}
impl HashTable {
pub fn set_gen(&mut self, val: u32) {
self._bitfield_1 &= !(((1 << 24u32) - 1) << 0usize);
self._bitfield_1 |= (val as u32) << 0usize;
}
pub fn set_hashShift(&mut self, val: u8) {
self._bitfield_1 &= !(((1 << 8u32) - 1) << 24usize);
self._bitfield_1 |= (val as u32) << 24usize;
}
pub const fn new_bitfield_1(gen: u32, hashShift: u8) -> u32 {
0 | ((gen as u32) << 0u32) | ((hashShift as u32) << 24u32)
}
}
#[repr(i32)]
#[derive(Copy)]
pub enum MemoryOrdering {
Relaxed = 0,
ReleaseAcquire = 1,
SequentiallyConsistent = 2,
}
pub enum AtomicOrderConstraints { }
#[repr(C)]
#[derive(Copy)]
pub struct AtomicOrderConstraints;
impl ::std::default::Default for AtomicOrderConstraints {
fn default() -> AtomicOrderConstraints { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct IntrinsicBase<T>;
#[repr(C)]
#[derive(Copy)]
pub struct IntrinsicMemoryOps<T> {
pub _base: IntrinsicBase<T>,
}
#[repr(C)]
#[derive(Copy)]
pub struct IntrinsicAddSub<T> {
pub _base: IntrinsicBase<T>,
}
#[repr(C)]
#[derive(Copy)]
pub struct IntrinsicIncDec<T> {
pub _base: IntrinsicAddSub<T>,
}
#[repr(C)]
#[derive(Copy)]
pub struct AtomicIntrinsics<T> {
pub _base: IntrinsicMemoryOps<T>,
pub _base1: IntrinsicIncDec<T>,
}
#[repr(C)]
#[derive(Copy)]
pub struct AtomicBase<T> {
pub mValue: typename Intrinsics::ValueType,
}
#[repr(C)]
#[derive(Copy)]
pub struct AtomicBaseIncDec<T> {
pub _base: AtomicBase<T>,
}
pub enum Atomic { }
#[repr(C)]
#[derive(Copy)]
pub struct JSPrincipals {
pub refcount: Atomic<i32, ::libc::c_void, ::libc::c_void>,
}
impl ::std::default::Default for JSPrincipals {
fn default() -> JSPrincipals { unsafe { ::std::mem::zeroed() } }
}
extern "C" {
fn _ZN12JSPrincipals13setDebugTokenEj(this: *mut JSPrincipals,
token: u32);
fn _ZN12JSPrincipals4dumpEv(this: *mut JSPrincipals);
}
impl JSPrincipals {
#[inline]
pub unsafe extern "C" fn setDebugToken(&mut self, token: u32) {
_ZN12JSPrincipals13setDebugTokenEj(&mut *self, token)
}
#[inline]
pub unsafe extern "C" fn dump(&mut self) {
_ZN12JSPrincipals4dumpEv(&mut *self)
}
}
pub type JSSubsumesOp =
::std::option::Option<unsafe extern "C" fn(first: *mut JSPrincipals,
second: *mut JSPrincipals)
-> bool>;
pub type JSCSPEvalChecker =
::std::option::Option<unsafe extern "C" fn(cx: *mut JSContext) -> bool>;
#[repr(C)]
#[derive(Copy)]
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<unsafe extern "C" fn(principals:
*mut JSPrincipals)>;
pub enum BaseShape { }
pub enum LazyScript { }
pub enum ObjectGroup { }
pub enum JitCode { }
#[repr(i32)]
#[derive(Copy)]
pub enum WeakMapTraceKind {
DoNotTraceWeakMaps = 0,
TraceWeakMapValues = 1,
TraceWeakMapKeysValues = 2,
}
#[repr(C)]
#[derive(Copy)]
pub struct JSTracer {
pub runtime_: *mut JSRuntime,
pub tag_: TracerKindTag,
pub eagerlyTraceWeakMaps_: WeakMapTraceKind,
}
impl ::std::default::Default for JSTracer {
fn default() -> JSTracer { unsafe { ::std::mem::zeroed() } }
}
#[repr(i32)]
#[derive(Copy)]
pub enum JSTracer_TracerKindTag { Marking = 0, Tenuring = 1, Callback = 2, }
extern "C" {
fn _ZNK8JSTracer7runtimeEv(this: *mut JSTracer) -> *mut JSRuntime;
fn _ZNK8JSTracer20eagerlyTraceWeakMapsEv(this: *mut JSTracer)
-> WeakMapTraceKind;
fn _ZNK8JSTracer15isMarkingTracerEv(this: *mut JSTracer) -> bool;
fn _ZNK8JSTracer16isTenuringTracerEv(this: *mut JSTracer) -> bool;
fn _ZNK8JSTracer16isCallbackTracerEv(this: *mut JSTracer) -> bool;
fn _ZN8JSTracer16asCallbackTracerEv(this: *mut JSTracer)
-> *mut CallbackTracer;
}
impl JSTracer {
#[inline]
pub unsafe extern "C" fn runtime(&mut self) -> *mut JSRuntime {
_ZNK8JSTracer7runtimeEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn eagerlyTraceWeakMaps(&mut self)
-> WeakMapTraceKind {
_ZNK8JSTracer20eagerlyTraceWeakMapsEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn isMarkingTracer(&mut self) -> bool {
_ZNK8JSTracer15isMarkingTracerEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn isTenuringTracer(&mut self) -> bool {
_ZNK8JSTracer16isTenuringTracerEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn isCallbackTracer(&mut self) -> bool {
_ZNK8JSTracer16isCallbackTracerEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn asCallbackTracer(&mut self)
-> *mut CallbackTracer {
_ZN8JSTracer16asCallbackTracerEv(&mut *self)
}
}
pub enum AutoTracingCallback { }
#[repr(C)]
#[derive(Copy)]
pub struct CallbackTracer {
pub _vftable: *const _vftable_CallbackTracer,
pub _base: JSTracer,
pub contextName_: *const ::libc::c_char,
pub contextIndex_: size_t,
pub contextFunctor_: *mut ContextFunctor,
}
impl ::std::default::Default for CallbackTracer {
fn default() -> CallbackTracer { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
pub struct _vftable_CallbackTracer {
pub onObjectEdge: extern "C" fn(this: *mut ::libc::c_void,
objp: *mut *mut JSObject),
pub onStringEdge: extern "C" fn(this: *mut ::libc::c_void,
strp: *mut *mut JSString),
pub onSymbolEdge: extern "C" fn(this: *mut ::libc::c_void,
symp: *mut *mut Symbol),
pub onScriptEdge: extern "C" fn(this: *mut ::libc::c_void,
scriptp: *mut *mut JSScript),
pub onShapeEdge: extern "C" fn(this: *mut ::libc::c_void,
shapep: *mut *mut Shape),
pub onObjectGroupEdge: extern "C" fn(this: *mut ::libc::c_void,
groupp: *mut *mut ObjectGroup),
pub onBaseShapeEdge: extern "C" fn(this: *mut ::libc::c_void,
basep: *mut *mut BaseShape),
pub onJitCodeEdge: extern "C" fn(this: *mut ::libc::c_void,
codep: *mut *mut JitCode),
pub onLazyScriptEdge: extern "C" fn(this: *mut ::libc::c_void,
lazyp: *mut *mut LazyScript),
pub onChild: extern "C" fn(this: *mut ::libc::c_void, thing: &GCCellPtr),
}
extern "C" {
fn _ZNK2JS14CallbackTracer11contextNameEv(this: *mut CallbackTracer)
-> *const ::libc::c_char;
fn _ZNK2JS14CallbackTracer12contextIndexEv(this: *mut CallbackTracer)
-> size_t;
fn _ZN2JS14CallbackTracer18getTracingEdgeNameEPcj(this:
*mut CallbackTracer,
buffer:
*mut ::libc::c_char,
bufferSize: size_t);
fn _ZN2JS14CallbackTracer16dispatchToOnEdgeEPP8JSObject(this:
*mut CallbackTracer,
objp:
*mut *mut JSObject);
fn _ZN2JS14CallbackTracer16dispatchToOnEdgeEPP8JSString(this:
*mut CallbackTracer,
strp:
*mut *mut JSString);
fn _ZN2JS14CallbackTracer16dispatchToOnEdgeEPPNS_6SymbolE(this:
*mut CallbackTracer,
symp:
*mut *mut Symbol);
fn _ZN2JS14CallbackTracer16dispatchToOnEdgeEPP8JSScript(this:
*mut CallbackTracer,
scriptp:
*mut *mut JSScript);
fn _ZN2JS14CallbackTracer16dispatchToOnEdgeEPPN2js5ShapeE(this:
*mut CallbackTracer,
shapep:
*mut *mut Shape);
fn _ZN2JS14CallbackTracer16dispatchToOnEdgeEPPN2js11ObjectGroupE(this:
*mut CallbackTracer,
groupp:
*mut *mut ObjectGroup);
fn _ZN2JS14CallbackTracer16dispatchToOnEdgeEPPN2js9BaseShapeE(this:
*mut CallbackTracer,
basep:
*mut *mut BaseShape);
fn _ZN2JS14CallbackTracer16dispatchToOnEdgeEPPN2js3jit7JitCodeE(this:
*mut CallbackTracer,
codep:
*mut *mut JitCode);
fn _ZN2JS14CallbackTracer16dispatchToOnEdgeEPPN2js10LazyScriptE(this:
*mut CallbackTracer,
lazyp:
*mut *mut LazyScript);
}
impl CallbackTracer {
#[inline]
pub unsafe extern "C" fn contextName(&mut self) -> *const ::libc::c_char {
_ZNK2JS14CallbackTracer11contextNameEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn contextIndex(&mut self) -> size_t {
_ZNK2JS14CallbackTracer12contextIndexEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn getTracingEdgeName(&mut self,
buffer: *mut ::libc::c_char,
bufferSize: size_t) {
_ZN2JS14CallbackTracer18getTracingEdgeNameEPcj(&mut *self, buffer,
bufferSize)
}
#[inline]
pub unsafe extern "C" fn dispatchToOnEdge(&mut self,
objp: *mut *mut JSObject) {
_ZN2JS14CallbackTracer16dispatchToOnEdgeEPP8JSObject(&mut *self, objp)
}
#[inline]
pub unsafe extern "C" fn dispatchToOnEdge1(&mut self,
strp: *mut *mut JSString) {
_ZN2JS14CallbackTracer16dispatchToOnEdgeEPP8JSString(&mut *self, strp)
}
#[inline]
pub unsafe extern "C" fn dispatchToOnEdge2(&mut self,
symp: *mut *mut Symbol) {
_ZN2JS14CallbackTracer16dispatchToOnEdgeEPPNS_6SymbolE(&mut *self,
symp)
}
#[inline]
pub unsafe extern "C" fn dispatchToOnEdge3(&mut self,
scriptp: *mut *mut JSScript) {
_ZN2JS14CallbackTracer16dispatchToOnEdgeEPP8JSScript(&mut *self,
scriptp)
}
#[inline]
pub unsafe extern "C" fn dispatchToOnEdge4(&mut self,
shapep: *mut *mut Shape) {
_ZN2JS14CallbackTracer16dispatchToOnEdgeEPPN2js5ShapeE(&mut *self,
shapep)
}
#[inline]
pub unsafe extern "C" fn dispatchToOnEdge5(&mut self,
groupp:
*mut *mut ObjectGroup) {
_ZN2JS14CallbackTracer16dispatchToOnEdgeEPPN2js11ObjectGroupE(&mut *self,
groupp)
}
#[inline]
pub unsafe extern "C" fn dispatchToOnEdge6(&mut self,
basep: *mut *mut BaseShape) {
_ZN2JS14CallbackTracer16dispatchToOnEdgeEPPN2js9BaseShapeE(&mut *self,
basep)
}
#[inline]
pub unsafe extern "C" fn dispatchToOnEdge7(&mut self,
codep: *mut *mut JitCode) {
_ZN2JS14CallbackTracer16dispatchToOnEdgeEPPN2js3jit7JitCodeE(&mut *self,
codep)
}
#[inline]
pub unsafe extern "C" fn dispatchToOnEdge8(&mut self,
lazyp: *mut *mut LazyScript) {
_ZN2JS14CallbackTracer16dispatchToOnEdgeEPPN2js10LazyScriptE(&mut *self,
lazyp)
}
}
#[repr(C)]
#[derive(Copy)]
pub struct AutoTracingName {
pub trc_: *mut CallbackTracer,
pub prior_: *const ::libc::c_char,
}
impl ::std::default::Default for AutoTracingName {
fn default() -> AutoTracingName { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct AutoTracingIndex {
pub trc_: *mut CallbackTracer,
}
impl ::std::default::Default for AutoTracingIndex {
fn default() -> AutoTracingIndex { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct AutoTracingDetails {
pub trc_: *mut CallbackTracer,
}
impl ::std::default::Default for AutoTracingDetails {
fn default() -> AutoTracingDetails { unsafe { ::std::mem::zeroed() } }
}
pub type ZoneSet = HashSet<*mut Zone, DefaultHasher, SystemAllocPolicy>;
#[repr(C)]
#[derive(Copy)]
pub struct Vector<T, AllocPolicy> {
pub _base: VectorBase,
}
pub enum TwoByteChars { }
#[repr(C)]
#[derive(Copy)]
pub struct AutoValueArray {
pub _base: AutoGCRooter,
pub length_: size_t,
pub elements_: *mut Value,
}
impl ::std::default::Default for AutoValueArray {
fn default() -> AutoValueArray { unsafe { ::std::mem::zeroed() } }
}
extern "C" {
fn _ZNK2JS14AutoValueArray6lengthEv(this: *mut AutoValueArray) -> u32;
fn _ZNK2JS14AutoValueArray5beginEv(this: *mut AutoValueArray)
-> *const Value;
fn _ZN2JS14AutoValueArray5beginEv(this: *mut AutoValueArray)
-> *mut Value;
}
impl AutoValueArray {
#[inline]
pub unsafe extern "C" fn length(&mut self) -> u32 {
_ZNK2JS14AutoValueArray6lengthEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn begin(&mut self) -> *const Value {
_ZNK2JS14AutoValueArray5beginEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn begin1(&mut self) -> *mut Value {
_ZN2JS14AutoValueArray5beginEv(&mut *self)
}
}
#[repr(C)]
#[derive(Copy)]
pub struct AutoVectorRooterBase<T> {
pub _base: AutoGCRooter,
pub vector: VectorImpl,
}
#[repr(C)]
#[derive(Copy)]
pub struct AutoVectorRooter<T> {
pub _base: AutoVectorRooterBase<T>,
}
pub type AutoValueVector = AutoVectorRooter<Value>;
pub type AutoObjectVector = AutoVectorRooter<*mut JSObject>;
pub type AutoFunctionVector = AutoVectorRooter<*mut JSFunction>;
pub type AutoScriptVector = AutoVectorRooter<*mut JSScript>;
#[repr(C)]
#[derive(Copy)]
pub struct AutoHashMapRooter<Key, Value> {
pub _base: AutoGCRooter,
pub map: HashMapImpl,
}
#[repr(C)]
#[derive(Copy)]
pub struct AutoHashSetRooter<T> {
pub _base: AutoGCRooter,
pub set: HashSetImpl,
}
#[repr(C)]
#[derive(Copy)]
pub struct CustomAutoRooter {
pub _vftable: *const _vftable_CustomAutoRooter,
pub _base: AutoGCRooter,
}
impl ::std::default::Default for CustomAutoRooter {
fn default() -> CustomAutoRooter { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
pub struct _vftable_CustomAutoRooter {
pub trace: extern "C" fn(this: *mut ::libc::c_void, trc: *mut JSTracer),
}
#[repr(C)]
#[derive(Copy)]
pub struct RootedGeneric<T> {
pub _base: CustomAutoRooter,
pub value: T,
}
#[repr(C)]
#[derive(Copy)]
pub struct HandleValueArray {
pub length_: size_t,
pub elements_: *const Value,
}
impl ::std::default::Default for HandleValueArray {
fn default() -> HandleValueArray { unsafe { ::std::mem::zeroed() } }
}
extern "C" {
fn _ZN2JS16HandleValueArray18fromMarkedLocationEjPKNS_5ValueE(len: size_t,
elements:
*const Value)
-> HandleValueArray;
fn _ZN2JS16HandleValueArray8subarrayERKS0_jj(values: &HandleValueArray,
startIndex: size_t,
len: size_t)
-> HandleValueArray;
fn _ZN2JS16HandleValueArray5emptyEv() -> HandleValueArray;
fn _ZNK2JS16HandleValueArray6lengthEv(this: *mut HandleValueArray)
-> size_t;
fn _ZNK2JS16HandleValueArray5beginEv(this: *mut HandleValueArray)
-> *const Value;
}
impl HandleValueArray {
#[inline]
pub unsafe extern "C" fn fromMarkedLocation(len: size_t,
elements: *const Value)
-> HandleValueArray {
_ZN2JS16HandleValueArray18fromMarkedLocationEjPKNS_5ValueE(len,
elements)
}
#[inline]
pub unsafe extern "C" fn subarray(values: &HandleValueArray,
startIndex: size_t, len: size_t)
-> HandleValueArray {
_ZN2JS16HandleValueArray8subarrayERKS0_jj(values, startIndex, len)
}
#[inline]
pub unsafe extern "C" fn empty() -> HandleValueArray {
_ZN2JS16HandleValueArray5emptyEv()
}
#[inline]
pub unsafe extern "C" fn length(&mut self) -> size_t {
_ZNK2JS16HandleValueArray6lengthEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn begin(&mut self) -> *const Value {
_ZNK2JS16HandleValueArray5beginEv(&mut *self)
}
}
/************************************************************************/
#[repr(C)]
#[derive(Copy)]
pub struct JSFreeOp {
pub runtime_: *mut JSRuntime,
}
impl ::std::default::Default for JSFreeOp {
fn default() -> JSFreeOp { unsafe { ::std::mem::zeroed() } }
}
extern "C" {
fn _ZNK8JSFreeOp7runtimeEv(this: *mut JSFreeOp) -> *mut JSRuntime;
}
impl JSFreeOp {
#[inline]
pub unsafe extern "C" fn runtime(&mut self) -> *mut JSRuntime {
_ZNK8JSFreeOp7runtimeEv(&mut *self)
}
}
#[repr(i32)]
#[derive(Copy)]
pub enum JSContextOp { JSCONTEXT_NEW = 0, JSCONTEXT_DESTROY = 1, }
pub type JSContextCallback =
::std::option::Option<unsafe extern "C" fn(cx: *mut JSContext,
contextOp: u32,
data: *mut ::libc::c_void)
-> bool>;
#[repr(i32)]
#[derive(Copy)]
pub enum JSGCStatus { JSGC_BEGIN = 0, JSGC_END = 1, }
pub type JSGCCallback =
::std::option::Option<unsafe extern "C" fn(rt: *mut JSRuntime,
status: JSGCStatus,
data: *mut ::libc::c_void)>;
#[repr(i32)]
#[derive(Copy)]
pub enum JSFinalizeStatus {
JSFINALIZE_GROUP_START = 0,
JSFINALIZE_GROUP_END = 1,
JSFINALIZE_COLLECTION_END = 2,
}
pub type JSFinalizeCallback =
::std::option::Option<unsafe extern "C" fn(fop: *mut JSFreeOp,
status: JSFinalizeStatus,
isCompartment: bool,
data: *mut ::libc::c_void)>;
pub type JSWeakPointerCallback =
::std::option::Option<unsafe extern "C" fn(rt: *mut JSRuntime,
data: *mut ::libc::c_void)>;
pub type JSInterruptCallback =
::std::option::Option<unsafe extern "C" fn(cx: *mut JSContext) -> bool>;
pub type JSErrorReporter =
::std::option::Option<unsafe extern "C" fn(cx: *mut JSContext,
message: *const ::libc::c_char,
report: *mut JSErrorReport)>;
#[repr(i32)]
#[derive(Copy)]
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)]
pub struct JSErrorFormatString {
pub format: *const ::libc::c_char,
pub argCount: u16,
pub exnType: i16,
}
impl ::std::default::Default for JSErrorFormatString {
fn default() -> JSErrorFormatString { unsafe { ::std::mem::zeroed() } }
}
pub type JSErrorCallback =
::std::option::Option<unsafe extern "C" fn(userRef: *mut ::libc::c_void,
errorNumber: u32)
-> *const JSErrorFormatString>;
pub type JSLocaleToUpperCase =
::std::option::Option<unsafe extern "C" fn(cx: *mut JSContext,
src: HandleString,
rval: MutableHandleValue)
-> bool>;
pub type JSLocaleToLowerCase =
::std::option::Option<unsafe extern "C" fn(cx: *mut JSContext,
src: HandleString,
rval: MutableHandleValue)
-> bool>;
pub type JSLocaleCompare =
::std::option::Option<unsafe extern "C" fn(cx: *mut JSContext,
src1: HandleString,
src2: HandleString,
rval: MutableHandleValue)
-> bool>;
pub type JSLocaleToUnicode =
::std::option::Option<unsafe extern "C" fn(cx: *mut JSContext,
src: *const ::libc::c_char,
rval: MutableHandleValue)
-> bool>;
pub type JSWrapObjectCallback =
::std::option::Option<unsafe extern "C" fn(cx: *mut JSContext,
existing: HandleObject,
obj: HandleObject)
-> *mut JSObject>;
pub type JSPreWrapCallback =
::std::option::Option<unsafe extern "C" fn(cx: *mut JSContext,
scope: HandleObject,
obj: HandleObject,
objectPassedToWrap:
HandleObject)
-> *mut JSObject>;
#[repr(C)]
#[derive(Copy)]
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 =
::std::option::Option<unsafe extern "C" fn(fop: *mut JSFreeOp,
compartment:
*mut JSCompartment)>;
pub type JSZoneCallback =
::std::option::Option<unsafe extern "C" fn(zone: *mut Zone)>;
pub type JSCompartmentNameCallback =
::std::option::Option<unsafe extern "C" fn(rt: *mut JSRuntime,
compartment:
*mut JSCompartment,
buf: *mut ::libc::c_char,
bufsize: size_t)>;
pub type JSCurrentPerfGroupCallback =
::std::option::Option<unsafe extern "C" fn(arg1: *mut JSContext)
-> *mut ::libc::c_void>;
#[repr(C)]
#[derive(Copy)]
pub struct SourceBufferHolder {
pub data_: *const u16,
pub length_: size_t,
pub ownsChars_: bool,
}
impl ::std::default::Default for SourceBufferHolder {
fn default() -> SourceBufferHolder { unsafe { ::std::mem::zeroed() } }
}
#[repr(i32)]
#[derive(Copy)]
pub enum SourceBufferHolder_Ownership { NoOwnership = 0, GiveOwnership = 1, }
extern "C" {
fn _ZNK2JS18SourceBufferHolder3getEv(this: *mut SourceBufferHolder)
-> *const u16;
fn _ZNK2JS18SourceBufferHolder6lengthEv(this: *mut SourceBufferHolder)
-> size_t;
fn _ZNK2JS18SourceBufferHolder9ownsCharsEv(this: *mut SourceBufferHolder)
-> bool;
fn _ZN2JS18SourceBufferHolder4takeEv(this: *mut SourceBufferHolder)
-> *mut u16;
}
impl SourceBufferHolder {
#[inline]
pub unsafe extern "C" fn get(&mut self) -> *const u16 {
_ZNK2JS18SourceBufferHolder3getEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn length(&mut self) -> size_t {
_ZNK2JS18SourceBufferHolder6lengthEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn ownsChars(&mut self) -> bool {
_ZNK2JS18SourceBufferHolder9ownsCharsEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn take(&mut self) -> *mut u16 {
_ZN2JS18SourceBufferHolder4takeEv(&mut *self)
}
}
pub type JS_ICUAllocFn =
::std::option::Option<unsafe extern "C" fn(arg1: *const ::libc::c_void,
size: size_t)
-> *mut ::libc::c_void>;
pub type JS_ICUReallocFn =
::std::option::Option<unsafe extern "C" fn(arg1: *const ::libc::c_void,
p: *mut ::libc::c_void,
size: size_t)
-> *mut ::libc::c_void>;
pub type JS_ICUFreeFn =
::std::option::Option<unsafe extern "C" fn(arg1: *const ::libc::c_void,
p: *mut ::libc::c_void)>;
pub type JS_CurrentEmbedderTimeFunction =
::std::option::Option<unsafe extern "C" fn() -> f64>;
#[repr(C)]
#[derive(Copy)]
pub struct JSAutoRequest {
pub mContext: *mut JSContext,
}
impl ::std::default::Default for JSAutoRequest {
fn default() -> JSAutoRequest { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct RuntimeOptions {
pub _bitfield_1: u8,
pub _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._bitfield_1 &= !(((1 << 1u32) - 1) << 0usize);
self._bitfield_1 |= (val as bool) << 0usize;
}
pub fn set_ion_(&mut self, val: bool) {
self._bitfield_1 &= !(((1 << 1u32) - 1) << 1usize);
self._bitfield_1 |= (val as bool) << 1usize;
}
pub fn set_asmJS_(&mut self, val: bool) {
self._bitfield_1 &= !(((1 << 1u32) - 1) << 2usize);
self._bitfield_1 |= (val as bool) << 2usize;
}
pub fn set_nativeRegExp_(&mut self, val: bool) {
self._bitfield_1 &= !(((1 << 1u32) - 1) << 3usize);
self._bitfield_1 |= (val as bool) << 3usize;
}
pub fn set_unboxedArrays_(&mut self, val: bool) {
self._bitfield_1 &= !(((1 << 1u32) - 1) << 4usize);
self._bitfield_1 |= (val as bool) << 4usize;
}
pub fn set_asyncStack_(&mut self, val: bool) {
self._bitfield_1 &= !(((1 << 1u32) - 1) << 5usize);
self._bitfield_1 |= (val as bool) << 5usize;
}
pub fn set_werror_(&mut self, val: bool) {
self._bitfield_1 &= !(((1 << 1u32) - 1) << 6usize);
self._bitfield_1 |= (val as bool) << 6usize;
}
pub fn set_strictMode_(&mut self, val: bool) {
self._bitfield_1 &= !(((1 << 1u32) - 1) << 7usize);
self._bitfield_1 |= (val as bool) << 7usize;
}
pub const fn new_bitfield_1(baseline_: bool, ion_: bool, asmJS_: bool,
nativeRegExp_: bool, unboxedArrays_: bool,
asyncStack_: bool, werror_: bool,
strictMode_: bool) -> u8 {
0 | ((baseline_ as u8) << 0u32) | ((ion_ as u8) << 1u32) |
((asmJS_ as u8) << 2u32) | ((nativeRegExp_ as u8) << 3u32) |
((unboxedArrays_ as u8) << 4u32) | ((asyncStack_ as u8) << 5u32) |
((werror_ as u8) << 6u32) | ((strictMode_ as u8) << 7u32)
}
pub fn set_extraWarnings_(&mut self, val: bool) {
self._bitfield_2 &= !(((1 << 1u32) - 1) << 0usize);
self._bitfield_2 |= (val as bool) << 0usize;
}
pub const fn new_bitfield_2(extraWarnings_: bool) -> u8 {
0 | ((extraWarnings_ as u8) << 0u32)
}
}
extern "C" {
fn _ZNK2JS14RuntimeOptions8baselineEv(this: *mut RuntimeOptions) -> bool;
fn _ZN2JS14RuntimeOptions11setBaselineEb(this: *mut RuntimeOptions,
flag: bool)
-> *mut RuntimeOptions;
fn _ZN2JS14RuntimeOptions14toggleBaselineEv(this: *mut RuntimeOptions)
-> *mut RuntimeOptions;
fn _ZNK2JS14RuntimeOptions3ionEv(this: *mut RuntimeOptions) -> bool;
fn _ZN2JS14RuntimeOptions6setIonEb(this: *mut RuntimeOptions, flag: bool)
-> *mut RuntimeOptions;
fn _ZN2JS14RuntimeOptions9toggleIonEv(this: *mut RuntimeOptions)
-> *mut RuntimeOptions;
fn _ZNK2JS14RuntimeOptions5asmJSEv(this: *mut RuntimeOptions) -> bool;
fn _ZN2JS14RuntimeOptions8setAsmJSEb(this: *mut RuntimeOptions,
flag: bool) -> *mut RuntimeOptions;
fn _ZN2JS14RuntimeOptions11toggleAsmJSEv(this: *mut RuntimeOptions)
-> *mut RuntimeOptions;
fn _ZNK2JS14RuntimeOptions12nativeRegExpEv(this: *mut RuntimeOptions)
-> bool;
fn _ZN2JS14RuntimeOptions15setNativeRegExpEb(this: *mut RuntimeOptions,
flag: bool)
-> *mut RuntimeOptions;
fn _ZNK2JS14RuntimeOptions13unboxedArraysEv(this: *mut RuntimeOptions)
-> bool;
fn _ZN2JS14RuntimeOptions16setUnboxedArraysEb(this: *mut RuntimeOptions,
flag: bool)
-> *mut RuntimeOptions;
fn _ZNK2JS14RuntimeOptions10asyncStackEv(this: *mut RuntimeOptions)
-> bool;
fn _ZN2JS14RuntimeOptions13setAsyncStackEb(this: *mut RuntimeOptions,
flag: bool)
-> *mut RuntimeOptions;
fn _ZNK2JS14RuntimeOptions6werrorEv(this: *mut RuntimeOptions) -> bool;
fn _ZN2JS14RuntimeOptions9setWerrorEb(this: *mut RuntimeOptions,
flag: bool) -> *mut RuntimeOptions;
fn _ZN2JS14RuntimeOptions12toggleWerrorEv(this: *mut RuntimeOptions)
-> *mut RuntimeOptions;
fn _ZNK2JS14RuntimeOptions10strictModeEv(this: *mut RuntimeOptions)
-> bool;
fn _ZN2JS14RuntimeOptions13setStrictModeEb(this: *mut RuntimeOptions,
flag: bool)
-> *mut RuntimeOptions;
fn _ZN2JS14RuntimeOptions16toggleStrictModeEv(this: *mut RuntimeOptions)
-> *mut RuntimeOptions;
fn _ZNK2JS14RuntimeOptions13extraWarningsEv(this: *mut RuntimeOptions)
-> bool;
fn _ZN2JS14RuntimeOptions16setExtraWarningsEb(this: *mut RuntimeOptions,
flag: bool)
-> *mut RuntimeOptions;
fn _ZN2JS14RuntimeOptions19toggleExtraWarningsEv(this:
*mut RuntimeOptions)
-> *mut RuntimeOptions;
}
impl RuntimeOptions {
#[inline]
pub unsafe extern "C" fn baseline(&mut self) -> bool {
_ZNK2JS14RuntimeOptions8baselineEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn setBaseline(&mut self, flag: bool)
-> *mut RuntimeOptions {
_ZN2JS14RuntimeOptions11setBaselineEb(&mut *self, flag)
}
#[inline]
pub unsafe extern "C" fn toggleBaseline(&mut self)
-> *mut RuntimeOptions {
_ZN2JS14RuntimeOptions14toggleBaselineEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn ion(&mut self) -> bool {
_ZNK2JS14RuntimeOptions3ionEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn setIon(&mut self, flag: bool)
-> *mut RuntimeOptions {
_ZN2JS14RuntimeOptions6setIonEb(&mut *self, flag)
}
#[inline]
pub unsafe extern "C" fn toggleIon(&mut self) -> *mut RuntimeOptions {
_ZN2JS14RuntimeOptions9toggleIonEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn asmJS(&mut self) -> bool {
_ZNK2JS14RuntimeOptions5asmJSEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn setAsmJS(&mut self, flag: bool)
-> *mut RuntimeOptions {
_ZN2JS14RuntimeOptions8setAsmJSEb(&mut *self, flag)
}
#[inline]
pub unsafe extern "C" fn toggleAsmJS(&mut self) -> *mut RuntimeOptions {
_ZN2JS14RuntimeOptions11toggleAsmJSEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn nativeRegExp(&mut self) -> bool {
_ZNK2JS14RuntimeOptions12nativeRegExpEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn setNativeRegExp(&mut self, flag: bool)
-> *mut RuntimeOptions {
_ZN2JS14RuntimeOptions15setNativeRegExpEb(&mut *self, flag)
}
#[inline]
pub unsafe extern "C" fn unboxedArrays(&mut self) -> bool {
_ZNK2JS14RuntimeOptions13unboxedArraysEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn setUnboxedArrays(&mut self, flag: bool)
-> *mut RuntimeOptions {
_ZN2JS14RuntimeOptions16setUnboxedArraysEb(&mut *self, flag)
}
#[inline]
pub unsafe extern "C" fn asyncStack(&mut self) -> bool {
_ZNK2JS14RuntimeOptions10asyncStackEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn setAsyncStack(&mut self, flag: bool)
-> *mut RuntimeOptions {
_ZN2JS14RuntimeOptions13setAsyncStackEb(&mut *self, flag)
}
#[inline]
pub unsafe extern "C" fn werror(&mut self) -> bool {
_ZNK2JS14RuntimeOptions6werrorEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn setWerror(&mut self, flag: bool)
-> *mut RuntimeOptions {
_ZN2JS14RuntimeOptions9setWerrorEb(&mut *self, flag)
}
#[inline]
pub unsafe extern "C" fn toggleWerror(&mut self) -> *mut RuntimeOptions {
_ZN2JS14RuntimeOptions12toggleWerrorEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn strictMode(&mut self) -> bool {
_ZNK2JS14RuntimeOptions10strictModeEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn setStrictMode(&mut self, flag: bool)
-> *mut RuntimeOptions {
_ZN2JS14RuntimeOptions13setStrictModeEb(&mut *self, flag)
}
#[inline]
pub unsafe extern "C" fn toggleStrictMode(&mut self)
-> *mut RuntimeOptions {
_ZN2JS14RuntimeOptions16toggleStrictModeEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn extraWarnings(&mut self) -> bool {
_ZNK2JS14RuntimeOptions13extraWarningsEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn setExtraWarnings(&mut self, flag: bool)
-> *mut RuntimeOptions {
_ZN2JS14RuntimeOptions16setExtraWarningsEb(&mut *self, flag)
}
#[inline]
pub unsafe extern "C" fn toggleExtraWarnings(&mut self)
-> *mut RuntimeOptions {
_ZN2JS14RuntimeOptions19toggleExtraWarningsEv(&mut *self)
}
}
#[repr(C)]
#[derive(Copy)]
pub struct ContextOptions {
pub _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._bitfield_1 &= !(((1 << 1u32) - 1) << 0usize);
self._bitfield_1 |= (val as bool) << 0usize;
}
pub fn set_dontReportUncaught_(&mut self, val: bool) {
self._bitfield_1 &= !(((1 << 1u32) - 1) << 1usize);
self._bitfield_1 |= (val as bool) << 1usize;
}
pub fn set_autoJSAPIOwnsErrorReporting_(&mut self, val: bool) {
self._bitfield_1 &= !(((1 << 1u32) - 1) << 2usize);
self._bitfield_1 |= (val as bool) << 2usize;
}
pub const fn new_bitfield_1(privateIsNSISupports_: bool,
dontReportUncaught_: bool,
autoJSAPIOwnsErrorReporting_: bool) -> u8 {
0 | ((privateIsNSISupports_ as u8) << 0u32) |
((dontReportUncaught_ as u8) << 1u32) |
((autoJSAPIOwnsErrorReporting_ as u8) << 2u32)
}
}
extern "C" {
fn _ZNK2JS14ContextOptions20privateIsNSISupportsEv(this:
*mut ContextOptions)
-> bool;
fn _ZN2JS14ContextOptions23setPrivateIsNSISupportsEb(this:
*mut ContextOptions,
flag: bool)
-> *mut ContextOptions;
fn _ZN2JS14ContextOptions26togglePrivateIsNSISupportsEv(this:
*mut ContextOptions)
-> *mut ContextOptions;
fn _ZNK2JS14ContextOptions18dontReportUncaughtEv(this:
*mut ContextOptions)
-> bool;
fn _ZN2JS14ContextOptions21setDontReportUncaughtEb(this:
*mut ContextOptions,
flag: bool)
-> *mut ContextOptions;
fn _ZN2JS14ContextOptions24toggleDontReportUncaughtEv(this:
*mut ContextOptions)
-> *mut ContextOptions;
fn _ZNK2JS14ContextOptions27autoJSAPIOwnsErrorReportingEv(this:
*mut ContextOptions)
-> bool;
fn _ZN2JS14ContextOptions30setAutoJSAPIOwnsErrorReportingEb(this:
*mut ContextOptions,
flag: bool)
-> *mut ContextOptions;
fn _ZN2JS14ContextOptions33toggleAutoJSAPIOwnsErrorReportingEv(this:
*mut ContextOptions)
-> *mut ContextOptions;
}
impl ContextOptions {
#[inline]
pub unsafe extern "C" fn privateIsNSISupports(&mut self) -> bool {
_ZNK2JS14ContextOptions20privateIsNSISupportsEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn setPrivateIsNSISupports(&mut self, flag: bool)
-> *mut ContextOptions {
_ZN2JS14ContextOptions23setPrivateIsNSISupportsEb(&mut *self, flag)
}
#[inline]
pub unsafe extern "C" fn togglePrivateIsNSISupports(&mut self)
-> *mut ContextOptions {
_ZN2JS14ContextOptions26togglePrivateIsNSISupportsEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn dontReportUncaught(&mut self) -> bool {
_ZNK2JS14ContextOptions18dontReportUncaughtEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn setDontReportUncaught(&mut self, flag: bool)
-> *mut ContextOptions {
_ZN2JS14ContextOptions21setDontReportUncaughtEb(&mut *self, flag)
}
#[inline]
pub unsafe extern "C" fn toggleDontReportUncaught(&mut self)
-> *mut ContextOptions {
_ZN2JS14ContextOptions24toggleDontReportUncaughtEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn autoJSAPIOwnsErrorReporting(&mut self) -> bool {
_ZNK2JS14ContextOptions27autoJSAPIOwnsErrorReportingEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn setAutoJSAPIOwnsErrorReporting(&mut self,
flag: bool)
-> *mut ContextOptions {
_ZN2JS14ContextOptions30setAutoJSAPIOwnsErrorReportingEb(&mut *self,
flag)
}
#[inline]
pub unsafe extern "C" fn toggleAutoJSAPIOwnsErrorReporting(&mut self)
-> *mut ContextOptions {
_ZN2JS14ContextOptions33toggleAutoJSAPIOwnsErrorReportingEv(&mut *self)
}
}
#[repr(C)]
#[derive(Copy)]
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)]
#[derive(Copy)]
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)]
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 =
::std::option::Option<unsafe extern "C" fn(rt: *mut JSRuntime,
data: *mut ::libc::c_void,
compartment:
*mut JSCompartment)>;
pub type JSCTypesUnicodeToNativeFun =
::std::option::Option<unsafe extern "C" fn(cx: *mut JSContext,
source: *const u16,
slen: size_t)
-> *mut ::libc::c_char>;
#[repr(C)]
#[derive(Copy)]
pub struct JSCTypesCallbacks {
pub unicodeToNative: JSCTypesUnicodeToNativeFun,
}
impl ::std::default::Default for JSCTypesCallbacks {
fn default() -> JSCTypesCallbacks { unsafe { ::std::mem::zeroed() } }
}
#[repr(i32)]
#[derive(Copy)]
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,
}
#[repr(C)]
#[derive(Copy)]
pub struct AutoIdArray {
pub _base: AutoGCRooter,
pub context: *mut JSContext,
pub idArray: *mut JSIdArray,
}
impl ::std::default::Default for AutoIdArray {
fn default() -> AutoIdArray { unsafe { ::std::mem::zeroed() } }
}
extern "C" {
fn _ZNK2JS11AutoIdArray6lengthEv(this: *mut AutoIdArray) -> size_t;
fn _ZN2JS11AutoIdArray5stealEv(this: *mut AutoIdArray) -> *mut JSIdArray;
fn _ZN2JS11AutoIdArray5traceEP8JSTracer(this: *mut AutoIdArray,
trc: *mut JSTracer);
}
impl AutoIdArray {
#[inline]
pub unsafe extern "C" fn length(&mut self) -> size_t {
_ZNK2JS11AutoIdArray6lengthEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn steal(&mut self) -> *mut JSIdArray {
_ZN2JS11AutoIdArray5stealEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn trace(&mut self, trc: *mut JSTracer) {
_ZN2JS11AutoIdArray5traceEP8JSTracer(&mut *self, trc)
}
}
#[repr(C)]
#[derive(Copy)]
pub struct JSConstScalarSpec<T> {
pub name: *const ::libc::c_char,
pub val: T,
}
#[repr(C)]
#[derive(Copy)]
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)]
pub struct JSPropertySpec {
pub name: *const ::libc::c_char,
pub flags: u8,
pub getter: jsapi_h_unnamed_3,
pub setter: jsapi_h_unnamed_4,
}
impl ::std::default::Default for JSPropertySpec {
fn default() -> JSPropertySpec { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct SelfHostedWrapper {
pub unused: *mut ::libc::c_void,
pub funname: *const ::libc::c_char,
}
impl ::std::default::Default for SelfHostedWrapper {
fn default() -> SelfHostedWrapper { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
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)]
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() } }
}
extern "C" {
fn _ZNK14JSPropertySpec12isSelfHostedEv(this: *mut JSPropertySpec)
-> bool;
fn _ZNK14JSPropertySpec23checkAccessorsAreNativeEv(this:
*mut JSPropertySpec);
fn _ZNK14JSPropertySpec27checkAccessorsAreSelfHostedEv(this:
*mut JSPropertySpec);
}
impl JSPropertySpec {
#[inline]
pub unsafe extern "C" fn isSelfHosted(&mut self) -> bool {
_ZNK14JSPropertySpec12isSelfHostedEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn checkAccessorsAreNative(&mut self) {
_ZNK14JSPropertySpec23checkAccessorsAreNativeEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn checkAccessorsAreSelfHosted(&mut self) {
_ZNK14JSPropertySpec27checkAccessorsAreSelfHostedEv(&mut *self)
}
}
#[repr(C)]
#[derive(Copy)]
pub struct JSFunctionSpec {
pub name: *const ::libc::c_char,
pub call: JSNativeWrapper,
pub nargs: u16,
pub flags: u16,
pub selfHostedName: *const ::libc::c_char,
}
impl ::std::default::Default for JSFunctionSpec {
fn default() -> JSFunctionSpec { unsafe { ::std::mem::zeroed() } }
}
#[repr(i32)]
#[derive(Copy)]
pub enum ZoneSpecifier { FreshZone = 0, SystemZone = 1, }
#[repr(C)]
#[derive(Copy)]
pub struct CompartmentOptions {
pub version_: JSVersion,
pub invisibleToDebugger_: bool,
pub mergeable_: bool,
pub discardSource_: bool,
pub disableLazyParsing_: bool,
pub cloneSingletons_: bool,
pub extraWarningsOverride_: Override,
pub zone_: jsapi_h_unnamed_5,
pub traceGlobal_: JSTraceOp,
pub singletonsAsTemplates_: bool,
pub addonId_: *mut JSAddonId,
pub preserveJitCode_: bool,
}
impl ::std::default::Default for CompartmentOptions {
fn default() -> CompartmentOptions { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct jsapi_h_unnamed_5 {
pub _bindgen_data_: [u32; 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() } }
}
extern "C" {
fn _ZNK2JS18CompartmentOptions7versionEv(this: *mut CompartmentOptions)
-> JSVersion;
fn _ZN2JS18CompartmentOptions10setVersionE9JSVersion(this:
*mut CompartmentOptions,
aVersion: JSVersion)
-> *mut CompartmentOptions;
fn _ZNK2JS18CompartmentOptions19invisibleToDebuggerEv(this:
*mut CompartmentOptions)
-> bool;
fn _ZN2JS18CompartmentOptions22setInvisibleToDebuggerEb(this:
*mut CompartmentOptions,
flag: bool)
-> *mut CompartmentOptions;
fn _ZNK2JS18CompartmentOptions9mergeableEv(this: *mut CompartmentOptions)
-> bool;
fn _ZN2JS18CompartmentOptions12setMergeableEb(this:
*mut CompartmentOptions,
flag: bool)
-> *mut CompartmentOptions;
fn _ZNK2JS18CompartmentOptions13discardSourceEv(this:
*mut CompartmentOptions)
-> bool;
fn _ZN2JS18CompartmentOptions16setDiscardSourceEb(this:
*mut CompartmentOptions,
flag: bool)
-> *mut CompartmentOptions;
fn _ZNK2JS18CompartmentOptions18disableLazyParsingEv(this:
*mut CompartmentOptions)
-> bool;
fn _ZN2JS18CompartmentOptions21setDisableLazyParsingEb(this:
*mut CompartmentOptions,
flag: bool)
-> *mut CompartmentOptions;
fn _ZNK2JS18CompartmentOptions15cloneSingletonsEv(this:
*mut CompartmentOptions)
-> bool;
fn _ZN2JS18CompartmentOptions18setCloneSingletonsEb(this:
*mut CompartmentOptions,
flag: bool)
-> *mut CompartmentOptions;
fn _ZNK2JS18CompartmentOptions13extraWarningsEP9JSRuntime(this:
*mut CompartmentOptions,
rt:
*mut JSRuntime)
-> bool;
fn _ZNK2JS18CompartmentOptions13extraWarningsEP9JSContext(this:
*mut CompartmentOptions,
cx:
*mut JSContext)
-> bool;
fn _ZN2JS18CompartmentOptions21extraWarningsOverrideEv(this:
*mut CompartmentOptions)
-> *mut Override;
fn _ZNK2JS18CompartmentOptions11zonePointerEv(this:
*mut CompartmentOptions)
-> *mut ::libc::c_void;
fn _ZNK2JS18CompartmentOptions13zoneSpecifierEv(this:
*mut CompartmentOptions)
-> ZoneSpecifier;
fn _ZN2JS18CompartmentOptions7setZoneENS_13ZoneSpecifierE(this:
*mut CompartmentOptions,
spec:
ZoneSpecifier)
-> *mut CompartmentOptions;
fn _ZN2JS18CompartmentOptions13setSameZoneAsEP8JSObject(this:
*mut CompartmentOptions,
obj:
*mut JSObject)
-> *mut CompartmentOptions;
fn _ZN2JS18CompartmentOptions21setSingletonsAsValuesEv(this:
*mut CompartmentOptions);
fn _ZNK2JS18CompartmentOptions24getSingletonsAsTemplatesEv(this:
*mut CompartmentOptions)
-> bool;
fn _ZNK2JS18CompartmentOptions13addonIdOrNullEv(this:
*mut CompartmentOptions)
-> *mut JSAddonId;
fn _ZN2JS18CompartmentOptions10setAddonIdEP9JSAddonId(this:
*mut CompartmentOptions,
id: *mut JSAddonId)
-> *mut CompartmentOptions;
fn _ZN2JS18CompartmentOptions8setTraceEPFvP8JSTracerP8JSObjectE(this:
*mut CompartmentOptions,
op:
JSTraceOp)
-> *mut CompartmentOptions;
fn _ZNK2JS18CompartmentOptions8getTraceEv(this: *mut CompartmentOptions)
-> JSTraceOp;
fn _ZNK2JS18CompartmentOptions15preserveJitCodeEv(this:
*mut CompartmentOptions)
-> bool;
fn _ZN2JS18CompartmentOptions18setPreserveJitCodeEb(this:
*mut CompartmentOptions,
flag: bool)
-> *mut CompartmentOptions;
}
impl CompartmentOptions {
#[inline]
pub unsafe extern "C" fn version(&mut self) -> JSVersion {
_ZNK2JS18CompartmentOptions7versionEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn setVersion(&mut self, aVersion: JSVersion)
-> *mut CompartmentOptions {
_ZN2JS18CompartmentOptions10setVersionE9JSVersion(&mut *self,
aVersion)
}
#[inline]
pub unsafe extern "C" fn invisibleToDebugger(&mut self) -> bool {
_ZNK2JS18CompartmentOptions19invisibleToDebuggerEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn setInvisibleToDebugger(&mut self, flag: bool)
-> *mut CompartmentOptions {
_ZN2JS18CompartmentOptions22setInvisibleToDebuggerEb(&mut *self, flag)
}
#[inline]
pub unsafe extern "C" fn mergeable(&mut self) -> bool {
_ZNK2JS18CompartmentOptions9mergeableEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn setMergeable(&mut self, flag: bool)
-> *mut CompartmentOptions {
_ZN2JS18CompartmentOptions12setMergeableEb(&mut *self, flag)
}
#[inline]
pub unsafe extern "C" fn discardSource(&mut self) -> bool {
_ZNK2JS18CompartmentOptions13discardSourceEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn setDiscardSource(&mut self, flag: bool)
-> *mut CompartmentOptions {
_ZN2JS18CompartmentOptions16setDiscardSourceEb(&mut *self, flag)
}
#[inline]
pub unsafe extern "C" fn disableLazyParsing(&mut self) -> bool {
_ZNK2JS18CompartmentOptions18disableLazyParsingEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn setDisableLazyParsing(&mut self, flag: bool)
-> *mut CompartmentOptions {
_ZN2JS18CompartmentOptions21setDisableLazyParsingEb(&mut *self, flag)
}
#[inline]
pub unsafe extern "C" fn cloneSingletons(&mut self) -> bool {
_ZNK2JS18CompartmentOptions15cloneSingletonsEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn setCloneSingletons(&mut self, flag: bool)
-> *mut CompartmentOptions {
_ZN2JS18CompartmentOptions18setCloneSingletonsEb(&mut *self, flag)
}
#[inline]
pub unsafe extern "C" fn extraWarnings(&mut self, rt: *mut JSRuntime)
-> bool {
_ZNK2JS18CompartmentOptions13extraWarningsEP9JSRuntime(&mut *self, rt)
}
#[inline]
pub unsafe extern "C" fn extraWarnings1(&mut self, cx: *mut JSContext)
-> bool {
_ZNK2JS18CompartmentOptions13extraWarningsEP9JSContext(&mut *self, cx)
}
#[inline]
pub unsafe extern "C" fn extraWarningsOverride(&mut self)
-> *mut Override {
_ZN2JS18CompartmentOptions21extraWarningsOverrideEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn zonePointer(&mut self) -> *mut ::libc::c_void {
_ZNK2JS18CompartmentOptions11zonePointerEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn zoneSpecifier(&mut self) -> ZoneSpecifier {
_ZNK2JS18CompartmentOptions13zoneSpecifierEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn setZone(&mut self, spec: ZoneSpecifier)
-> *mut CompartmentOptions {
_ZN2JS18CompartmentOptions7setZoneENS_13ZoneSpecifierE(&mut *self,
spec)
}
#[inline]
pub unsafe extern "C" fn setSameZoneAs(&mut self, obj: *mut JSObject)
-> *mut CompartmentOptions {
_ZN2JS18CompartmentOptions13setSameZoneAsEP8JSObject(&mut *self, obj)
}
#[inline]
pub unsafe extern "C" fn setSingletonsAsValues(&mut self) {
_ZN2JS18CompartmentOptions21setSingletonsAsValuesEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn getSingletonsAsTemplates(&mut self) -> bool {
_ZNK2JS18CompartmentOptions24getSingletonsAsTemplatesEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn addonIdOrNull(&mut self) -> *mut JSAddonId {
_ZNK2JS18CompartmentOptions13addonIdOrNullEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn setAddonId(&mut self, id: *mut JSAddonId)
-> *mut CompartmentOptions {
_ZN2JS18CompartmentOptions10setAddonIdEP9JSAddonId(&mut *self, id)
}
#[inline]
pub unsafe extern "C" fn setTrace(&mut self, op: JSTraceOp)
-> *mut CompartmentOptions {
_ZN2JS18CompartmentOptions8setTraceEPFvP8JSTracerP8JSObjectE(&mut *self,
op)
}
#[inline]
pub unsafe extern "C" fn getTrace(&mut self) -> JSTraceOp {
_ZNK2JS18CompartmentOptions8getTraceEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn preserveJitCode(&mut self) -> bool {
_ZNK2JS18CompartmentOptions15preserveJitCodeEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn setPreserveJitCode(&mut self, flag: bool)
-> *mut CompartmentOptions {
_ZN2JS18CompartmentOptions18setPreserveJitCodeEb(&mut *self, flag)
}
}
#[repr(i32)]
#[derive(Copy)]
pub enum OnNewGlobalHookOption {
FireOnNewGlobalHook = 0,
DontFireOnNewGlobalHook = 1,
}
/*** Property descriptors ************************************************************************/
#[repr(C)]
#[derive(Copy)]
pub struct JSPropertyDescriptor {
pub obj: *mut JSObject,
pub attrs: u32,
pub getter: JSGetterOp,
pub setter: JSSetterOp,
pub value: Value,
}
impl ::std::default::Default for JSPropertyDescriptor {
fn default() -> JSPropertyDescriptor { unsafe { ::std::mem::zeroed() } }
}
extern "C" {
fn _ZN20JSPropertyDescriptor5traceEP8JSTracer(this:
*mut JSPropertyDescriptor,
trc: *mut JSTracer);
fn _ZN20JSPropertyDescriptor8rootKindEv() -> ThingRootKind;
}
impl JSPropertyDescriptor {
#[inline]
pub unsafe extern "C" fn trace(&mut self, trc: *mut JSTracer) {
_ZN20JSPropertyDescriptor5traceEP8JSTracer(&mut *self, trc)
}
#[inline]
pub unsafe extern "C" fn rootKind() -> ThingRootKind {
_ZN20JSPropertyDescriptor8rootKindEv()
}
}
#[repr(C)]
#[derive(Copy)]
pub struct PropertyDescriptorOperations<Outer>;
#[repr(i32)]
#[derive(Copy)]
pub enum PropertyDescriptorOperations_ { SHADOWABLE = 0, }
#[repr(C)]
#[derive(Copy)]
pub struct MutablePropertyDescriptorOperations<Outer> {
pub _base: PropertyDescriptorOperations<Outer>,
}
#[repr(C)]
#[derive(Copy)]
pub struct RootedBase<> {
pub _base: MutablePropertyDescriptorOperations<Rooted<JSPropertyDescriptor>>,
}
#[repr(C)]
#[derive(Copy)]
pub struct HandleBase<> {
pub _base: PropertyDescriptorOperations<Handle<JSPropertyDescriptor>>,
}
#[repr(C)]
#[derive(Copy)]
pub struct MutableHandleBase<> {
pub _base: MutablePropertyDescriptorOperations<MutableHandle<JSPropertyDescriptor>>,
}
#[repr(i32)]
#[derive(Copy)]
pub enum PropertyDefinitionBehavior {
DefineAllProperties = 0,
OnlyDefineLateProperties = 1,
DontDefineLateProperties = 2,
}
#[repr(C)]
#[derive(Copy)]
pub struct ReadOnlyCompileOptions {
pub _vftable: *const _vftable_ReadOnlyCompileOptions,
pub mutedErrors_: bool,
pub filename_: *const ::libc::c_char,
pub introducerFilename_: *const ::libc::c_char,
pub sourceMapURL_: *const u16,
pub version: JSVersion,
pub versionSet: bool,
pub utf8: bool,
pub lineno: u32,
pub column: u32,
pub isRunOnce: bool,
pub forEval: bool,
pub noScriptRval: bool,
pub selfHostingMode: bool,
pub canLazilyParse: bool,
pub strictOption: bool,
pub extraWarningsOption: bool,
pub werrorOption: bool,
pub asmJSOption: bool,
pub forceAsync: bool,
pub installedFile: bool,
pub sourceIsLazy: bool,
pub introductionType: *const ::libc::c_char,
pub introductionLineno: u32,
pub introductionOffset: u32,
pub hasIntroductionInfo: bool,
}
impl ::std::default::Default for ReadOnlyCompileOptions {
fn default() -> ReadOnlyCompileOptions { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
pub struct _vftable_ReadOnlyCompileOptions {
pub element: extern "C" fn(this: *mut ::libc::c_void) -> *mut JSObject,
pub elementAttributeName: extern "C" fn(this: *mut ::libc::c_void)
-> *mut JSString,
pub introductionScript: extern "C" fn(this: *mut ::libc::c_void)
-> *mut JSScript,
}
extern "C" {
fn _ZN2JS22ReadOnlyCompileOptions14copyPODOptionsERKS0_(this:
*mut ReadOnlyCompileOptions,
rhs:
&ReadOnlyCompileOptions);
fn _ZNK2JS22ReadOnlyCompileOptions11mutedErrorsEv(this:
*mut ReadOnlyCompileOptions)
-> bool;
fn _ZNK2JS22ReadOnlyCompileOptions8filenameEv(this:
*mut ReadOnlyCompileOptions)
-> *const ::libc::c_char;
fn _ZNK2JS22ReadOnlyCompileOptions18introducerFilenameEv(this:
*mut ReadOnlyCompileOptions)
-> *const ::libc::c_char;
fn _ZNK2JS22ReadOnlyCompileOptions12sourceMapURLEv(this:
*mut ReadOnlyCompileOptions)
-> *const u16;
}
impl ReadOnlyCompileOptions {
#[inline]
pub unsafe extern "C" fn copyPODOptions(&mut self,
rhs: &ReadOnlyCompileOptions) {
_ZN2JS22ReadOnlyCompileOptions14copyPODOptionsERKS0_(&mut *self, rhs)
}
#[inline]
pub unsafe extern "C" fn mutedErrors(&mut self) -> bool {
_ZNK2JS22ReadOnlyCompileOptions11mutedErrorsEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn filename(&mut self) -> *const ::libc::c_char {
_ZNK2JS22ReadOnlyCompileOptions8filenameEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn introducerFilename(&mut self)
-> *const ::libc::c_char {
_ZNK2JS22ReadOnlyCompileOptions18introducerFilenameEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn sourceMapURL(&mut self) -> *const u16 {
_ZNK2JS22ReadOnlyCompileOptions12sourceMapURLEv(&mut *self)
}
}
#[repr(C)]
#[derive(Copy)]
pub struct OwningCompileOptions {
pub _base: ReadOnlyCompileOptions,
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 _vftable_OwningCompileOptions {
pub _base: _vftable_ReadOnlyCompileOptions,
}
extern "C" {
fn _ZN2JS20OwningCompileOptions4copyEP9JSContextRKNS_22ReadOnlyCompileOptionsE(this:
*mut OwningCompileOptions,
cx:
*mut JSContext,
rhs:
&ReadOnlyCompileOptions)
-> bool;
fn _ZN2JS20OwningCompileOptions7setFileEP9JSContextPKc(this:
*mut OwningCompileOptions,
cx: *mut JSContext,
f:
*const ::libc::c_char)
-> bool;
fn _ZN2JS20OwningCompileOptions14setFileAndLineEP9JSContextPKcj(this:
*mut OwningCompileOptions,
cx:
*mut JSContext,
f:
*const ::libc::c_char,
l: u32)
-> bool;
fn _ZN2JS20OwningCompileOptions15setSourceMapURLEP9JSContextPKDs(this:
*mut OwningCompileOptions,
cx:
*mut JSContext,
s:
*const u16)
-> bool;
fn _ZN2JS20OwningCompileOptions21setIntroducerFilenameEP9JSContextPKc(this:
*mut OwningCompileOptions,
cx:
*mut JSContext,
s:
*const ::libc::c_char)
-> bool;
fn _ZN2JS20OwningCompileOptions7setLineEj(this: *mut OwningCompileOptions,
l: u32)
-> *mut OwningCompileOptions;
fn _ZN2JS20OwningCompileOptions10setElementEP8JSObject(this:
*mut OwningCompileOptions,
e: *mut JSObject)
-> *mut OwningCompileOptions;
fn _ZN2JS20OwningCompileOptions23setElementAttributeNameEP8JSString(this:
*mut OwningCompileOptions,
p:
*mut JSString)
-> *mut OwningCompileOptions;
fn _ZN2JS20OwningCompileOptions21setIntroductionScriptEP8JSScript(this:
*mut OwningCompileOptions,
s:
*mut JSScript)
-> *mut OwningCompileOptions;
fn _ZN2JS20OwningCompileOptions14setMutedErrorsEb(this:
*mut OwningCompileOptions,
mute: bool)
-> *mut OwningCompileOptions;
fn _ZN2JS20OwningCompileOptions10setVersionE9JSVersion(this:
*mut OwningCompileOptions,
v: JSVersion)
-> *mut OwningCompileOptions;
fn _ZN2JS20OwningCompileOptions7setUTF8Eb(this: *mut OwningCompileOptions,
u: bool)
-> *mut OwningCompileOptions;
fn _ZN2JS20OwningCompileOptions9setColumnEj(this:
*mut OwningCompileOptions,
c: u32)
-> *mut OwningCompileOptions;
fn _ZN2JS20OwningCompileOptions12setIsRunOnceEb(this:
*mut OwningCompileOptions,
once: bool)
-> *mut OwningCompileOptions;
fn _ZN2JS20OwningCompileOptions10setForEvalEb(this:
*mut OwningCompileOptions,
eval: bool)
-> *mut OwningCompileOptions;
fn _ZN2JS20OwningCompileOptions15setNoScriptRvalEb(this:
*mut OwningCompileOptions,
nsr: bool)
-> *mut OwningCompileOptions;
fn _ZN2JS20OwningCompileOptions18setSelfHostingModeEb(this:
*mut OwningCompileOptions,
shm: bool)
-> *mut OwningCompileOptions;
fn _ZN2JS20OwningCompileOptions17setCanLazilyParseEb(this:
*mut OwningCompileOptions,
clp: bool)
-> *mut OwningCompileOptions;
fn _ZN2JS20OwningCompileOptions15setSourceIsLazyEb(this:
*mut OwningCompileOptions,
l: bool)
-> *mut OwningCompileOptions;
fn _ZN2JS20OwningCompileOptions19setIntroductionTypeEPKc(this:
*mut OwningCompileOptions,
t:
*const ::libc::c_char)
-> *mut OwningCompileOptions;
fn _ZN2JS20OwningCompileOptions19setIntroductionInfoEP9JSContextPKcS4_jP8JSScriptj(this:
*mut OwningCompileOptions,
cx:
*mut JSContext,
introducerFn:
*const ::libc::c_char,
intro:
*const ::libc::c_char,
line:
u32,
script:
*mut JSScript,
offset:
u32)
-> bool;
}
impl OwningCompileOptions {
#[inline]
pub unsafe extern "C" fn copy(&mut self, cx: *mut JSContext,
rhs: &ReadOnlyCompileOptions) -> bool {
_ZN2JS20OwningCompileOptions4copyEP9JSContextRKNS_22ReadOnlyCompileOptionsE(&mut *self,
cx,
rhs)
}
#[inline]
pub unsafe extern "C" fn setFile(&mut self, cx: *mut JSContext,
f: *const ::libc::c_char) -> bool {
_ZN2JS20OwningCompileOptions7setFileEP9JSContextPKc(&mut *self, cx, f)
}
#[inline]
pub unsafe extern "C" fn setFileAndLine(&mut self, cx: *mut JSContext,
f: *const ::libc::c_char, l: u32)
-> bool {
_ZN2JS20OwningCompileOptions14setFileAndLineEP9JSContextPKcj(&mut *self,
cx, f, l)
}
#[inline]
pub unsafe extern "C" fn setSourceMapURL(&mut self, cx: *mut JSContext,
s: *const u16) -> bool {
_ZN2JS20OwningCompileOptions15setSourceMapURLEP9JSContextPKDs(&mut *self,
cx, s)
}
#[inline]
pub unsafe extern "C" fn setIntroducerFilename(&mut self,
cx: *mut JSContext,
s: *const ::libc::c_char)
-> bool {
_ZN2JS20OwningCompileOptions21setIntroducerFilenameEP9JSContextPKc(&mut *self,
cx,
s)
}
#[inline]
pub unsafe extern "C" fn setLine(&mut self, l: u32)
-> *mut OwningCompileOptions {
_ZN2JS20OwningCompileOptions7setLineEj(&mut *self, l)
}
#[inline]
pub unsafe extern "C" fn setElement(&mut self, e: *mut JSObject)
-> *mut OwningCompileOptions {
_ZN2JS20OwningCompileOptions10setElementEP8JSObject(&mut *self, e)
}
#[inline]
pub unsafe extern "C" fn setElementAttributeName(&mut self,
p: *mut JSString)
-> *mut OwningCompileOptions {
_ZN2JS20OwningCompileOptions23setElementAttributeNameEP8JSString(&mut *self,
p)
}
#[inline]
pub unsafe extern "C" fn setIntroductionScript(&mut self,
s: *mut JSScript)
-> *mut OwningCompileOptions {
_ZN2JS20OwningCompileOptions21setIntroductionScriptEP8JSScript(&mut *self,
s)
}
#[inline]
pub unsafe extern "C" fn setMutedErrors(&mut self, mute: bool)
-> *mut OwningCompileOptions {
_ZN2JS20OwningCompileOptions14setMutedErrorsEb(&mut *self, mute)
}
#[inline]
pub unsafe extern "C" fn setVersion(&mut self, v: JSVersion)
-> *mut OwningCompileOptions {
_ZN2JS20OwningCompileOptions10setVersionE9JSVersion(&mut *self, v)
}
#[inline]
pub unsafe extern "C" fn setUTF8(&mut self, u: bool)
-> *mut OwningCompileOptions {
_ZN2JS20OwningCompileOptions7setUTF8Eb(&mut *self, u)
}
#[inline]
pub unsafe extern "C" fn setColumn(&mut self, c: u32)
-> *mut OwningCompileOptions {
_ZN2JS20OwningCompileOptions9setColumnEj(&mut *self, c)
}
#[inline]
pub unsafe extern "C" fn setIsRunOnce(&mut self, once: bool)
-> *mut OwningCompileOptions {
_ZN2JS20OwningCompileOptions12setIsRunOnceEb(&mut *self, once)
}
#[inline]
pub unsafe extern "C" fn setForEval(&mut self, eval: bool)
-> *mut OwningCompileOptions {
_ZN2JS20OwningCompileOptions10setForEvalEb(&mut *self, eval)
}
#[inline]
pub unsafe extern "C" fn setNoScriptRval(&mut self, nsr: bool)
-> *mut OwningCompileOptions {
_ZN2JS20OwningCompileOptions15setNoScriptRvalEb(&mut *self, nsr)
}
#[inline]
pub unsafe extern "C" fn setSelfHostingMode(&mut self, shm: bool)
-> *mut OwningCompileOptions {
_ZN2JS20OwningCompileOptions18setSelfHostingModeEb(&mut *self, shm)
}
#[inline]
pub unsafe extern "C" fn setCanLazilyParse(&mut self, clp: bool)
-> *mut OwningCompileOptions {
_ZN2JS20OwningCompileOptions17setCanLazilyParseEb(&mut *self, clp)
}
#[inline]
pub unsafe extern "C" fn setSourceIsLazy(&mut self, l: bool)
-> *mut OwningCompileOptions {
_ZN2JS20OwningCompileOptions15setSourceIsLazyEb(&mut *self, l)
}
#[inline]
pub unsafe extern "C" fn setIntroductionType(&mut self,
t: *const ::libc::c_char)
-> *mut OwningCompileOptions {
_ZN2JS20OwningCompileOptions19setIntroductionTypeEPKc(&mut *self, t)
}
#[inline]
pub unsafe extern "C" fn setIntroductionInfo(&mut self,
cx: *mut JSContext,
introducerFn:
*const ::libc::c_char,
intro: *const ::libc::c_char,
line: u32,
script: *mut JSScript,
offset: u32) -> bool {
_ZN2JS20OwningCompileOptions19setIntroductionInfoEP9JSContextPKcS4_jP8JSScriptj(&mut *self,
cx,
introducerFn,
intro,
line,
script,
offset)
}
}
#[repr(C)]
#[derive(Copy)]
pub struct CompileOptions {
pub _base: ReadOnlyCompileOptions,
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 _vftable_CompileOptions {
pub _base: _vftable_ReadOnlyCompileOptions,
}
extern "C" {
fn _ZN2JS14CompileOptions7setFileEPKc(this: *mut CompileOptions,
f: *const ::libc::c_char)
-> *mut CompileOptions;
fn _ZN2JS14CompileOptions7setLineEj(this: *mut CompileOptions, l: u32)
-> *mut CompileOptions;
fn _ZN2JS14CompileOptions14setFileAndLineEPKcj(this: *mut CompileOptions,
f: *const ::libc::c_char,
l: u32)
-> *mut CompileOptions;
fn _ZN2JS14CompileOptions15setSourceMapURLEPKDs(this: *mut CompileOptions,
s: *const u16)
-> *mut CompileOptions;
fn _ZN2JS14CompileOptions10setElementEP8JSObject(this:
*mut CompileOptions,
e: *mut JSObject)
-> *mut CompileOptions;
fn _ZN2JS14CompileOptions23setElementAttributeNameEP8JSString(this:
*mut CompileOptions,
p:
*mut JSString)
-> *mut CompileOptions;
fn _ZN2JS14CompileOptions21setIntroductionScriptEP8JSScript(this:
*mut CompileOptions,
s:
*mut JSScript)
-> *mut CompileOptions;
fn _ZN2JS14CompileOptions14setMutedErrorsEb(this: *mut CompileOptions,
mute: bool)
-> *mut CompileOptions;
fn _ZN2JS14CompileOptions10setVersionE9JSVersion(this:
*mut CompileOptions,
v: JSVersion)
-> *mut CompileOptions;
fn _ZN2JS14CompileOptions7setUTF8Eb(this: *mut CompileOptions, u: bool)
-> *mut CompileOptions;
fn _ZN2JS14CompileOptions9setColumnEj(this: *mut CompileOptions, c: u32)
-> *mut CompileOptions;
fn _ZN2JS14CompileOptions12setIsRunOnceEb(this: *mut CompileOptions,
once: bool)
-> *mut CompileOptions;
fn _ZN2JS14CompileOptions10setForEvalEb(this: *mut CompileOptions,
eval: bool)
-> *mut CompileOptions;
fn _ZN2JS14CompileOptions15setNoScriptRvalEb(this: *mut CompileOptions,
nsr: bool)
-> *mut CompileOptions;
fn _ZN2JS14CompileOptions18setSelfHostingModeEb(this: *mut CompileOptions,
shm: bool)
-> *mut CompileOptions;
fn _ZN2JS14CompileOptions17setCanLazilyParseEb(this: *mut CompileOptions,
clp: bool)
-> *mut CompileOptions;
fn _ZN2JS14CompileOptions15setSourceIsLazyEb(this: *mut CompileOptions,
l: bool)
-> *mut CompileOptions;
fn _ZN2JS14CompileOptions19setIntroductionTypeEPKc(this:
*mut CompileOptions,
t:
*const ::libc::c_char)
-> *mut CompileOptions;
fn _ZN2JS14CompileOptions19setIntroductionInfoEPKcS2_jP8JSScriptj(this:
*mut CompileOptions,
introducerFn:
*const ::libc::c_char,
intro:
*const ::libc::c_char,
line:
u32,
script:
*mut JSScript,
offset:
u32)
-> *mut CompileOptions;
fn _ZN2JS14CompileOptions19maybeMakeStrictModeEb(this:
*mut CompileOptions,
strict: bool)
-> *mut CompileOptions;
}
impl CompileOptions {
#[inline]
pub unsafe extern "C" fn setFile(&mut self, f: *const ::libc::c_char)
-> *mut CompileOptions {
_ZN2JS14CompileOptions7setFileEPKc(&mut *self, f)
}
#[inline]
pub unsafe extern "C" fn setLine(&mut self, l: u32)
-> *mut CompileOptions {
_ZN2JS14CompileOptions7setLineEj(&mut *self, l)
}
#[inline]
pub unsafe extern "C" fn setFileAndLine(&mut self,
f: *const ::libc::c_char, l: u32)
-> *mut CompileOptions {
_ZN2JS14CompileOptions14setFileAndLineEPKcj(&mut *self, f, l)
}
#[inline]
pub unsafe extern "C" fn setSourceMapURL(&mut self, s: *const u16)
-> *mut CompileOptions {
_ZN2JS14CompileOptions15setSourceMapURLEPKDs(&mut *self, s)
}
#[inline]
pub unsafe extern "C" fn setElement(&mut self, e: *mut JSObject)
-> *mut CompileOptions {
_ZN2JS14CompileOptions10setElementEP8JSObject(&mut *self, e)
}
#[inline]
pub unsafe extern "C" fn setElementAttributeName(&mut self,
p: *mut JSString)
-> *mut CompileOptions {
_ZN2JS14CompileOptions23setElementAttributeNameEP8JSString(&mut *self,
p)
}
#[inline]
pub unsafe extern "C" fn setIntroductionScript(&mut self,
s: *mut JSScript)
-> *mut CompileOptions {
_ZN2JS14CompileOptions21setIntroductionScriptEP8JSScript(&mut *self,
s)
}
#[inline]
pub unsafe extern "C" fn setMutedErrors(&mut self, mute: bool)
-> *mut CompileOptions {
_ZN2JS14CompileOptions14setMutedErrorsEb(&mut *self, mute)
}
#[inline]
pub unsafe extern "C" fn setVersion(&mut self, v: JSVersion)
-> *mut CompileOptions {
_ZN2JS14CompileOptions10setVersionE9JSVersion(&mut *self, v)
}
#[inline]
pub unsafe extern "C" fn setUTF8(&mut self, u: bool)
-> *mut CompileOptions {
_ZN2JS14CompileOptions7setUTF8Eb(&mut *self, u)
}
#[inline]
pub unsafe extern "C" fn setColumn(&mut self, c: u32)
-> *mut CompileOptions {
_ZN2JS14CompileOptions9setColumnEj(&mut *self, c)
}
#[inline]
pub unsafe extern "C" fn setIsRunOnce(&mut self, once: bool)
-> *mut CompileOptions {
_ZN2JS14CompileOptions12setIsRunOnceEb(&mut *self, once)
}
#[inline]
pub unsafe extern "C" fn setForEval(&mut self, eval: bool)
-> *mut CompileOptions {
_ZN2JS14CompileOptions10setForEvalEb(&mut *self, eval)
}
#[inline]
pub unsafe extern "C" fn setNoScriptRval(&mut self, nsr: bool)
-> *mut CompileOptions {
_ZN2JS14CompileOptions15setNoScriptRvalEb(&mut *self, nsr)
}
#[inline]
pub unsafe extern "C" fn setSelfHostingMode(&mut self, shm: bool)
-> *mut CompileOptions {
_ZN2JS14CompileOptions18setSelfHostingModeEb(&mut *self, shm)
}
#[inline]
pub unsafe extern "C" fn setCanLazilyParse(&mut self, clp: bool)
-> *mut CompileOptions {
_ZN2JS14CompileOptions17setCanLazilyParseEb(&mut *self, clp)
}
#[inline]
pub unsafe extern "C" fn setSourceIsLazy(&mut self, l: bool)
-> *mut CompileOptions {
_ZN2JS14CompileOptions15setSourceIsLazyEb(&mut *self, l)
}
#[inline]
pub unsafe extern "C" fn setIntroductionType(&mut self,
t: *const ::libc::c_char)
-> *mut CompileOptions {
_ZN2JS14CompileOptions19setIntroductionTypeEPKc(&mut *self, t)
}
#[inline]
pub unsafe extern "C" fn setIntroductionInfo(&mut self,
introducerFn:
*const ::libc::c_char,
intro: *const ::libc::c_char,
line: u32,
script: *mut JSScript,
offset: u32)
-> *mut CompileOptions {
_ZN2JS14CompileOptions19setIntroductionInfoEPKcS2_jP8JSScriptj(&mut *self,
introducerFn,
intro,
line,
script,
offset)
}
#[inline]
pub unsafe extern "C" fn maybeMakeStrictMode(&mut self, strict: bool)
-> *mut CompileOptions {
_ZN2JS14CompileOptions19maybeMakeStrictModeEb(&mut *self, strict)
}
}
#[repr(C)]
#[derive(Copy)]
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)]
pub struct JSAutoByteString {
pub mBytes: *mut ::libc::c_char,
}
impl ::std::default::Default for JSAutoByteString {
fn default() -> JSAutoByteString { unsafe { ::std::mem::zeroed() } }
}
extern "C" {
fn _ZN16JSAutoByteString9initBytesEPc(this: *mut JSAutoByteString,
bytes: *mut ::libc::c_char);
fn _ZN16JSAutoByteString12encodeLatin1EP9JSContextP8JSString(this:
*mut JSAutoByteString,
cx:
*mut JSContext,
str:
*mut JSString)
-> *mut ::libc::c_char;
fn _ZN16JSAutoByteString12encodeLatin1EPN2js16ExclusiveContextEP8JSString(this:
*mut JSAutoByteString,
cx:
*mut ExclusiveContext,
str:
*mut JSString)
-> *mut ::libc::c_char;
fn _ZN16JSAutoByteString10encodeUtf8EP9JSContextN2JS6HandleIP8JSStringEE(this:
*mut JSAutoByteString,
cx:
*mut JSContext,
str:
HandleString)
-> *mut ::libc::c_char;
fn _ZN16JSAutoByteString5clearEv(this: *mut JSAutoByteString);
fn _ZNK16JSAutoByteString3ptrEv(this: *mut JSAutoByteString)
-> *mut ::libc::c_char;
fn _ZNK16JSAutoByteString6lengthEv(this: *mut JSAutoByteString) -> size_t;
}
impl JSAutoByteString {
#[inline]
pub unsafe extern "C" fn initBytes(&mut self,
bytes: *mut ::libc::c_char) {
_ZN16JSAutoByteString9initBytesEPc(&mut *self, bytes)
}
#[inline]
pub unsafe extern "C" fn encodeLatin1(&mut self, cx: *mut JSContext,
str: *mut JSString)
-> *mut ::libc::c_char {
_ZN16JSAutoByteString12encodeLatin1EP9JSContextP8JSString(&mut *self,
cx, str)
}
#[inline]
pub unsafe extern "C" fn encodeLatin11(&mut self,
cx: *mut ExclusiveContext,
str: *mut JSString)
-> *mut ::libc::c_char {
_ZN16JSAutoByteString12encodeLatin1EPN2js16ExclusiveContextEP8JSString(&mut *self,
cx,
str)
}
#[inline]
pub unsafe extern "C" fn encodeUtf8(&mut self, cx: *mut JSContext,
str: HandleString)
-> *mut ::libc::c_char {
_ZN16JSAutoByteString10encodeUtf8EP9JSContextN2JS6HandleIP8JSStringEE(&mut *self,
cx,
str)
}
#[inline]
pub unsafe extern "C" fn clear(&mut self) {
_ZN16JSAutoByteString5clearEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn ptr(&mut self) -> *mut ::libc::c_char {
_ZNK16JSAutoByteString3ptrEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn length(&mut self) -> size_t {
_ZNK16JSAutoByteString6lengthEv(&mut *self)
}
}
#[repr(i32)]
#[derive(Copy)]
pub enum SymbolCode {
iterator = 0,
match = 1,
species = 2,
InSymbolRegistry = -2,
UniqueSymbol = -1,
}
pub type JSONWriteCallback =
::std::option::Option<unsafe extern "C" fn(buf: *const u16, len: u32,
data: *mut ::libc::c_void)
-> bool>;
#[repr(C)]
#[derive(Copy)]
pub struct JSLocaleCallbacks {
pub localeToUpperCase: JSLocaleToUpperCase,
pub localeToLowerCase: JSLocaleToLowerCase,
pub localeCompare: JSLocaleCompare,
pub localeToUnicode: JSLocaleToUnicode,
}
impl ::std::default::Default for JSLocaleCallbacks {
fn default() -> JSLocaleCallbacks { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct JSErrorReport {
pub filename: *const ::libc::c_char,
pub lineno: u32,
pub column: u32,
pub isMuted: bool,
pub linebuf: *const ::libc::c_char,
pub tokenptr: *const ::libc::c_char,
pub uclinebuf: *const u16,
pub uctokenptr: *const u16,
pub flags: u32,
pub errorNumber: u32,
pub ucmessage: *const u16,
pub messageArgs: *mut *const u16,
pub exnType: i16,
}
impl ::std::default::Default for JSErrorReport {
fn default() -> JSErrorReport { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct AutoSaveExceptionState {
pub context: *mut JSContext,
pub wasPropagatingForcedReturn: bool,
pub wasOverRecursed: bool,
pub wasThrowing: bool,
pub exceptionValue: RootedValue,
}
impl ::std::default::Default for AutoSaveExceptionState {
fn default() -> AutoSaveExceptionState { unsafe { ::std::mem::zeroed() } }
}
extern "C" {
fn _ZN2JS22AutoSaveExceptionState4dropEv(this:
*mut AutoSaveExceptionState);
fn _ZN2JS22AutoSaveExceptionState7restoreEv(this:
*mut AutoSaveExceptionState);
}
impl AutoSaveExceptionState {
#[inline]
pub unsafe extern "C" fn drop(&mut self) {
_ZN2JS22AutoSaveExceptionState4dropEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn restore(&mut self) {
_ZN2JS22AutoSaveExceptionState7restoreEv(&mut *self)
}
}
#[repr(i32)]
#[derive(Copy)]
pub enum JSJitCompilerOption {
JSJITCOMPILER_BASELINE_WARMUP_TRIGGER = 0,
JSJITCOMPILER_ION_WARMUP_TRIGGER = 1,
JSJITCOMPILER_ION_GVN_ENABLE = 2,
JSJITCOMPILER_ION_FORCE_IC = 3,
JSJITCOMPILER_ION_ENABLE = 4,
JSJITCOMPILER_BASELINE_ENABLE = 5,
JSJITCOMPILER_OFFTHREAD_COMPILATION_ENABLE = 6,
JSJITCOMPILER_SIGNALS_ENABLE = 7,
JSJITCOMPILER_NOT_AN_OPTION = 8,
}
#[repr(C)]
#[derive(Copy)]
pub struct AutoFilename {
pub scriptSource_: *mut ::libc::c_void,
}
impl ::std::default::Default for AutoFilename {
fn default() -> AutoFilename { unsafe { ::std::mem::zeroed() } }
}
extern "C" {
fn _ZNK2JS12AutoFilename3getEv(this: *mut AutoFilename)
-> *const ::libc::c_char;
fn _ZN2JS12AutoFilename5resetEPv(this: *mut AutoFilename,
newScriptSource: *mut ::libc::c_void);
}
impl AutoFilename {
#[inline]
pub unsafe extern "C" fn get(&mut self) -> *const ::libc::c_char {
_ZNK2JS12AutoFilename3getEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn reset(&mut self,
newScriptSource: *mut ::libc::c_void) {
_ZN2JS12AutoFilename5resetEPv(&mut *self, newScriptSource)
}
}
#[repr(C)]
#[derive(Copy)]
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<unsafe extern "C" fn(global: HandleObject,
begin: *const u16,
limit: *const u16,
size: *mut size_t,
memory: *mut *const u8,
handle: *mut intptr_t)
-> bool>;
pub type CloseAsmJSCacheEntryForReadOp =
::std::option::Option<unsafe extern "C" fn(size: size_t,
memory: *const u8,
handle: intptr_t)>;
#[repr(i32)]
#[derive(Copy)]
pub enum AsmJSCacheResult {
AsmJSCache_MIN = 0,
AsmJSCache_Success = 0,
AsmJSCache_ModuleTooSmall = 1,
AsmJSCache_SynchronousScript = 2,
AsmJSCache_QuotaExceeded = 3,
AsmJSCache_StorageInitFailure = 4,
AsmJSCache_Disabled_Internal = 5,
AsmJSCache_Disabled_ShellFlags = 6,
AsmJSCache_Disabled_JitInspector = 7,
AsmJSCache_InternalError = 8,
AsmJSCache_LIMIT = 9,
}
pub type OpenAsmJSCacheEntryForWriteOp =
::std::option::Option<unsafe extern "C" fn(global: HandleObject,
installed: bool,
begin: *const u16,
end: *const u16, size: size_t,
memory: *mut *mut u8,
handle: *mut intptr_t)
-> AsmJSCacheResult>;
pub type CloseAsmJSCacheEntryForWriteOp =
::std::option::Option<unsafe extern "C" fn(size: size_t, memory: *mut u8,
handle: intptr_t)>;
pub type BuildIdCharVector =
Vector<::libc::c_char, ::libc::c_void, SystemAllocPolicy>;
pub type BuildIdOp =
::std::option::Option<unsafe extern "C" fn(buildId:
*mut BuildIdCharVector)
-> bool>;
#[repr(C)]
#[derive(Copy)]
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)]
#[derive(Copy)]
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() } }
}
#[repr(i32)]
#[derive(Copy)]
pub enum ForOfIterator_NonIterableBehavior {
ThrowOnNonIterable = 0,
AllowNonIterable = 1,
}
extern "C" {
fn _ZN2JS13ForOfIterator4initENS_6HandleINS_5ValueEEENS0_19NonIterableBehaviorE(this:
*mut ForOfIterator,
iterable:
HandleValue,
nonIterableBehavior:
NonIterableBehavior)
-> bool;
fn _ZN2JS13ForOfIterator4nextENS_13MutableHandleINS_5ValueEEEPb(this:
*mut ForOfIterator,
val:
MutableHandleValue,
done:
*mut bool)
-> bool;
fn _ZNK2JS13ForOfIterator15valueIsIterableEv(this: *mut ForOfIterator)
-> bool;
fn _ZN2JS13ForOfIterator22nextFromOptimizedArrayENS_13MutableHandleINS_5ValueEEEPb(this:
*mut ForOfIterator,
val:
MutableHandleValue,
done:
*mut bool)
-> bool;
fn _ZN2JS13ForOfIterator24materializeArrayIteratorEv(this:
*mut ForOfIterator)
-> bool;
}
impl ForOfIterator {
#[inline]
pub unsafe extern "C" fn init(&mut self, iterable: HandleValue,
nonIterableBehavior: NonIterableBehavior)
-> bool {
_ZN2JS13ForOfIterator4initENS_6HandleINS_5ValueEEENS0_19NonIterableBehaviorE(&mut *self,
iterable,
nonIterableBehavior)
}
#[inline]
pub unsafe extern "C" fn next(&mut self, val: MutableHandleValue,
done: *mut bool) -> bool {
_ZN2JS13ForOfIterator4nextENS_13MutableHandleINS_5ValueEEEPb(&mut *self,
val,
done)
}
#[inline]
pub unsafe extern "C" fn valueIsIterable(&mut self) -> bool {
_ZNK2JS13ForOfIterator15valueIsIterableEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn nextFromOptimizedArray(&mut self,
val: MutableHandleValue,
done: *mut bool) -> bool {
_ZN2JS13ForOfIterator22nextFromOptimizedArrayENS_13MutableHandleINS_5ValueEEEPb(&mut *self,
val,
done)
}
#[inline]
pub unsafe extern "C" fn materializeArrayIterator(&mut self) -> bool {
_ZN2JS13ForOfIterator24materializeArrayIteratorEv(&mut *self)
}
}
pub type LargeAllocationFailureCallback =
::std::option::Option<unsafe extern "C" fn(data: *mut ::libc::c_void)>;
pub type OutOfMemoryCallback =
::std::option::Option<unsafe extern "C" fn(cx: *mut JSContext,
data: *mut ::libc::c_void)>;
#[repr(i32)]
#[derive(Copy)]
pub enum SavedFrameResult { Ok = 0, AccessDenied = 1, }
pub enum AutoStopwatch { }
#[repr(C)]
#[derive(Copy)]
pub struct PerformanceData {
pub durations: [u64; 10usize],
pub totalUserTime: u64,
pub totalSystemTime: u64,
pub totalCPOWTime: u64,
pub ticks: u64,
}
impl ::std::default::Default for PerformanceData {
fn default() -> PerformanceData { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct PerformanceGroup {
pub data: PerformanceData,
pub uid: u64,
pub stopwatch_: *const AutoStopwatch,
pub iteration_: u64,
pub key_: *mut ::libc::c_void,
pub refCount_: u64,
}
impl ::std::default::Default for PerformanceGroup {
fn default() -> PerformanceGroup { unsafe { ::std::mem::zeroed() } }
}
extern "C" {
fn _ZNK2js16PerformanceGroup12hasStopwatchEy(this: *mut PerformanceGroup,
iteration: u64) -> bool;
fn _ZN2js16PerformanceGroup16acquireStopwatchEyPKNS_13AutoStopwatchE(this:
*mut PerformanceGroup,
iteration:
u64,
stopwatch:
*const AutoStopwatch);
fn _ZN2js16PerformanceGroup16releaseStopwatchEyPKNS_13AutoStopwatchE(this:
*mut PerformanceGroup,
iteration:
u64,
stopwatch:
*const AutoStopwatch);
fn _ZN2js16PerformanceGroup11incRefCountEv(this: *mut PerformanceGroup)
-> u64;
fn _ZN2js16PerformanceGroup11decRefCountEv(this: *mut PerformanceGroup)
-> u64;
}
impl PerformanceGroup {
#[inline]
pub unsafe extern "C" fn hasStopwatch(&mut self, iteration: u64) -> bool {
_ZNK2js16PerformanceGroup12hasStopwatchEy(&mut *self, iteration)
}
#[inline]
pub unsafe extern "C" fn acquireStopwatch(&mut self, iteration: u64,
stopwatch:
*const AutoStopwatch) {
_ZN2js16PerformanceGroup16acquireStopwatchEyPKNS_13AutoStopwatchE(&mut *self,
iteration,
stopwatch)
}
#[inline]
pub unsafe extern "C" fn releaseStopwatch(&mut self, iteration: u64,
stopwatch:
*const AutoStopwatch) {
_ZN2js16PerformanceGroup16releaseStopwatchEyPKNS_13AutoStopwatchE(&mut *self,
iteration,
stopwatch)
}
#[inline]
pub unsafe extern "C" fn incRefCount(&mut self) -> u64 {
_ZN2js16PerformanceGroup11incRefCountEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn decRefCount(&mut self) -> u64 {
_ZN2js16PerformanceGroup11decRefCountEv(&mut *self)
}
}
#[repr(C)]
#[derive(Copy)]
pub struct PerformanceGroupHolder {
pub runtime_: *mut JSRuntime,
pub group_: *mut PerformanceGroup,
}
impl ::std::default::Default for PerformanceGroupHolder {
fn default() -> PerformanceGroupHolder { unsafe { ::std::mem::zeroed() } }
}
extern "C" {
fn _ZN2js22PerformanceGroupHolder8getGroupEP9JSContext(this:
*mut PerformanceGroupHolder,
arg1:
*mut JSContext)
-> *mut PerformanceGroup;
fn _ZNK2js22PerformanceGroupHolder8isLinkedEv(this:
*mut PerformanceGroupHolder)
-> bool;
fn _ZN2js22PerformanceGroupHolder6unlinkEv(this:
*mut PerformanceGroupHolder);
fn _ZN2js22PerformanceGroupHolder10getHashKeyEP9JSContext(this:
*mut PerformanceGroupHolder,
cx:
*mut JSContext)
-> *mut ::libc::c_void;
}
impl PerformanceGroupHolder {
#[inline]
pub unsafe extern "C" fn getGroup(&mut self, arg1: *mut JSContext)
-> *mut PerformanceGroup {
_ZN2js22PerformanceGroupHolder8getGroupEP9JSContext(&mut *self, arg1)
}
#[inline]
pub unsafe extern "C" fn isLinked(&mut self) -> bool {
_ZNK2js22PerformanceGroupHolder8isLinkedEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn unlink(&mut self) {
_ZN2js22PerformanceGroupHolder6unlinkEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn getHashKey(&mut self, cx: *mut JSContext)
-> *mut ::libc::c_void {
_ZN2js22PerformanceGroupHolder10getHashKeyEP9JSContext(&mut *self, cx)
}
}
pub type PerformanceStatsWalker =
extern "C" fn(cx: *mut JSContext, stats: &PerformanceData, uid: u64,
closure: *mut ::libc::c_void) -> bool;
pub type jsbytecode = u8;
pub type IsAcceptableThis =
::std::option::Option<unsafe extern "C" fn(v: HandleValue) -> bool>;
pub type NativeImpl =
::std::option::Option<unsafe extern "C" fn(cx: *mut JSContext,
args: CallArgs) -> bool>;
pub enum JSAtom { }
pub enum JSLinearString { }
pub enum BaseProxyHandler { }
pub enum InterpreterFrame { }
#[repr(i32)]
#[derive(Copy)]
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_BUDGET_MS = 3,
JS_TELEMETRY_GC_ANIMATION_MS = 4,
JS_TELEMETRY_GC_MAX_PAUSE_MS = 5,
JS_TELEMETRY_GC_MARK_MS = 6,
JS_TELEMETRY_GC_SWEEP_MS = 7,
JS_TELEMETRY_GC_MARK_ROOTS_MS = 8,
JS_TELEMETRY_GC_MARK_GRAY_MS = 9,
JS_TELEMETRY_GC_SLICE_MS = 10,
JS_TELEMETRY_GC_SLOW_PHASE = 11,
JS_TELEMETRY_GC_MMU_50 = 12,
JS_TELEMETRY_GC_RESET = 13,
JS_TELEMETRY_GC_INCREMENTAL_DISABLED = 14,
JS_TELEMETRY_GC_NON_INCREMENTAL = 15,
JS_TELEMETRY_GC_SCC_SWEEP_TOTAL_MS = 16,
JS_TELEMETRY_GC_SCC_SWEEP_MAX_PAUSE_MS = 17,
JS_TELEMETRY_GC_MINOR_REASON = 18,
JS_TELEMETRY_GC_MINOR_REASON_LONG = 19,
JS_TELEMETRY_GC_MINOR_US = 20,
JS_TELEMETRY_DEPRECATED_LANGUAGE_EXTENSIONS_IN_CONTENT = 21,
JS_TELEMETRY_ADDON_EXCEPTIONS = 22,
}
pub type JSAccumulateTelemetryDataCallback =
::std::option::Option<unsafe extern "C" fn(id: i32, sample: u32,
key: *const ::libc::c_char)>;
#[repr(i32)]
#[derive(Copy)]
pub enum jsfriendapi_hpp_unnamed_7 {
MakeNonConfigurableIntoConfigurable = 0,
CopyNonConfigurableAsIs = 1,
}
pub type PropertyCopyBehavior = jsfriendapi_hpp_unnamed_7;
#[repr(C)]
#[derive(Copy)]
pub struct JSFunctionSpecWithHelp {
pub name: *const ::libc::c_char,
pub call: JSNative,
pub nargs: u16,
pub flags: u16,
pub usage: *const ::libc::c_char,
pub help: *const ::libc::c_char,
}
impl ::std::default::Default for JSFunctionSpecWithHelp {
fn default() -> JSFunctionSpecWithHelp { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct SourceHook {
pub _vftable: *const _vftable_SourceHook,
}
impl ::std::default::Default for SourceHook {
fn default() -> SourceHook { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
pub struct _vftable_SourceHook {
pub load: extern "C" fn(this: *mut ::libc::c_void, cx: *mut JSContext,
filename: *const ::libc::c_char,
src: *mut *mut u16, length: *mut size_t) -> bool,
}
pub type PreserveWrapperCallback =
::std::option::Option<unsafe extern "C" fn(cx: *mut JSContext,
obj: *mut JSObject) -> bool>;
#[repr(i32)]
#[derive(Copy)]
pub enum jsfriendapi_hpp_unnamed_8 {
CollectNurseryBeforeDump = 0,
IgnoreNurseryObjects = 1,
}
pub type DumpHeapNurseryBehaviour = jsfriendapi_hpp_unnamed_8;
#[repr(C)]
#[derive(Copy)]
pub struct WeakMapTracer {
pub _vftable: *const _vftable_WeakMapTracer,
pub runtime: *mut JSRuntime,
}
impl ::std::default::Default for WeakMapTracer {
fn default() -> WeakMapTracer { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
pub struct _vftable_WeakMapTracer {
pub trace: extern "C" fn(this: *mut ::libc::c_void, m: *mut JSObject,
key: GCCellPtr, value: GCCellPtr),
}
pub type GCThingCallback =
::std::option::Option<unsafe extern "C" fn(closure: *mut ::libc::c_void,
thing: GCCellPtr)>;
#[repr(C)]
#[derive(Copy)]
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)]
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)]
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)]
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() } }
}
extern "C" {
fn _ZNK2js6shadow6Object13numFixedSlotsEv(this: *mut Object) -> size_t;
fn _ZNK2js6shadow6Object10fixedSlotsEv(this: *mut Object) -> *mut Value;
fn _ZNK2js6shadow6Object7slotRefEj(this: *mut Object, slot: size_t)
-> *mut Value;
}
impl Object {
#[inline]
pub unsafe extern "C" fn numFixedSlots(&mut self) -> size_t {
_ZNK2js6shadow6Object13numFixedSlotsEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn fixedSlots(&mut self) -> *mut Value {
_ZNK2js6shadow6Object10fixedSlotsEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn slotRef(&mut self, slot: size_t) -> *mut Value {
_ZNK2js6shadow6Object7slotRefEj(&mut *self, slot)
}
}
#[repr(C)]
#[derive(Copy)]
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)]
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 u16 {
::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 [u16; 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<unsafe extern "C" fn(arg: *mut ::libc::c_void,
active: bool)>;
pub type DOMInstanceClassHasProtoAtDepth =
::std::option::Option<unsafe extern "C" fn(instanceClass: *const Class,
protoID: u32, depth: u32)
-> bool>;
#[repr(C)]
#[derive(Copy)]
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)]
pub enum NukeReferencesToWindow {
NukeWindowReferences = 0,
DontNukeWindowReferences = 1,
}
#[repr(C)]
#[derive(Copy)]
pub struct CompartmentFilter {
pub _vftable: *const _vftable_CompartmentFilter,
}
impl ::std::default::Default for CompartmentFilter {
fn default() -> CompartmentFilter { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
pub struct _vftable_CompartmentFilter {
pub match: extern "C" fn(this: *mut ::libc::c_void, c: *mut JSCompartment)
-> bool,
}
#[repr(C)]
#[derive(Copy)]
pub struct AllCompartments {
pub _base: CompartmentFilter,
}
impl ::std::default::Default for AllCompartments {
fn default() -> AllCompartments { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
pub struct _vftable_AllCompartments {
pub _base: _vftable_CompartmentFilter,
}
#[repr(C)]
#[derive(Copy)]
pub struct ContentCompartmentsOnly {
pub _base: CompartmentFilter,
}
impl ::std::default::Default for ContentCompartmentsOnly {
fn default() -> ContentCompartmentsOnly {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
pub struct _vftable_ContentCompartmentsOnly {
pub _base: _vftable_CompartmentFilter,
}
#[repr(C)]
#[derive(Copy)]
pub struct ChromeCompartmentsOnly {
pub _base: CompartmentFilter,
}
impl ::std::default::Default for ChromeCompartmentsOnly {
fn default() -> ChromeCompartmentsOnly { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
pub struct _vftable_ChromeCompartmentsOnly {
pub _base: _vftable_CompartmentFilter,
}
#[repr(C)]
#[derive(Copy)]
pub struct SingleCompartment {
pub _base: CompartmentFilter,
pub ours: *mut JSCompartment,
}
impl ::std::default::Default for SingleCompartment {
fn default() -> SingleCompartment { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
pub struct _vftable_SingleCompartment {
pub _base: _vftable_CompartmentFilter,
}
#[repr(C)]
#[derive(Copy)]
pub struct CompartmentsWithPrincipals {
pub _base: CompartmentFilter,
pub principals: *mut JSPrincipals,
}
impl ::std::default::Default for CompartmentsWithPrincipals {
fn default() -> CompartmentsWithPrincipals {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
pub struct _vftable_CompartmentsWithPrincipals {
pub _base: _vftable_CompartmentFilter,
}
#[repr(C)]
#[derive(Copy)]
pub struct ExpandoAndGeneration {
pub expando: Heap<Value>,
pub generation: u32,
}
impl ::std::default::Default for ExpandoAndGeneration {
fn default() -> ExpandoAndGeneration { unsafe { ::std::mem::zeroed() } }
}
extern "C" {
fn _ZN2js20ExpandoAndGeneration6UnlinkEv(this: *mut ExpandoAndGeneration);
fn _ZN2js20ExpandoAndGeneration15offsetOfExpandoEv() -> size_t;
fn _ZN2js20ExpandoAndGeneration18offsetOfGenerationEv() -> size_t;
}
impl ExpandoAndGeneration {
#[inline]
pub unsafe extern "C" fn Unlink(&mut self) {
_ZN2js20ExpandoAndGeneration6UnlinkEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn offsetOfExpando() -> size_t {
_ZN2js20ExpandoAndGeneration15offsetOfExpandoEv()
}
#[inline]
pub unsafe extern "C" fn offsetOfGeneration() -> size_t {
_ZN2js20ExpandoAndGeneration18offsetOfGenerationEv()
}
}
#[repr(i32)]
#[derive(Copy)]
pub enum DOMProxyShadowsResult {
ShadowCheckFailed = 0,
Shadows = 1,
DoesntShadow = 2,
DoesntShadowUnique = 3,
ShadowsViaDirectExpando = 4,
ShadowsViaIndirectExpando = 5,
}
pub type DOMProxyShadowsCheck =
::std::option::Option<unsafe extern "C" fn(cx: *mut JSContext,
object: HandleObject,
id: HandleId)
-> DOMProxyShadowsResult>;
#[repr(i32)]
#[derive(Copy)]
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_TO = 12,
JSMSG_NO_PROPERTIES = 13,
JSMSG_BAD_REGEXP_FLAG = 14,
JSMSG_ARG_INDEX_OUT_OF_RANGE = 15,
JSMSG_SPREAD_TOO_LARGE = 16,
JSMSG_BAD_WEAKMAP_KEY = 17,
JSMSG_BAD_GETTER_OR_SETTER = 18,
JSMSG_BAD_ARRAY_LENGTH = 19,
JSMSG_REDECLARED_VAR = 20,
JSMSG_UNDECLARED_VAR = 21,
JSMSG_GETTER_ONLY = 22,
JSMSG_OVERWRITING_ACCESSOR = 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_BUILTIN_CTOR_NO_NEW_FATAL = 35,
JSMSG_PROTO_SETTING_SLOW = 36,
JSMSG_BAD_GENERATOR_YIELD = 37,
JSMSG_EMPTY_ARRAY_REDUCE = 38,
JSMSG_UNEXPECTED_TYPE = 39,
JSMSG_MISSING_FUN_ARG = 40,
JSMSG_NOT_NONNULL_OBJECT = 41,
JSMSG_SET_NON_OBJECT_RECEIVER = 42,
JSMSG_INVALID_DESCRIPTOR = 43,
JSMSG_OBJECT_NOT_EXTENSIBLE = 44,
JSMSG_CANT_REDEFINE_PROP = 45,
JSMSG_CANT_APPEND_TO_ARRAY = 46,
JSMSG_CANT_REDEFINE_ARRAY_LENGTH = 47,
JSMSG_CANT_DEFINE_PAST_ARRAY_LENGTH = 48,
JSMSG_BAD_GET_SET_FIELD = 49,
JSMSG_THROW_TYPE_ERROR = 50,
JSMSG_NOT_EXPECTED_TYPE = 51,
JSMSG_NOT_ITERABLE = 52,
JSMSG_ALREADY_HAS_PRAGMA = 53,
JSMSG_NEXT_RETURNED_PRIMITIVE = 54,
JSMSG_CANT_SET_PROTO = 55,
JSMSG_CANT_SET_PROTO_OF = 56,
JSMSG_CANT_SET_PROTO_CYCLE = 57,
JSMSG_INVALID_ARG_TYPE = 58,
JSMSG_TERMINATED = 59,
JSMSG_PROTO_NOT_OBJORNULL = 60,
JSMSG_CANT_CALL_CLASS_CONSTRUCTOR = 61,
JSMSG_DISABLED_DERIVED_CLASS = 62,
JSMSG_JSON_BAD_PARSE = 63,
JSMSG_JSON_CYCLIC_VALUE = 64,
JSMSG_BAD_INSTANCEOF_RHS = 65,
JSMSG_BAD_LEFTSIDE_OF_ASS = 66,
JSMSG_BAD_PROTOTYPE = 67,
JSMSG_IN_NOT_OBJECT = 68,
JSMSG_TOO_MANY_CON_SPREADARGS = 69,
JSMSG_TOO_MANY_FUN_SPREADARGS = 70,
JSMSG_UNINITIALIZED_LEXICAL = 71,
JSMSG_INVALID_DATE = 72,
JSMSG_BAD_TOISOSTRING_PROP = 73,
JSMSG_BAD_URI = 74,
JSMSG_INVALID_NORMALIZE_FORM = 75,
JSMSG_NEGATIVE_REPETITION_COUNT = 76,
JSMSG_NOT_A_CODEPOINT = 77,
JSMSG_RESULTING_STRING_TOO_LARGE = 78,
JSMSG_DEPRECATED_STRING_CONTAINS = 79,
JSMSG_BAD_RADIX = 80,
JSMSG_PRECISION_RANGE = 81,
JSMSG_BAD_APPLY_ARGS = 82,
JSMSG_BAD_FORMAL = 83,
JSMSG_CALLER_IS_STRICT = 84,
JSMSG_DEPRECATED_USAGE = 85,
JSMSG_FUNCTION_ARGUMENTS_AND_REST = 86,
JSMSG_NOT_SCRIPTED_FUNCTION = 87,
JSMSG_NO_REST_NAME = 88,
JSMSG_PARAMETER_AFTER_REST = 89,
JSMSG_TOO_MANY_FUN_APPLY_ARGS = 90,
JSMSG_CSP_BLOCKED_EVAL = 91,
JSMSG_CSP_BLOCKED_FUNCTION = 92,
JSMSG_ACCESSOR_DEF_DENIED = 93,
JSMSG_DEAD_OBJECT = 94,
JSMSG_UNWRAP_DENIED = 95,
JSMSG_BAD_CHAR = 96,
JSMSG_BAD_CLONE_FUNOBJ_SCOPE = 97,
JSMSG_BAD_NEW_RESULT = 98,
JSMSG_BAD_TYPE = 99,
JSMSG_CANT_CLONE_OBJECT = 100,
JSMSG_CANT_OPEN = 101,
JSMSG_USER_DEFINED_ERROR = 102,
JSMSG_ALLOC_OVERFLOW = 103,
JSMSG_BAD_BYTECODE = 104,
JSMSG_BAD_SCRIPT_MAGIC = 105,
JSMSG_BUFFER_TOO_SMALL = 106,
JSMSG_BYTECODE_TOO_BIG = 107,
JSMSG_CANT_SET_ARRAY_ATTRS = 108,
JSMSG_INACTIVE = 109,
JSMSG_NEED_DIET = 110,
JSMSG_OUT_OF_MEMORY = 111,
JSMSG_OVER_RECURSED = 112,
JSMSG_TOO_BIG_TO_ENCODE = 113,
JSMSG_TOO_DEEP = 114,
JSMSG_UNCAUGHT_EXCEPTION = 115,
JSMSG_UNKNOWN_FORMAT = 116,
JSMSG_ACCESSOR_WRONG_ARGS = 117,
JSMSG_ARGUMENTS_AND_REST = 118,
JSMSG_ARRAY_COMP_LEFTSIDE = 119,
JSMSG_ARRAY_INIT_TOO_BIG = 120,
JSMSG_AS_AFTER_IMPORT_STAR = 121,
JSMSG_AS_AFTER_RESERVED_WORD = 122,
JSMSG_BAD_ANON_GENERATOR_RETURN = 123,
JSMSG_BAD_ARROW_ARGS = 124,
JSMSG_BAD_BINDING = 125,
JSMSG_BAD_CONST_DECL = 126,
JSMSG_BAD_CONST_ASSIGN = 127,
JSMSG_BAD_CONTINUE = 128,
JSMSG_BAD_DESTRUCT_ASS = 129,
JSMSG_BAD_DESTRUCT_TARGET = 130,
JSMSG_BAD_DESTRUCT_PARENS = 131,
JSMSG_BAD_DESTRUCT_DECL = 132,
JSMSG_BAD_DUP_ARGS = 133,
JSMSG_BAD_FOR_EACH_LOOP = 134,
JSMSG_BAD_FOR_LEFTSIDE = 135,
JSMSG_BAD_GENERATOR_RETURN = 136,
JSMSG_BAD_GENERATOR_SYNTAX = 137,
JSMSG_BAD_GENEXP_BODY = 138,
JSMSG_BAD_INCOP_OPERAND = 139,
JSMSG_BAD_METHOD_DEF = 140,
JSMSG_BAD_OCTAL = 141,
JSMSG_BAD_OPERAND = 142,
JSMSG_BAD_PROP_ID = 143,
JSMSG_BAD_RETURN_OR_YIELD = 144,
JSMSG_BAD_STRICT_ASSIGN = 145,
JSMSG_BAD_SWITCH = 146,
JSMSG_BAD_SUPER = 147,
JSMSG_BAD_SUPERPROP = 148,
JSMSG_BRACKET_AFTER_ARRAY_COMPREHENSION = 149,
JSMSG_BRACKET_AFTER_LIST = 150,
JSMSG_BRACKET_IN_INDEX = 151,
JSMSG_CATCH_AFTER_GENERAL = 152,
JSMSG_CATCH_IDENTIFIER = 153,
JSMSG_CATCH_OR_FINALLY = 154,
JSMSG_CATCH_WITHOUT_TRY = 155,
JSMSG_COLON_AFTER_CASE = 156,
JSMSG_COLON_AFTER_ID = 157,
JSMSG_COLON_IN_COND = 158,
JSMSG_COMP_PROP_UNTERM_EXPR = 159,
JSMSG_CONTRARY_NONDIRECTIVE = 160,
JSMSG_CURLY_AFTER_BODY = 161,
JSMSG_CURLY_AFTER_CATCH = 162,
JSMSG_CURLY_AFTER_FINALLY = 163,
JSMSG_CURLY_AFTER_LET = 164,
JSMSG_CURLY_AFTER_LIST = 165,
JSMSG_CURLY_AFTER_TRY = 166,
JSMSG_CURLY_BEFORE_BODY = 167,
JSMSG_CURLY_BEFORE_CATCH = 168,
JSMSG_CURLY_BEFORE_CLASS = 169,
JSMSG_CURLY_BEFORE_LET = 170,
JSMSG_CURLY_BEFORE_FINALLY = 171,
JSMSG_CURLY_BEFORE_SWITCH = 172,
JSMSG_CURLY_BEFORE_TRY = 173,
JSMSG_CURLY_IN_COMPOUND = 174,
JSMSG_DECLARATION_AFTER_EXPORT = 175,
JSMSG_DECLARATION_AFTER_IMPORT = 176,
JSMSG_DEPRECATED_DELETE_OPERAND = 177,
JSMSG_DEPRECATED_FLAGS_ARG = 178,
JSMSG_DEPRECATED_LET_BLOCK = 179,
JSMSG_DEPRECATED_FOR_EACH = 180,
JSMSG_DEPRECATED_OCTAL = 181,
JSMSG_DEPRECATED_PRAGMA = 182,
JSMSG_DUPLICATE_FORMAL = 183,
JSMSG_DUPLICATE_LABEL = 184,
JSMSG_DUPLICATE_PROPERTY = 185,
JSMSG_EMPTY_CONSEQUENT = 186,
JSMSG_EQUAL_AS_ASSIGN = 187,
JSMSG_EXPORT_DECL_AT_TOP_LEVEL = 188,
JSMSG_FINALLY_WITHOUT_TRY = 189,
JSMSG_FROM_AFTER_IMPORT_CLAUSE = 190,
JSMSG_FROM_AFTER_EXPORT_STAR = 191,
JSMSG_GARBAGE_AFTER_INPUT = 192,
JSMSG_IDSTART_AFTER_NUMBER = 193,
JSMSG_ILLEGAL_CHARACTER = 194,
JSMSG_IMPORT_DECL_AT_TOP_LEVEL = 195,
JSMSG_INVALID_FOR_INOF_DECL_WITH_INIT = 196,
JSMSG_IN_AFTER_FOR_NAME = 197,
JSMSG_LABEL_NOT_FOUND = 198,
JSMSG_LET_CLASS_BINDING = 199,
JSMSG_LET_COMP_BINDING = 200,
JSMSG_LEXICAL_DECL_NOT_IN_BLOCK = 201,
JSMSG_LINE_BREAK_AFTER_THROW = 202,
JSMSG_MALFORMED_ESCAPE = 203,
JSMSG_MISSING_BINARY_DIGITS = 204,
JSMSG_MISSING_EXPONENT = 205,
JSMSG_MISSING_EXPR_AFTER_THROW = 206,
JSMSG_MISSING_FORMAL = 207,
JSMSG_MISSING_HEXDIGITS = 208,
JSMSG_MISSING_OCTAL_DIGITS = 209,
JSMSG_MODULES_NOT_IMPLEMENTED = 210,
JSMSG_MODULE_SPEC_AFTER_FROM = 211,
JSMSG_NAME_AFTER_DOT = 212,
JSMSG_NAME_AFTER_IMPORT_STAR_AS = 213,
JSMSG_NAMED_IMPORTS_OR_NAMESPACE_IMPORT = 214,
JSMSG_NONDEFAULT_FORMAL_AFTER_DEFAULT = 215,
JSMSG_NO_BINDING_NAME = 216,
JSMSG_NO_CLASS_CONSTRUCTOR = 217,
JSMSG_NO_EXPORT_NAME = 218,
JSMSG_NO_IMPORT_NAME = 219,
JSMSG_NO_VARIABLE_NAME = 220,
JSMSG_OF_AFTER_FOR_NAME = 221,
JSMSG_PAREN_AFTER_ARGS = 222,
JSMSG_PAREN_AFTER_CATCH = 223,
JSMSG_PAREN_AFTER_COND = 224,
JSMSG_PAREN_AFTER_FOR = 225,
JSMSG_PAREN_AFTER_FORMAL = 226,
JSMSG_PAREN_AFTER_FOR_CTRL = 227,
JSMSG_PAREN_AFTER_FOR_OF_ITERABLE = 228,
JSMSG_PAREN_AFTER_LET = 229,
JSMSG_PAREN_AFTER_SWITCH = 230,
JSMSG_PAREN_AFTER_WITH = 231,
JSMSG_PAREN_BEFORE_CATCH = 232,
JSMSG_PAREN_BEFORE_COND = 233,
JSMSG_PAREN_BEFORE_FORMAL = 234,
JSMSG_PAREN_BEFORE_LET = 235,
JSMSG_PAREN_BEFORE_SWITCH = 236,
JSMSG_PAREN_BEFORE_WITH = 237,
JSMSG_PAREN_IN_PAREN = 238,
JSMSG_RC_AFTER_EXPORT_SPEC_LIST = 239,
JSMSG_RC_AFTER_IMPORT_SPEC_LIST = 240,
JSMSG_REDECLARED_CATCH_IDENTIFIER = 241,
JSMSG_REDECLARED_PARAM = 242,
JSMSG_RESERVED_ID = 243,
JSMSG_REST_WITH_DEFAULT = 244,
JSMSG_SELFHOSTED_TOP_LEVEL_LEXICAL = 245,
JSMSG_SELFHOSTED_UNBOUND_NAME = 246,
JSMSG_SEMI_AFTER_FOR_COND = 247,
JSMSG_SEMI_AFTER_FOR_INIT = 248,
JSMSG_SEMI_BEFORE_STMNT = 249,
JSMSG_SOURCE_TOO_LONG = 250,
JSMSG_STMT_AFTER_RETURN = 251,
JSMSG_STRICT_CODE_WITH = 252,
JSMSG_STRICT_FUNCTION_STATEMENT = 253,
JSMSG_TEMPLSTR_UNTERM_EXPR = 254,
JSMSG_SIMD_NOT_A_VECTOR = 255,
JSMSG_TOO_MANY_CASES = 256,
JSMSG_TOO_MANY_CATCH_VARS = 257,
JSMSG_TOO_MANY_CON_ARGS = 258,
JSMSG_TOO_MANY_DEFAULTS = 259,
JSMSG_TOO_MANY_FUN_ARGS = 260,
JSMSG_TOO_MANY_LOCALS = 261,
JSMSG_TOO_MANY_YIELDS = 262,
JSMSG_TOUGH_BREAK = 263,
JSMSG_UNEXPECTED_TOKEN = 264,
JSMSG_UNNAMED_CLASS_STMT = 265,
JSMSG_UNNAMED_FUNCTION_STMT = 266,
JSMSG_UNTERMINATED_COMMENT = 267,
JSMSG_UNTERMINATED_REGEXP = 268,
JSMSG_UNTERMINATED_STRING = 269,
JSMSG_USELESS_EXPR = 270,
JSMSG_USE_ASM_DIRECTIVE_FAIL = 271,
JSMSG_VAR_HIDES_ARG = 272,
JSMSG_WHILE_AFTER_DO = 273,
JSMSG_YIELD_IN_ARROW = 274,
JSMSG_YIELD_IN_DEFAULT = 275,
JSMSG_BAD_COLUMN_NUMBER = 276,
JSMSG_COMPUTED_NAME_IN_PATTERN = 277,
JSMSG_DEFAULT_IN_PATTERN = 278,
JSMSG_BAD_NEWTARGET = 279,
JSMSG_USE_ASM_TYPE_FAIL = 280,
JSMSG_USE_ASM_LINK_FAIL = 281,
JSMSG_USE_ASM_TYPE_OK = 282,
JSMSG_BAD_TRAP_RETURN_VALUE = 283,
JSMSG_CANT_CHANGE_EXTENSIBILITY = 284,
JSMSG_CANT_DEFINE_INVALID = 285,
JSMSG_CANT_DEFINE_NEW = 286,
JSMSG_CANT_DEFINE_NE_AS_NC = 287,
JSMSG_PROXY_DEFINE_RETURNED_FALSE = 288,
JSMSG_PROXY_DELETE_RETURNED_FALSE = 289,
JSMSG_PROXY_PREVENTEXTENSIONS_RETURNED_FALSE = 290,
JSMSG_PROXY_SET_RETURNED_FALSE = 291,
JSMSG_CANT_REPORT_AS_NON_EXTENSIBLE = 292,
JSMSG_CANT_REPORT_C_AS_NC = 293,
JSMSG_CANT_REPORT_E_AS_NE = 294,
JSMSG_CANT_REPORT_INVALID = 295,
JSMSG_CANT_REPORT_NC_AS_NE = 296,
JSMSG_CANT_REPORT_NEW = 297,
JSMSG_CANT_REPORT_NE_AS_NC = 298,
JSMSG_CANT_SET_NW_NC = 299,
JSMSG_CANT_SET_WO_SETTER = 300,
JSMSG_CANT_SKIP_NC = 301,
JSMSG_INVALID_TRAP_RESULT = 302,
JSMSG_ONWKEYS_STR_SYM = 303,
JSMSG_MUST_REPORT_SAME_VALUE = 304,
JSMSG_MUST_REPORT_UNDEFINED = 305,
JSMSG_OBJECT_ACCESS_DENIED = 306,
JSMSG_PROPERTY_ACCESS_DENIED = 307,
JSMSG_PROXY_CONSTRUCT_OBJECT = 308,
JSMSG_PROXY_EXTENSIBILITY = 309,
JSMSG_PROXY_GETOWN_OBJORUNDEF = 310,
JSMSG_PROXY_REVOKED = 311,
JSMSG_PROXY_ARG_REVOKED = 312,
JSMSG_SC_BAD_CLONE_VERSION = 313,
JSMSG_SC_BAD_SERIALIZED_DATA = 314,
JSMSG_SC_DUP_TRANSFERABLE = 315,
JSMSG_SC_NOT_TRANSFERABLE = 316,
JSMSG_SC_UNSUPPORTED_TYPE = 317,
JSMSG_SC_SHMEM_MUST_TRANSFER = 318,
JSMSG_ASSIGN_FUNCTION_OR_NULL = 319,
JSMSG_DEBUG_BAD_LINE = 320,
JSMSG_DEBUG_BAD_OFFSET = 321,
JSMSG_DEBUG_BAD_REFERENT = 322,
JSMSG_DEBUG_BAD_RESUMPTION = 323,
JSMSG_DEBUG_CANT_DEBUG_GLOBAL = 324,
JSMSG_DEBUG_CCW_REQUIRED = 325,
JSMSG_DEBUG_COMPARTMENT_MISMATCH = 326,
JSMSG_DEBUG_LOOP = 327,
JSMSG_DEBUG_NOT_DEBUGGEE = 328,
JSMSG_DEBUG_NOT_DEBUGGING = 329,
JSMSG_DEBUG_NOT_IDLE = 330,
JSMSG_DEBUG_NOT_LIVE = 331,
JSMSG_DEBUG_NO_SCOPE_OBJECT = 332,
JSMSG_DEBUG_OBJECT_PROTO = 333,
JSMSG_DEBUG_OBJECT_WRONG_OWNER = 334,
JSMSG_DEBUG_OPTIMIZED_OUT = 335,
JSMSG_DEBUG_RESUMPTION_VALUE_DISALLOWED = 336,
JSMSG_DEBUG_VARIABLE_NOT_FOUND = 337,
JSMSG_DEBUG_WRAPPER_IN_WAY = 338,
JSMSG_NOT_CALLABLE_OR_UNDEFINED = 339,
JSMSG_NOT_TRACKING_ALLOCATIONS = 340,
JSMSG_NOT_TRACKING_TENURINGS = 341,
JSMSG_OBJECT_METADATA_CALLBACK_ALREADY_SET = 342,
JSMSG_QUERY_INNERMOST_WITHOUT_LINE_URL = 343,
JSMSG_QUERY_LINE_WITHOUT_URL = 344,
JSMSG_DEBUG_CANT_SET_OPT_ENV = 345,
JSMSG_DEBUG_INVISIBLE_COMPARTMENT = 346,
JSMSG_DEBUG_CENSUS_BREAKDOWN = 347,
JSMSG_TRACELOGGER_ENABLE_FAIL = 348,
JSMSG_DATE_NOT_FINITE = 349,
JSMSG_INTERNAL_INTL_ERROR = 350,
JSMSG_INTL_OBJECT_NOT_INITED = 351,
JSMSG_INTL_OBJECT_REINITED = 352,
JSMSG_INVALID_CURRENCY_CODE = 353,
JSMSG_INVALID_DIGITS_VALUE = 354,
JSMSG_INVALID_LANGUAGE_TAG = 355,
JSMSG_INVALID_LOCALES_ELEMENT = 356,
JSMSG_INVALID_LOCALE_MATCHER = 357,
JSMSG_INVALID_OPTION_VALUE = 358,
JSMSG_INVALID_TIME_ZONE = 359,
JSMSG_UNDEFINED_CURRENCY = 360,
JSMSG_BAD_CLASS_RANGE = 361,
JSMSG_ESCAPE_AT_END_OF_REGEXP = 362,
JSMSG_INVALID_GROUP = 363,
JSMSG_MISSING_PAREN = 364,
JSMSG_NEWREGEXP_FLAGGED = 365,
JSMSG_NOTHING_TO_REPEAT = 366,
JSMSG_NUMBERS_OUT_OF_ORDER = 367,
JSMSG_TOO_MANY_PARENS = 368,
JSMSG_UNMATCHED_RIGHT_PAREN = 369,
JSMSG_UNTERM_CLASS = 370,
JSMSG_DEFAULT_LOCALE_ERROR = 371,
JSMSG_NO_SUCH_SELF_HOSTED_PROP = 372,
JSMSG_INVALID_PROTOTYPE = 373,
JSMSG_TYPEDOBJECT_BAD_ARGS = 374,
JSMSG_TYPEDOBJECT_BINARYARRAY_BAD_INDEX = 375,
JSMSG_TYPEDOBJECT_HANDLE_UNATTACHED = 376,
JSMSG_TYPEDOBJECT_STRUCTTYPE_BAD_ARGS = 377,
JSMSG_TYPEDOBJECT_TOO_BIG = 378,
JSMSG_SIMD_FAILED_CONVERSION = 379,
JSMSG_BAD_INDEX = 380,
JSMSG_TYPED_ARRAY_BAD_ARGS = 381,
JSMSG_TYPED_ARRAY_BAD_OBJECT = 382,
JSMSG_TYPED_ARRAY_BAD_INDEX = 383,
JSMSG_TYPED_ARRAY_NEGATIVE_ARG = 384,
JSMSG_TYPED_ARRAY_DETACHED = 385,
JSMSG_SHARED_ARRAY_BAD_OBJECT = 386,
JSMSG_SHARED_ARRAY_BAD_LENGTH = 387,
JSMSG_SHARED_TYPED_ARRAY_BAD_OBJECT = 388,
JSMSG_SHARED_TYPED_ARRAY_BAD_ARGS = 389,
JSMSG_SHARED_TYPED_ARRAY_ARG_RANGE = 390,
JSMSG_SHARED_TYPED_ARRAY_BAD_LENGTH = 391,
JSMSG_BAD_PARSE_NODE = 392,
JSMSG_BAD_SYMBOL = 393,
JSMSG_SYMBOL_TO_STRING = 394,
JSMSG_SYMBOL_TO_NUMBER = 395,
JSMSG_ATOMICS_BAD_ARRAY = 396,
JSMSG_ATOMICS_TOO_LONG = 397,
JSMSG_ATOMICS_WAIT_NOT_ALLOWED = 398,
JSMSG_CANT_SET_INTERPOSED = 399,
JSMSG_CANT_DEFINE_WINDOW_ELEMENT = 400,
JSMSG_CANT_DELETE_WINDOW_ELEMENT = 401,
JSMSG_CANT_DELETE_WINDOW_NAMED_PROPERTY = 402,
JSMSG_CANT_PREVENT_EXTENSIONS = 403,
JSMSG_NO_NAMED_SETTER = 404,
JSMSG_NO_INDEXED_SETTER = 405,
JSMSG_CANT_DELETE_SUPER = 406,
JSErr_Limit = 407,
}
#[repr(C)]
#[derive(Copy)]
pub struct AutoStableStringChars {
pub s_: RootedString,
pub _bindgen_data_1_: [u32; 1usize],
pub state_: State,
pub ownsChars_: bool,
}
impl AutoStableStringChars {
pub unsafe fn twoByteChars_(&mut self) -> *mut *const u16 {
::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(i32)]
#[derive(Copy)]
pub enum AutoStableStringChars_State {
Uninitialized = 0,
Latin1 = 1,
TwoByte = 2,
}
extern "C" {
fn _ZN2js21AutoStableStringChars4initEP9JSContextP8JSString(this:
*mut AutoStableStringChars,
cx:
*mut JSContext,
s:
*mut JSString)
-> bool;
fn _ZN2js21AutoStableStringChars11initTwoByteEP9JSContextP8JSString(this:
*mut AutoStableStringChars,
cx:
*mut JSContext,
s:
*mut JSString)
-> bool;
fn _ZNK2js21AutoStableStringChars8isLatin1Ev(this:
*mut AutoStableStringChars)
-> bool;
fn _ZNK2js21AutoStableStringChars9isTwoByteEv(this:
*mut AutoStableStringChars)
-> bool;
fn _ZNK2js21AutoStableStringChars12twoByteCharsEv(this:
*mut AutoStableStringChars)
-> *const u16;
fn _ZNK2js21AutoStableStringChars11latin1RangeEv(this:
*mut AutoStableStringChars)
-> Range<u8>;
fn _ZNK2js21AutoStableStringChars12twoByteRangeEv(this:
*mut AutoStableStringChars)
-> Range<u16>;
fn _ZN2js21AutoStableStringChars26maybeGiveOwnershipToCallerEv(this:
*mut AutoStableStringChars)
-> bool;
}
impl AutoStableStringChars {
#[inline]
pub unsafe extern "C" fn init(&mut self, cx: *mut JSContext,
s: *mut JSString) -> bool {
_ZN2js21AutoStableStringChars4initEP9JSContextP8JSString(&mut *self,
cx, s)
}
#[inline]
pub unsafe extern "C" fn initTwoByte(&mut self, cx: *mut JSContext,
s: *mut JSString) -> bool {
_ZN2js21AutoStableStringChars11initTwoByteEP9JSContextP8JSString(&mut *self,
cx,
s)
}
#[inline]
pub unsafe extern "C" fn isLatin1(&mut self) -> bool {
_ZNK2js21AutoStableStringChars8isLatin1Ev(&mut *self)
}
#[inline]
pub unsafe extern "C" fn isTwoByte(&mut self) -> bool {
_ZNK2js21AutoStableStringChars9isTwoByteEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn twoByteChars(&mut self) -> *const u16 {
_ZNK2js21AutoStableStringChars12twoByteCharsEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn latin1Range(&mut self) -> Range<u8> {
_ZNK2js21AutoStableStringChars11latin1RangeEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn twoByteRange(&mut self) -> Range<u16> {
_ZNK2js21AutoStableStringChars12twoByteRangeEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn maybeGiveOwnershipToCaller(&mut self) -> bool {
_ZN2js21AutoStableStringChars26maybeGiveOwnershipToCallerEv(&mut *self)
}
}
#[repr(C)]
#[derive(Copy)]
pub struct ErrorReport {
pub reportp: *mut JSErrorReport,
pub message_: *const ::libc::c_char,
pub ownedReport: JSErrorReport,
pub ownedMessage: *mut ::libc::c_char,
pub _str: RootedString,
pub strChars: AutoStableStringChars,
pub exnObject: RootedObject,
pub bytesStorage: JSAutoByteString,
pub filename: JSAutoByteString,
pub ownsMessageAndReport: bool,
}
impl ::std::default::Default for ErrorReport {
fn default() -> ErrorReport { unsafe { ::std::mem::zeroed() } }
}
extern "C" {
fn _ZN2js11ErrorReport4initEP9JSContextN2JS6HandleINS3_5ValueEEE(this:
*mut ErrorReport,
cx:
*mut JSContext,
exn:
HandleValue)
-> bool;
fn _ZN2js11ErrorReport6reportEv(this: *mut ErrorReport)
-> *mut JSErrorReport;
fn _ZN2js11ErrorReport7messageEv(this: *mut ErrorReport)
-> *const ::libc::c_char;
fn _ZN2js11ErrorReport31populateUncaughtExceptionReportEP9JSContextz(this:
*mut ErrorReport,
cx:
*mut JSContext, ...)
-> bool;
fn _ZN2js11ErrorReport33populateUncaughtExceptionReportVAEP9JSContextPc(this:
*mut ErrorReport,
cx:
*mut JSContext,
ap:
va_list)
-> bool;
fn _ZN2js11ErrorReport32ReportAddonExceptionToTelementryEP9JSContext(this:
*mut ErrorReport,
cx:
*mut JSContext);
}
impl ErrorReport {
#[inline]
pub unsafe extern "C" fn init(&mut self, cx: *mut JSContext,
exn: HandleValue) -> bool {
_ZN2js11ErrorReport4initEP9JSContextN2JS6HandleINS3_5ValueEEE(&mut *self,
cx, exn)
}
#[inline]
pub unsafe extern "C" fn report(&mut self) -> *mut JSErrorReport {
_ZN2js11ErrorReport6reportEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn message(&mut self) -> *const ::libc::c_char {
_ZN2js11ErrorReport7messageEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn populateUncaughtExceptionReport(&mut self,
cx:
*mut JSContext)
-> bool {
_ZN2js11ErrorReport31populateUncaughtExceptionReportEP9JSContextz(&mut *self,
cx)
}
#[inline]
pub unsafe extern "C" fn populateUncaughtExceptionReportVA(&mut self,
cx:
*mut JSContext,
ap: va_list)
-> bool {
_ZN2js11ErrorReport33populateUncaughtExceptionReportVAEP9JSContextPc(&mut *self,
cx,
ap)
}
#[inline]
pub unsafe extern "C" fn ReportAddonExceptionToTelementry(&mut self,
cx:
*mut JSContext) {
_ZN2js11ErrorReport32ReportAddonExceptionToTelementryEP9JSContext(&mut *self,
cx)
}
}
#[repr(i32)]
#[derive(Copy)]
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)]
pub enum jsfriendapi_hpp_unnamed_9 { ChangeData = 0, KeepData = 1, }
pub type NeuterDataDisposition = jsfriendapi_hpp_unnamed_9;
#[repr(C)]
#[derive(Copy)]
pub struct JSJitGetterCallArgs {
pub _base: MutableHandleValue,
}
impl ::std::default::Default for JSJitGetterCallArgs {
fn default() -> JSJitGetterCallArgs { unsafe { ::std::mem::zeroed() } }
}
extern "C" {
fn _ZN19JSJitGetterCallArgs4rvalEv(this: *mut JSJitGetterCallArgs)
-> MutableHandleValue;
}
impl JSJitGetterCallArgs {
#[inline]
pub unsafe extern "C" fn rval(&mut self) -> MutableHandleValue {
_ZN19JSJitGetterCallArgs4rvalEv(&mut *self)
}
}
#[repr(C)]
#[derive(Copy)]
pub struct JSJitSetterCallArgs {
pub _base: MutableHandleValue,
}
impl ::std::default::Default for JSJitSetterCallArgs {
fn default() -> JSJitSetterCallArgs { unsafe { ::std::mem::zeroed() } }
}
extern "C" {
fn _ZNK19JSJitSetterCallArgs6lengthEv(this: *mut JSJitSetterCallArgs)
-> u32;
}
impl JSJitSetterCallArgs {
#[inline]
pub unsafe extern "C" fn length(&mut self) -> u32 {
_ZNK19JSJitSetterCallArgs6lengthEv(&mut *self)
}
}
#[repr(C)]
#[derive(Copy)]
pub struct JSJitMethodCallArgs {
pub _base: CallArgsBase<::libc::c_void>,
}
impl ::std::default::Default for JSJitMethodCallArgs {
fn default() -> JSJitMethodCallArgs { unsafe { ::std::mem::zeroed() } }
}
extern "C" {
fn _ZNK19JSJitMethodCallArgs4rvalEv(this: *mut JSJitMethodCallArgs)
-> MutableHandleValue;
fn _ZNK19JSJitMethodCallArgs6lengthEv(this: *mut JSJitMethodCallArgs)
-> u32;
fn _ZNK19JSJitMethodCallArgs10hasDefinedEj(this: *mut JSJitMethodCallArgs,
i: u32) -> bool;
fn _ZNK19JSJitMethodCallArgs6calleeEv(this: *mut JSJitMethodCallArgs)
-> *mut JSObject;
fn _ZNK19JSJitMethodCallArgs3getEj(this: *mut JSJitMethodCallArgs, i: u32)
-> HandleValue;
}
impl JSJitMethodCallArgs {
#[inline]
pub unsafe extern "C" fn rval(&mut self) -> MutableHandleValue {
_ZNK19JSJitMethodCallArgs4rvalEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn length(&mut self) -> u32 {
_ZNK19JSJitMethodCallArgs6lengthEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn hasDefined(&mut self, i: u32) -> bool {
_ZNK19JSJitMethodCallArgs10hasDefinedEj(&mut *self, i)
}
#[inline]
pub unsafe extern "C" fn callee(&mut self) -> *mut JSObject {
_ZNK19JSJitMethodCallArgs6calleeEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn get(&mut self, i: u32) -> HandleValue {
_ZNK19JSJitMethodCallArgs3getEj(&mut *self, i)
}
}
#[repr(C)]
#[derive(Copy)]
pub struct JSJitMethodCallArgsTraits;
impl ::std::default::Default for JSJitMethodCallArgsTraits {
fn default() -> JSJitMethodCallArgsTraits {
unsafe { ::std::mem::zeroed() }
}
}
pub type JSJitGetterOp =
::std::option::Option<unsafe extern "C" fn(cx: *mut JSContext,
thisObj: HandleObject,
specializedThis:
*mut ::libc::c_void,
args: JSJitGetterCallArgs)
-> bool>;
pub type JSJitSetterOp =
::std::option::Option<unsafe extern "C" fn(cx: *mut JSContext,
thisObj: HandleObject,
specializedThis:
*mut ::libc::c_void,
args: JSJitSetterCallArgs)
-> bool>;
pub type JSJitMethodOp =
::std::option::Option<unsafe extern "C" fn(cx: *mut JSContext,
thisObj: HandleObject,
specializedThis:
*mut ::libc::c_void,
args: &JSJitMethodCallArgs)
-> bool>;
#[repr(C)]
#[derive(Copy)]
pub struct JSJitInfo {
pub _bindgen_data_1_: [u32; 1usize],
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)]
pub enum JSJitInfo_OpType {
Getter = 0,
Setter = 1,
Method = 2,
StaticMethod = 3,
OpTypeCount = 4,
}
#[repr(i32)]
#[derive(Copy)]
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)]
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 << 4u32) - 1) << 0usize);
self._bitfield_1 |= (val as u32) << 0usize;
}
pub fn set_aliasSet_(&mut self, val: u8) {
self._bitfield_1 &= !(((1 << 4u32) - 1) << 4usize);
self._bitfield_1 |= (val as u32) << 4usize;
}
pub fn set_returnType_(&mut self, val: u8) {
self._bitfield_1 &= !(((1 << 8u32) - 1) << 8usize);
self._bitfield_1 |= (val as u32) << 8usize;
}
pub fn set_isInfallible(&mut self, val: bool) {
self._bitfield_1 &= !(((1 << 1u32) - 1) << 16usize);
self._bitfield_1 |= (val as u32) << 16usize;
}
pub fn set_isMovable(&mut self, val: bool) {
self._bitfield_1 &= !(((1 << 1u32) - 1) << 17usize);
self._bitfield_1 |= (val as u32) << 17usize;
}
pub fn set_isEliminatable(&mut self, val: bool) {
self._bitfield_1 &= !(((1 << 1u32) - 1) << 18usize);
self._bitfield_1 |= (val as u32) << 18usize;
}
pub fn set_isAlwaysInSlot(&mut self, val: bool) {
self._bitfield_1 &= !(((1 << 1u32) - 1) << 19usize);
self._bitfield_1 |= (val as u32) << 19usize;
}
pub fn set_isLazilyCachedInSlot(&mut self, val: bool) {
self._bitfield_1 &= !(((1 << 1u32) - 1) << 20usize);
self._bitfield_1 |= (val as u32) << 20usize;
}
pub fn set_isTypedMethod(&mut self, val: bool) {
self._bitfield_1 &= !(((1 << 1u32) - 1) << 21usize);
self._bitfield_1 |= (val as u32) << 21usize;
}
pub fn set_slotIndex(&mut self, val: u16) {
self._bitfield_1 &= !(((1 << 10u32) - 1) << 22usize);
self._bitfield_1 |= (val as u32) << 22usize;
}
pub const fn new_bitfield_1(type_: u8, aliasSet_: u8, returnType_: u8,
isInfallible: bool, isMovable: bool,
isEliminatable: bool, isAlwaysInSlot: bool,
isLazilyCachedInSlot: bool,
isTypedMethod: bool, slotIndex: u16) -> u32 {
0 | ((type_ as u32) << 0u32) | ((aliasSet_ as u32) << 4u32) |
((returnType_ as u32) << 8u32) | ((isInfallible as u32) << 16u32)
| ((isMovable as u32) << 17u32) |
((isEliminatable as u32) << 18u32) |
((isAlwaysInSlot as u32) << 19u32) |
((isLazilyCachedInSlot as u32) << 20u32) |
((isTypedMethod as u32) << 21u32) | ((slotIndex as u32) << 22u32)
}
}
extern "C" {
fn _ZNK9JSJitInfo24needsOuterizedThisObjectEv(this: *mut JSJitInfo)
-> bool;
fn _ZNK9JSJitInfo20isTypedMethodJitInfoEv(this: *mut JSJitInfo) -> bool;
fn _ZNK9JSJitInfo4typeEv(this: *mut JSJitInfo) -> OpType;
fn _ZNK9JSJitInfo8aliasSetEv(this: *mut JSJitInfo) -> AliasSet;
fn _ZNK9JSJitInfo10returnTypeEv(this: *mut JSJitInfo) -> JSValueType;
}
impl JSJitInfo {
#[inline]
pub unsafe extern "C" fn needsOuterizedThisObject(&mut self) -> bool {
_ZNK9JSJitInfo24needsOuterizedThisObjectEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn isTypedMethodJitInfo(&mut self) -> bool {
_ZNK9JSJitInfo20isTypedMethodJitInfoEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn type(&mut self) -> OpType {
_ZNK9JSJitInfo4typeEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn aliasSet(&mut self) -> AliasSet {
_ZNK9JSJitInfo8aliasSetEv(&mut *self)
}
#[inline]
pub unsafe extern "C" fn returnType(&mut self) -> JSValueType {
_ZNK9JSJitInfo10returnTypeEv(&mut *self)
}
}
#[repr(C)]
#[derive(Copy)]
pub struct JSTypedMethodJitInfo {
pub base: JSJitInfo,
pub argTypes: *const ArgType,
}
impl ::std::default::Default for JSTypedMethodJitInfo {
fn default() -> JSTypedMethodJitInfo { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct ScriptEnvironmentPreparer {
pub _vftable: *const _vftable_ScriptEnvironmentPreparer,
}
impl ::std::default::Default for ScriptEnvironmentPreparer {
fn default() -> ScriptEnvironmentPreparer {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
pub struct _vftable_ScriptEnvironmentPreparer {
pub invoke: extern "C" fn(this: *mut ::libc::c_void, scope: HandleObject,
closure: &mut Closure) -> bool,
}
#[repr(C)]
#[derive(Copy)]
pub struct Closure;
impl ::std::default::Default for Closure {
fn default() -> Closure { unsafe { ::std::mem::zeroed() } }
}
#[repr(i32)]
#[derive(Copy)]
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<unsafe extern "C" fn(cx: *mut JSContext,
_type: CTypesActivityType)>;
#[repr(C)]
#[derive(Copy)]
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() }
}
}
extern "C" {
fn _ZN2js26AutoCTypesActivityCallback13DoEndCallbackEv(this:
*mut AutoCTypesActivityCallback);
}
impl AutoCTypesActivityCallback {
#[inline]
pub unsafe extern "C" fn DoEndCallback(&mut self) {
_ZN2js26AutoCTypesActivityCallback13DoEndCallbackEv(&mut *self)
}
}
pub type ObjectMetadataCallback =
::std::option::Option<unsafe extern "C" fn(cx: *mut JSContext,
obj: *mut JSObject)
-> *mut JSObject>;
extern "C" {
pub static NullHandleValue: HandleValue;
pub static UndefinedHandleValue: HandleValue;
pub static TrueHandleValue: HandleValue;
pub static FalseHandleValue: 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;
}
extern "C" {
fn _Z9JS_AssertPKcS0_i(s: *const ::libc::c_char,
file: *const ::libc::c_char, ln: i32);
fn _ZN2js6detail16ScrambleHashCodeEj(h: HashNumber) -> HashNumber;
fn _ZN2js8FinishGCEP9JSRuntime(rt: *mut JSRuntime);
fn _ZN2js2gc26MarkPersistentRootedChainsEP8JSTracer(arg1: *mut JSTracer);
fn _ZN2js2gc28FinishPersistentRootedChainsEP9JSRuntime(arg1:
*mut JSRuntime);
fn _ZN2js10GetRuntimeEPK9JSContext(cx: *const JSContext)
-> *mut JSRuntime;
fn _ZN2js21GetContextCompartmentEPK9JSContext(cx: *const JSContext)
-> *mut JSCompartment;
fn _ZN2js14GetContextZoneEPK9JSContext(cx: *const JSContext) -> *mut Zone;
fn _ZN2js29CurrentThreadCanAccessRuntimeEP9JSRuntime(rt: *mut JSRuntime)
-> bool;
fn _ZN2js26CurrentThreadCanAccessZoneEPN2JS4ZoneE(zone: *mut Zone)
-> bool;
fn _ZN2js2gc20AssertGCThingHasTypeEPNS0_4CellEN2JS9TraceKindE(cell:
*mut Cell,
kind:
TraceKind);
fn _ZN2js2gc15IsInsideNurseryEPKNS0_4CellE(cell: *const Cell) -> bool;
fn _ZN2JS13GetObjectZoneEP8JSObject(obj: *mut JSObject) -> *mut Zone;
fn _ZN2js2gc19NewMemoryInfoObjectEP9JSContext(cx: *mut JSContext)
-> *mut JSObject;
fn _ZN2JS16PrepareZoneForGCEPNS_4ZoneE(zone: *mut Zone);
fn _ZN2JS16PrepareForFullGCEP9JSRuntime(rt: *mut JSRuntime);
fn _ZN2JS23PrepareForIncrementalGCEP9JSRuntime(rt: *mut JSRuntime);
fn _ZN2JS13IsGCScheduledEP9JSRuntime(rt: *mut JSRuntime) -> bool;
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 _ZN2JS18AbortIncrementalGCEP9JSRuntime(rt: *mut JSRuntime);
fn _ZN2JS18SetGCSliceCallbackEP9JSRuntimePFvS1_NS_10GCProgressERKNS_13GCDescriptionEE(rt:
*mut JSRuntime,
callback:
GCSliceCallback)
-> GCSliceCallback;
fn _ZN2JS20DisableIncrementalGCEP9JSRuntime(rt: *mut JSRuntime);
fn _ZN2JS22IsIncrementalGCEnabledEP9JSRuntime(rt: *mut JSRuntime) -> bool;
fn _ZN2JS25IsIncrementalGCInProgressEP9JSRuntime(rt: *mut JSRuntime)
-> bool;
fn _ZN2JS26IsIncrementalBarrierNeededEP9JSRuntime(rt: *mut JSRuntime)
-> bool;
fn _ZN2JS26IsIncrementalBarrierNeededEP9JSContext(cx: *mut JSContext)
-> bool;
fn _ZN2JS27IncrementalReferenceBarrierENS_9GCCellPtrE(thing: GCCellPtr);
fn _ZN2JS23IncrementalValueBarrierERKNS_5ValueE(v: &Value);
fn _ZN2JS24IncrementalObjectBarrierEP8JSObject(obj: *mut JSObject);
fn _ZN2JS16WasIncrementalGCEP9JSRuntime(rt: *mut JSRuntime) -> bool;
fn _ZN2JS23IsGenerationalGCEnabledEP9JSRuntime(rt: *mut JSRuntime)
-> bool;
fn _ZN2JS11GetGCNumberEv() -> size_t;
fn _ZN2JS15ShrinkGCBuffersEP9JSRuntime(rt: *mut JSRuntime);
fn _ZN2JS28UnmarkGrayGCThingRecursivelyENS_9GCCellPtrE(thing: GCCellPtr)
-> bool;
fn _ZN2JS6PokeGCEP9JSRuntime(rt: *mut JSRuntime);
fn _ZN2JS14NotifyDidPaintEP9JSRuntime(rt: *mut JSRuntime);
fn _ZN2JS11isGCEnabledEv() -> bool;
fn _ZN2JS21HeapObjectPostBarrierEPP8JSObjectS1_S1_(objp:
*mut *mut JSObject,
prev: *mut JSObject,
next: *mut JSObject);
fn _ZN2JS26AssertGCThingMustBeTenuredEP8JSObject(obj: *mut JSObject);
fn _ZN2JS34AssertGCThingIsNotAnObjectSubclassEPN2js2gc4CellE(cell:
*mut Cell);
fn _ZN2JS32IsOptimizedPlaceholderMagicValueERKNS_5ValueE(v: &Value)
-> bool;
fn _ZN2JS8SameTypeERKNS_5ValueES2_(lhs: &Value, rhs: &Value) -> bool;
fn _ZN2JS20HeapValuePostBarrierEPNS_5ValueERKS0_S3_(valuep: *mut Value,
prev: &Value,
next: &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_5ValueEb(stackSlots: u32, sp: *mut Value,
constructing: bool) -> CallArgs;
fn _Z7JS_THISP9JSContextPN2JS5ValueE(cx: *mut JSContext, vp: *mut Value)
-> Value;
fn _Z23INTERNED_STRING_TO_JSIDP9JSContextP8JSString(cx: *mut JSContext,
str: *mut JSString)
-> jsid;
fn _ZN2js19DELEGATED_CLASSSPECEPKNS_9ClassSpecE(spec: *const ClassSpec)
-> ClassObjectCreationOp;
fn _ZN2js13ObjectClassIsER8JSObjectNS_12ESClassValueEP9JSContext(obj:
&mut JSObject,
classValue:
ESClassValue,
cx:
*mut JSContext)
-> bool;
fn _ZN2js17IsObjectWithClassERKN2JS5ValueENS_12ESClassValueEP9JSContext(v:
&Value,
classValue:
ESClassValue,
cx:
*mut JSContext)
-> bool;
fn _ZN2js5UnboxEP9JSContextN2JS6HandleIP8JSObjectEENS2_13MutableHandleINS2_5ValueEEE(cx:
*mut JSContext,
obj:
HandleObject,
vp:
MutableHandleValue)
-> bool;
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 _ZN2JS18GCTraceKindToAsciiENS_9TraceKindE(kind: TraceKind)
-> *const ::libc::c_char;
fn _Z18JS_CallValueTracerP8JSTracerPN2JS4HeapINS1_5ValueEEEPKc(trc:
*mut JSTracer,
valuep:
*mut Heap<Value>,
name:
*const ::libc::c_char);
fn _Z15JS_CallIdTracerP8JSTracerPN2JS4HeapI4jsidEEPKc(trc: *mut JSTracer,
idp:
*mut Heap<jsid>,
name:
*const ::libc::c_char);
fn _Z19JS_CallObjectTracerP8JSTracerPN2JS4HeapIP8JSObjectEEPKc(trc:
*mut JSTracer,
objp:
*mut Heap<*mut JSObject>,
name:
*const ::libc::c_char);
fn _Z19JS_CallStringTracerP8JSTracerPN2JS4HeapIP8JSStringEEPKc(trc:
*mut JSTracer,
strp:
*mut Heap<*mut JSString>,
name:
*const ::libc::c_char);
fn _Z19JS_CallScriptTracerP8JSTracerPN2JS4HeapIP8JSScriptEEPKc(trc:
*mut JSTracer,
scriptp:
*mut Heap<*mut JSScript>,
name:
*const ::libc::c_char);
fn _Z21JS_CallFunctionTracerP8JSTracerPN2JS4HeapIP10JSFunctionEEPKc(trc:
*mut JSTracer,
funp:
*mut Heap<*mut JSFunction>,
name:
*const ::libc::c_char);
fn _Z29JS_CallUnbarrieredValueTracerP8JSTracerPN2JS5ValueEPKc(trc:
*mut JSTracer,
valuep:
*mut Value,
name:
*const ::libc::c_char);
fn _Z26JS_CallUnbarrieredIdTracerP8JSTracerP4jsidPKc(trc: *mut JSTracer,
idp: *mut jsid,
name:
*const ::libc::c_char);
fn _Z30JS_CallUnbarrieredObjectTracerP8JSTracerPP8JSObjectPKc(trc:
*mut JSTracer,
objp:
*mut *mut JSObject,
name:
*const ::libc::c_char);
fn _Z30JS_CallUnbarrieredStringTracerP8JSTracerPP8JSStringPKc(trc:
*mut JSTracer,
strp:
*mut *mut JSString,
name:
*const ::libc::c_char);
fn _Z30JS_CallUnbarrieredScriptTracerP8JSTracerPP8JSScriptPKc(trc:
*mut JSTracer,
scriptp:
*mut *mut JSScript,
name:
*const ::libc::c_char);
fn _Z26JS_CallTenuredObjectTracerP8JSTracerPN2JS11TenuredHeapIP8JSObjectEEPKc(trc:
*mut JSTracer,
objp:
*mut TenuredHeap<*mut JSObject>,
name:
*const ::libc::c_char);
fn _Z16JS_TraceChildrenP8JSTracerPvN2JS9TraceKindE(trc: *mut JSTracer,
thing:
*mut ::libc::c_void,
kind: TraceKind);
fn _Z15JS_TraceRuntimeP8JSTracer(trc: *mut JSTracer);
fn _Z20JS_TraceIncomingCCWsP8JSTracerRKN2js7HashSetIPN2JS4ZoneENS1_13DefaultHasherIS5_EENS1_17SystemAllocPolicyEEE(trc:
*mut JSTracer,
zones:
&ZoneSet);
fn _Z20JS_GetTraceThingInfoPcjP8JSTracerPvN2JS9TraceKindEb(buf:
*mut ::libc::c_char,
bufsize:
size_t,
trc:
*mut JSTracer,
thing:
*mut ::libc::c_void,
kind:
TraceKind,
includeDetails:
bool);
fn _Z22JS_StringHasBeenPinnedP9JSContextP8JSString(cx: *mut JSContext,
str: *mut JSString)
-> bool;
fn _Z11JS_CallOnceP14PRCallOnceTypePFbvE(once: *mut JSCallOnceType,
func: JSInitCallback) -> bool;
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 _Z16JS_ValueToObjectP9JSContextN2JS6HandleINS1_5ValueEEENS1_13MutableHandleIP8JSObjectEE(cx:
*mut JSContext,
v:
HandleValue,
objp:
MutableHandleObject)
-> bool;
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<Value>)
-> *mut JSString;
fn _Z16JS_DoubleIsInt32dPi(d: f64, ip: *mut i32) -> bool;
fn _Z14JS_TypeOfValueP9JSContextN2JS6HandleINS1_5ValueEEE(cx:
*mut JSContext,
v:
Handle<Value>)
-> JSType;
fn _Z16JS_StrictlyEqualP9JSContextN2JS6HandleINS1_5ValueEEES4_Pb(cx:
*mut JSContext,
v1:
Handle<Value>,
v2:
Handle<Value>,
equal:
*mut bool)
-> bool;
fn _Z15JS_LooselyEqualP9JSContextN2JS6HandleINS1_5ValueEEES4_Pb(cx:
*mut JSContext,
v1:
Handle<Value>,
v2:
Handle<Value>,
equal:
*mut bool)
-> bool;
fn _Z12JS_SameValueP9JSContextN2JS6HandleINS1_5ValueEEES4_Pb(cx:
*mut JSContext,
v1:
Handle<Value>,
v2:
Handle<Value>,
same:
*mut bool)
-> bool;
fn _Z24JS_IsBuiltinEvalFunctionP10JSFunction(fun: *mut JSFunction)
-> bool;
fn _Z31JS_IsBuiltinFunctionConstructorP10JSFunction(fun: *mut JSFunction)
-> bool;
fn _Z7JS_Initv() -> bool;
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)
-> bool;
fn _Z33JS_SetCurrentEmbedderTimeFunctionPFdvE(timeFn:
JS_CurrentEmbedderTimeFunction);
fn _Z25JS_GetCurrentEmbedderTimev() -> f64;
fn _Z20JS_GetRuntimePrivateP9JSRuntime(rt: *mut JSRuntime)
-> *mut ::libc::c_void;
fn _Z13JS_GetRuntimeP9JSContext(cx: *mut JSContext) -> *mut JSRuntime;
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);
fn _Z13JS_NewContextP9JSRuntimej(rt: *mut JSRuntime,
stackChunkSize: 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 ::libc::c_char;
fn _Z18JS_StringToVersionPKc(string: *const ::libc::c_char) -> 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 ::libc::c_char;
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)
-> bool;
fn _Z12JS_WrapValueP9JSContextN2JS13MutableHandleINS1_5ValueEEE(cx:
*mut JSContext,
vp:
MutableHandleValue)
-> bool;
fn _Z19JS_TransplantObjectP9JSContextN2JS6HandleIP8JSObjectEES5_(cx:
*mut JSContext,
origobj:
HandleObject,
target:
HandleObject)
-> *mut JSObject;
fn _Z34JS_RefreshCrossCompartmentWrappersP9JSContextN2JS6HandleIP8JSObjectEE(cx:
*mut JSContext,
obj:
Handle<*mut JSObject>)
-> bool;
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>)
-> bool;
fn _Z23JS_ResolveStandardClassP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEEPb(cx:
*mut JSContext,
obj:
HandleObject,
id:
HandleId,
resolved:
*mut bool)
-> bool;
fn _Z26JS_MayResolveStandardClassRK11JSAtomState4jsidP8JSObject(names:
&JSAtomState,
id: jsid,
maybeObj:
*mut JSObject)
-> bool;
fn _Z27JS_EnumerateStandardClassesP9JSContextN2JS6HandleIP8JSObjectEE(cx:
*mut JSContext,
obj:
HandleObject)
-> bool;
fn _Z17JS_GetClassObjectP9JSContext10JSProtoKeyN2JS13MutableHandleIP8JSObjectEE(cx:
*mut JSContext,
key:
JSProtoKey,
objp:
MutableHandle<*mut JSObject>)
-> bool;
fn _Z20JS_GetClassPrototypeP9JSContext10JSProtoKeyN2JS13MutableHandleIP8JSObjectEE(cx:
*mut JSContext,
key:
JSProtoKey,
objp:
MutableHandle<*mut JSObject>)
-> bool;
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) -> bool;
fn _Z32JS_GetGlobalForCompartmentOrNullP9JSContextP13JSCompartment(cx:
*mut JSContext,
c:
*mut JSCompartment)
-> *mut JSObject;
fn _ZN2JS19CurrentGlobalOrNullEP9JSContext(cx: *mut JSContext)
-> *mut JSObject;
fn _Z19JS_InitReflectParseP9JSContextN2JS6HandleIP8JSObjectEE(cx:
*mut JSContext,
global:
HandleObject)
-> bool;
fn _Z27JS_DefineProfilingFunctionsP9JSContextN2JS6HandleIP8JSObjectEE(cx:
*mut JSContext,
obj:
HandleObject)
-> bool;
fn _Z23JS_DefineDebuggerObjectP9JSContextN2JS6HandleIP8JSObjectEE(cx:
*mut JSContext,
obj:
HandleObject)
-> bool;
fn _Z18JS_InitCTypesClassP9JSContextN2JS6HandleIP8JSObjectEE(cx:
*mut JSContext,
global:
HandleObject)
-> bool;
fn _Z21JS_SetCTypesCallbacksP8JSObjectPK17JSCTypesCallbacks(ctypesObj:
*mut JSObject,
callbacks:
*const JSCTypesCallbacks);
fn _Z9JS_mallocP9JSContextj(cx: *mut JSContext, nbytes: size_t)
-> *mut ::libc::c_void;
fn _Z10JS_reallocP9JSContextPvjj(cx: *mut JSContext,
p: *mut ::libc::c_void, oldBytes: size_t,
newBytes: size_t) -> *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: size_t);
fn _Z9JS_strdupP9JSContextPKc(cx: *mut JSContext,
s: *const ::libc::c_char)
-> *mut ::libc::c_char;
fn _Z9JS_strdupP9JSRuntimePKc(rt: *mut JSRuntime,
s: *const ::libc::c_char)
-> *mut ::libc::c_char;
fn _Z24JS_AddExtraGCRootsTracerP9JSRuntimePFvP8JSTracerPvES3_(rt:
*mut JSRuntime,
traceOp:
JSTraceDataOp,
data:
*mut ::libc::c_void)
-> bool;
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)
-> bool;
fn _Z25JS_RemoveFinalizeCallbackP9JSRuntimePFvP8JSFreeOp16JSFinalizeStatusbPvE(rt:
*mut JSRuntime,
cb:
JSFinalizeCallback);
fn _Z25JS_AddWeakPointerCallbackP9JSRuntimePFvS0_PvES1_(rt:
*mut JSRuntime,
cb:
JSWeakPointerCallback,
data:
*mut ::libc::c_void)
-> bool;
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 u16,
length:
size_t,
fin:
*const JSStringFinalizer)
-> *mut JSString;
fn _Z19JS_IsExternalStringP8JSString(str: *mut JSString) -> bool;
fn _Z29JS_GetExternalStringFinalizerP8JSString(str: *mut JSString)
-> *const JSStringFinalizer;
fn _Z22JS_SetNativeStackQuotaP9JSRuntimejjj(cx: *mut JSRuntime,
systemCodeStackSize: size_t,
trustedScriptStackSize:
size_t,
untrustedScriptStackSize:
size_t);
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)
-> bool;
fn _Z13JS_StringToIdP9JSContextN2JS6HandleIP8JSStringEENS1_13MutableHandleI4jsidEE(cx:
*mut JSContext,
s:
HandleString,
idp:
MutableHandleId)
-> bool;
fn _Z12JS_IdToValueP9JSContext4jsidN2JS13MutableHandleINS2_5ValueEEE(cx:
*mut JSContext,
id:
jsid,
vp:
MutableHandle<Value>)
-> bool;
fn _Z15JS_DefaultValueP9JSContextN2JS6HandleIP8JSObjectEE6JSTypeNS1_13MutableHandleINS1_5ValueEEE(cx:
*mut JSContext,
obj:
Handle<*mut JSObject>,
hint:
JSType,
vp:
MutableHandle<Value>)
-> bool;
fn _Z15JS_PropertyStubP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEENS1_13MutableHandleINS1_5ValueEEE(cx:
*mut JSContext,
obj:
HandleObject,
id:
HandleId,
vp:
MutableHandleValue)
-> bool;
fn _Z21JS_StrictPropertyStubP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEENS1_13MutableHandleINS1_5ValueEEERNS1_14ObjectOpResultE(cx:
*mut JSContext,
obj:
HandleObject,
id:
HandleId,
vp:
MutableHandleValue,
result:
&mut ObjectOpResult)
-> bool;
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>)
-> bool;
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)
-> bool;
fn _Z14JS_HasInstanceP9JSContextN2JS6HandleIP8JSObjectEENS2_INS1_5ValueEEEPb(cx:
*mut JSContext,
obj:
Handle<*mut JSObject>,
v:
Handle<Value>,
bp:
*mut bool)
-> bool;
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)
-> bool;
fn _Z15JS_SetPrototypeP9JSContextN2JS6HandleIP8JSObjectEES5_(cx:
*mut JSContext,
obj:
HandleObject,
proto:
HandleObject)
-> bool;
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:
&CompartmentOptions)
-> *mut JSObject;
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 bool)
-> bool;
fn _Z11JS_IsNativeP8JSObject(obj: *mut JSObject) -> bool;
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>)
-> bool;
fn _Z15JS_FreezeObjectP9JSContextN2JS6HandleIP8JSObjectEE(cx:
*mut JSContext,
obj:
Handle<*mut JSObject>)
-> bool;
fn _Z20JS_PreventExtensionsP9JSContextN2JS6HandleIP8JSObjectEERNS1_14ObjectOpResultE(cx:
*mut JSContext,
obj:
HandleObject,
result:
&mut ObjectOpResult)
-> bool;
fn _Z6JS_NewP9JSContextN2JS6HandleIP8JSObjectEERKNS1_16HandleValueArrayE(cx:
*mut JSContext,
ctor:
HandleObject,
args:
&HandleValueArray)
-> *mut JSObject;
fn _ZN2JS34ObjectToCompletePropertyDescriptorEP9JSContextNS_6HandleIP8JSObjectEENS2_INS_5ValueEEENS_13MutableHandleI20JSPropertyDescriptorEE(cx:
*mut JSContext,
obj:
HandleObject,
descriptor:
HandleValue,
desc:
MutableHandle<JSPropertyDescriptor>)
-> bool;
fn _Z17JS_DefinePropertyP9JSContextN2JS6HandleIP8JSObjectEEPKcNS2_INS1_5ValueEEEjPFbS0_jPS8_ESC_(cx:
*mut JSContext,
obj:
HandleObject,
name:
*const ::libc::c_char,
value:
HandleValue,
attrs:
u32,
getter:
JSNative,
setter:
JSNative)
-> bool;
fn _Z17JS_DefinePropertyP9JSContextN2JS6HandleIP8JSObjectEEPKcS5_jPFbS0_jPNS1_5ValueEESB_(cx:
*mut JSContext,
obj:
HandleObject,
name:
*const ::libc::c_char,
value:
HandleObject,
attrs:
u32,
getter:
JSNative,
setter:
JSNative)
-> bool;
fn _Z17JS_DefinePropertyP9JSContextN2JS6HandleIP8JSObjectEEPKcNS2_IP8JSStringEEjPFbS0_jPNS1_5ValueEESE_(cx:
*mut JSContext,
obj:
HandleObject,
name:
*const ::libc::c_char,
value:
HandleString,
attrs:
u32,
getter:
JSNative,
setter:
JSNative)
-> bool;
fn _Z17JS_DefinePropertyP9JSContextN2JS6HandleIP8JSObjectEEPKcijPFbS0_jPNS1_5ValueEESB_(cx:
*mut JSContext,
obj:
HandleObject,
name:
*const ::libc::c_char,
value:
i32,
attrs:
u32,
getter:
JSNative,
setter:
JSNative)
-> bool;
fn _Z17JS_DefinePropertyP9JSContextN2JS6HandleIP8JSObjectEEPKcjjPFbS0_jPNS1_5ValueEESB_(cx:
*mut JSContext,
obj:
HandleObject,
name:
*const ::libc::c_char,
value:
u32,
attrs:
u32,
getter:
JSNative,
setter:
JSNative)
-> bool;
fn _Z17JS_DefinePropertyP9JSContextN2JS6HandleIP8JSObjectEEPKcdjPFbS0_jPNS1_5ValueEESB_(cx:
*mut JSContext,
obj:
HandleObject,
name:
*const ::libc::c_char,
value:
f64,
attrs:
u32,
getter:
JSNative,
setter:
JSNative)
-> bool;
fn _Z21JS_DefinePropertyByIdP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEENS2_INS1_5ValueEEEjPFbS0_jPS8_ESC_(cx:
*mut JSContext,
obj:
HandleObject,
id:
HandleId,
value:
HandleValue,
attrs:
u32,
getter:
JSNative,
setter:
JSNative)
-> bool;
fn _Z21JS_DefinePropertyByIdP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEES5_jPFbS0_jPNS1_5ValueEESB_(cx:
*mut JSContext,
obj:
HandleObject,
id:
HandleId,
value:
HandleObject,
attrs:
u32,
getter:
JSNative,
setter:
JSNative)
-> bool;
fn _Z21JS_DefinePropertyByIdP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEENS2_IP8JSStringEEjPFbS0_jPNS1_5ValueEESE_(cx:
*mut JSContext,
obj:
HandleObject,
id:
HandleId,
value:
HandleString,
attrs:
u32,
getter:
JSNative,
setter:
JSNative)
-> bool;
fn _Z21JS_DefinePropertyByIdP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEEijPFbS0_jPNS1_5ValueEESB_(cx:
*mut JSContext,
obj:
HandleObject,
id:
HandleId,
value:
i32,
attrs:
u32,
getter:
JSNative,
setter:
JSNative)
-> bool;
fn _Z21JS_DefinePropertyByIdP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEEjjPFbS0_jPNS1_5ValueEESB_(cx:
*mut JSContext,
obj:
HandleObject,
id:
HandleId,
value:
u32,
attrs:
u32,
getter:
JSNative,
setter:
JSNative)
-> bool;
fn _Z21JS_DefinePropertyByIdP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEEdjPFbS0_jPNS1_5ValueEESB_(cx:
*mut JSContext,
obj:
HandleObject,
id:
HandleId,
value:
f64,
attrs:
u32,
getter:
JSNative,
setter:
JSNative)
-> bool;
fn _Z21JS_DefinePropertyByIdP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEENS2_I20JSPropertyDescriptorEERNS1_14ObjectOpResultE(cx:
*mut JSContext,
obj:
HandleObject,
id:
HandleId,
desc:
Handle<JSPropertyDescriptor>,
result:
&mut ObjectOpResult)
-> bool;
fn _Z21JS_DefinePropertyByIdP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEENS2_I20JSPropertyDescriptorEE(cx:
*mut JSContext,
obj:
HandleObject,
id:
HandleId,
desc:
Handle<JSPropertyDescriptor>)
-> bool;
fn _Z15JS_DefineObjectP9JSContextN2JS6HandleIP8JSObjectEEPKcPK7JSClassj(cx:
*mut JSContext,
obj:
HandleObject,
name:
*const ::libc::c_char,
clasp:
*const JSClass,
attrs:
u32)
-> *mut JSObject;
fn _Z21JS_DefineConstDoublesP9JSContextN2JS6HandleIP8JSObjectEEPK17JSConstScalarSpecIdE(cx:
*mut JSContext,
obj:
HandleObject,
cds:
*const JSConstDoubleSpec)
-> bool;
fn _Z22JS_DefineConstIntegersP9JSContextN2JS6HandleIP8JSObjectEEPK17JSConstScalarSpecIiE(cx:
*mut JSContext,
obj:
HandleObject,
cis:
*const JSConstIntegerSpec)
-> bool;
fn _Z19JS_DefinePropertiesP9JSContextN2JS6HandleIP8JSObjectEEPK14JSPropertySpec(cx:
*mut JSContext,
obj:
HandleObject,
ps:
*const JSPropertySpec)
-> bool;
fn _Z24JS_AlreadyHasOwnPropertyP9JSContextN2JS6HandleIP8JSObjectEEPKcPb(cx:
*mut JSContext,
obj:
HandleObject,
name:
*const ::libc::c_char,
foundp:
*mut bool)
-> bool;
fn _Z28JS_AlreadyHasOwnPropertyByIdP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEEPb(cx:
*mut JSContext,
obj:
HandleObject,
id:
HandleId,
foundp:
*mut bool)
-> bool;
fn _Z14JS_HasPropertyP9JSContextN2JS6HandleIP8JSObjectEEPKcPb(cx:
*mut JSContext,
obj:
HandleObject,
name:
*const ::libc::c_char,
foundp:
*mut bool)
-> bool;
fn _Z18JS_HasPropertyByIdP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEEPb(cx:
*mut JSContext,
obj:
HandleObject,
id:
HandleId,
foundp:
*mut bool)
-> bool;
fn _Z31JS_GetOwnPropertyDescriptorByIdP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEENS1_13MutableHandleI20JSPropertyDescriptorEE(cx:
*mut JSContext,
obj:
HandleObject,
id:
HandleId,
desc:
MutableHandle<JSPropertyDescriptor>)
-> bool;
fn _Z27JS_GetOwnPropertyDescriptorP9JSContextN2JS6HandleIP8JSObjectEEPKcNS1_13MutableHandleI20JSPropertyDescriptorEE(cx:
*mut JSContext,
obj:
HandleObject,
name:
*const ::libc::c_char,
desc:
MutableHandle<JSPropertyDescriptor>)
-> bool;
fn _Z29JS_GetOwnUCPropertyDescriptorP9JSContextN2JS6HandleIP8JSObjectEEPKDsNS1_13MutableHandleI20JSPropertyDescriptorEE(cx:
*mut JSContext,
obj:
HandleObject,
name:
*const u16,
desc:
MutableHandle<JSPropertyDescriptor>)
-> bool;
fn _Z21JS_HasOwnPropertyByIdP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEEPb(cx:
*mut JSContext,
obj:
HandleObject,
id:
HandleId,
foundp:
*mut bool)
-> bool;
fn _Z17JS_HasOwnPropertyP9JSContextN2JS6HandleIP8JSObjectEEPKcPb(cx:
*mut JSContext,
obj:
HandleObject,
name:
*const ::libc::c_char,
foundp:
*mut bool)
-> bool;
fn _Z28JS_GetPropertyDescriptorByIdP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEENS1_13MutableHandleI20JSPropertyDescriptorEE(cx:
*mut JSContext,
obj:
HandleObject,
id:
HandleId,
desc:
MutableHandle<JSPropertyDescriptor>)
-> bool;
fn _Z24JS_GetPropertyDescriptorP9JSContextN2JS6HandleIP8JSObjectEEPKcNS1_13MutableHandleI20JSPropertyDescriptorEE(cx:
*mut JSContext,
obj:
HandleObject,
name:
*const ::libc::c_char,
desc:
MutableHandle<JSPropertyDescriptor>)
-> bool;
fn _Z14JS_GetPropertyP9JSContextN2JS6HandleIP8JSObjectEEPKcNS1_13MutableHandleINS1_5ValueEEE(cx:
*mut JSContext,
obj:
HandleObject,
name:
*const ::libc::c_char,
vp:
MutableHandleValue)
-> bool;
fn _Z18JS_GetPropertyByIdP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEENS1_13MutableHandleINS1_5ValueEEE(cx:
*mut JSContext,
obj:
HandleObject,
id:
HandleId,
vp:
MutableHandleValue)
-> bool;
fn _Z23JS_ForwardGetPropertyToP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEES5_NS1_13MutableHandleINS1_5ValueEEE(cx:
*mut JSContext,
obj:
HandleObject,
id:
HandleId,
onBehalfOf:
HandleObject,
vp:
MutableHandleValue)
-> bool;
fn _Z14JS_SetPropertyP9JSContextN2JS6HandleIP8JSObjectEEPKcNS2_INS1_5ValueEEE(cx:
*mut JSContext,
obj:
HandleObject,
name:
*const ::libc::c_char,
v:
HandleValue)
-> bool;
fn _Z18JS_SetPropertyByIdP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEENS2_INS1_5ValueEEE(cx:
*mut JSContext,
obj:
HandleObject,
id:
HandleId,
v:
HandleValue)
-> bool;
fn _Z23JS_ForwardSetPropertyToP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEENS2_INS1_5ValueEEES9_RNS1_14ObjectOpResultE(cx:
*mut JSContext,
obj:
HandleObject,
id:
HandleId,
v:
HandleValue,
receiver:
HandleValue,
result:
&mut ObjectOpResult)
-> bool;
fn _Z17JS_DeletePropertyP9JSContextN2JS6HandleIP8JSObjectEEPKc(cx:
*mut JSContext,
obj:
HandleObject,
name:
*const ::libc::c_char)
-> bool;
fn _Z17JS_DeletePropertyP9JSContextN2JS6HandleIP8JSObjectEEPKcRNS1_14ObjectOpResultE(cx:
*mut JSContext,
obj:
HandleObject,
name:
*const ::libc::c_char,
result:
&mut ObjectOpResult)
-> bool;
fn _Z21JS_DeletePropertyByIdP9JSContextN2JS6HandleIP8JSObjectEE4jsid(cx:
*mut JSContext,
obj:
HandleObject,
id:
jsid)
-> bool;
fn _Z21JS_DeletePropertyByIdP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEERNS1_14ObjectOpResultE(cx:
*mut JSContext,
obj:
HandleObject,
id:
HandleId,
result:
&mut ObjectOpResult)
-> bool;
fn _Z19JS_DefineUCPropertyP9JSContextN2JS6HandleIP8JSObjectEEPKDsjNS2_INS1_5ValueEEEjPFbS0_jPS8_ESC_(cx:
*mut JSContext,
obj:
HandleObject,
name:
*const u16,
namelen:
size_t,
value:
HandleValue,
attrs:
u32,
getter:
JSNative,
setter:
JSNative)
-> bool;
fn _Z19JS_DefineUCPropertyP9JSContextN2JS6HandleIP8JSObjectEEPKDsjS5_jPFbS0_jPNS1_5ValueEESB_(cx:
*mut JSContext,
obj:
HandleObject,
name:
*const u16,
namelen:
size_t,
value:
HandleObject,
attrs:
u32,
getter:
JSNative,
setter:
JSNative)
-> bool;
fn _Z19JS_DefineUCPropertyP9JSContextN2JS6HandleIP8JSObjectEEPKDsjNS2_IP8JSStringEEjPFbS0_jPNS1_5ValueEESE_(cx:
*mut JSContext,
obj:
HandleObject,
name:
*const u16,
namelen:
size_t,
value:
HandleString,
attrs:
u32,
getter:
JSNative,
setter:
JSNative)
-> bool;
fn _Z19JS_DefineUCPropertyP9JSContextN2JS6HandleIP8JSObjectEEPKDsjijPFbS0_jPNS1_5ValueEESB_(cx:
*mut JSContext,
obj:
HandleObject,
name:
*const u16,
namelen:
size_t,
value:
i32,
attrs:
u32,
getter:
JSNative,
setter:
JSNative)
-> bool;
fn _Z19JS_DefineUCPropertyP9JSContextN2JS6HandleIP8JSObjectEEPKDsjjjPFbS0_jPNS1_5ValueEESB_(cx:
*mut JSContext,
obj:
HandleObject,
name:
*const u16,
namelen:
size_t,
value:
u32,
attrs:
u32,
getter:
JSNative,
setter:
JSNative)
-> bool;
fn _Z19JS_DefineUCPropertyP9JSContextN2JS6HandleIP8JSObjectEEPKDsjdjPFbS0_jPNS1_5ValueEESB_(cx:
*mut JSContext,
obj:
HandleObject,
name:
*const u16,
namelen:
size_t,
value:
f64,
attrs:
u32,
getter:
JSNative,
setter:
JSNative)
-> bool;
fn _Z19JS_DefineUCPropertyP9JSContextN2JS6HandleIP8JSObjectEEPKDsjNS2_I20JSPropertyDescriptorEERNS1_14ObjectOpResultE(cx:
*mut JSContext,
obj:
HandleObject,
name:
*const u16,
namelen:
size_t,
desc:
Handle<JSPropertyDescriptor>,
result:
&mut ObjectOpResult)
-> bool;
fn _Z19JS_DefineUCPropertyP9JSContextN2JS6HandleIP8JSObjectEEPKDsjNS2_I20JSPropertyDescriptorEE(cx:
*mut JSContext,
obj:
HandleObject,
name:
*const u16,
namelen:
size_t,
desc:
Handle<JSPropertyDescriptor>)
-> bool;
fn _Z26JS_AlreadyHasOwnUCPropertyP9JSContextN2JS6HandleIP8JSObjectEEPKDsjPb(cx:
*mut JSContext,
obj:
HandleObject,
name:
*const u16,
namelen:
size_t,
foundp:
*mut bool)
-> bool;
fn _Z16JS_HasUCPropertyP9JSContextN2JS6HandleIP8JSObjectEEPKDsjPb(cx:
*mut JSContext,
obj:
HandleObject,
name:
*const u16,
namelen:
size_t,
vp:
*mut bool)
-> bool;
fn _Z16JS_GetUCPropertyP9JSContextN2JS6HandleIP8JSObjectEEPKDsjNS1_13MutableHandleINS1_5ValueEEE(cx:
*mut JSContext,
obj:
HandleObject,
name:
*const u16,
namelen:
size_t,
vp:
MutableHandleValue)
-> bool;
fn _Z16JS_SetUCPropertyP9JSContextN2JS6HandleIP8JSObjectEEPKDsjNS2_INS1_5ValueEEE(cx:
*mut JSContext,
obj:
HandleObject,
name:
*const u16,
namelen:
size_t,
v:
HandleValue)
-> bool;
fn _Z19JS_DeleteUCPropertyP9JSContextN2JS6HandleIP8JSObjectEEPKDsjRNS1_14ObjectOpResultE(cx:
*mut JSContext,
obj:
HandleObject,
name:
*const u16,
namelen:
size_t,
result:
&mut ObjectOpResult)
-> bool;
fn _Z17JS_NewArrayObjectP9JSContextRKN2JS16HandleValueArrayE(cx:
*mut JSContext,
contents:
&HandleValueArray)
-> *mut JSObject;
fn _Z17JS_NewArrayObjectP9JSContextj(cx: *mut JSContext, length: size_t)
-> *mut JSObject;
fn _Z16JS_IsArrayObjectP9JSContextN2JS6HandleINS1_5ValueEEE(cx:
*mut JSContext,
value:
HandleValue)
-> bool;
fn _Z16JS_IsArrayObjectP9JSContextN2JS6HandleIP8JSObjectEE(cx:
*mut JSContext,
obj:
HandleObject)
-> bool;
fn _Z17JS_GetArrayLengthP9JSContextN2JS6HandleIP8JSObjectEEPj(cx:
*mut JSContext,
obj:
Handle<*mut JSObject>,
lengthp:
*mut u32)
-> bool;
fn _Z17JS_SetArrayLengthP9JSContextN2JS6HandleIP8JSObjectEEj(cx:
*mut JSContext,
obj:
Handle<*mut JSObject>,
length: u32)
-> bool;
fn _Z16JS_DefineElementP9JSContextN2JS6HandleIP8JSObjectEEjNS2_INS1_5ValueEEEjPFbS0_jPS6_ESA_(cx:
*mut JSContext,
obj:
HandleObject,
index:
u32,
value:
HandleValue,
attrs:
u32,
getter:
JSNative,
setter:
JSNative)
-> bool;
fn _Z16JS_DefineElementP9JSContextN2JS6HandleIP8JSObjectEEjS5_jPFbS0_jPNS1_5ValueEES9_(cx:
*mut JSContext,
obj:
HandleObject,
index:
u32,
value:
HandleObject,
attrs:
u32,
getter:
JSNative,
setter:
JSNative)
-> bool;
fn _Z16JS_DefineElementP9JSContextN2JS6HandleIP8JSObjectEEjNS2_IP8JSStringEEjPFbS0_jPNS1_5ValueEESC_(cx:
*mut JSContext,
obj:
HandleObject,
index:
u32,
value:
HandleString,
attrs:
u32,
getter:
JSNative,
setter:
JSNative)
-> bool;
fn _Z16JS_DefineElementP9JSContextN2JS6HandleIP8JSObjectEEjijPFbS0_jPNS1_5ValueEES9_(cx:
*mut JSContext,
obj:
HandleObject,
index:
u32,
value:
i32,
attrs:
u32,
getter:
JSNative,
setter:
JSNative)
-> bool;
fn _Z16JS_DefineElementP9JSContextN2JS6HandleIP8JSObjectEEjjjPFbS0_jPNS1_5ValueEES9_(cx:
*mut JSContext,
obj:
HandleObject,
index:
u32,
value:
u32,
attrs:
u32,
getter:
JSNative,
setter:
JSNative)
-> bool;
fn _Z16JS_DefineElementP9JSContextN2JS6HandleIP8JSObjectEEjdjPFbS0_jPNS1_5ValueEES9_(cx:
*mut JSContext,
obj:
HandleObject,
index:
u32,
value:
f64,
attrs:
u32,
getter:
JSNative,
setter:
JSNative)
-> bool;
fn _Z23JS_AlreadyHasOwnElementP9JSContextN2JS6HandleIP8JSObjectEEjPb(cx:
*mut JSContext,
obj:
HandleObject,
index:
u32,
foundp:
*mut bool)
-> bool;
fn _Z13JS_HasElementP9JSContextN2JS6HandleIP8JSObjectEEjPb(cx:
*mut JSContext,
obj:
HandleObject,
index: u32,
foundp:
*mut bool)
-> bool;
fn _Z13JS_GetElementP9JSContextN2JS6HandleIP8JSObjectEEjNS1_13MutableHandleINS1_5ValueEEE(cx:
*mut JSContext,
obj:
HandleObject,
index:
u32,
vp:
MutableHandleValue)
-> bool;
fn _Z22JS_ForwardGetElementToP9JSContextN2JS6HandleIP8JSObjectEEjS5_NS1_13MutableHandleINS1_5ValueEEE(cx:
*mut JSContext,
obj:
HandleObject,
index:
u32,
onBehalfOf:
HandleObject,
vp:
MutableHandleValue)
-> bool;
fn _Z13JS_SetElementP9JSContextN2JS6HandleIP8JSObjectEEjNS2_INS1_5ValueEEE(cx:
*mut JSContext,
obj:
HandleObject,
index:
u32,
v:
HandleValue)
-> bool;
fn _Z13JS_SetElementP9JSContextN2JS6HandleIP8JSObjectEEjS5_(cx:
*mut JSContext,
obj:
HandleObject,
index: u32,
v:
HandleObject)
-> bool;
fn _Z13JS_SetElementP9JSContextN2JS6HandleIP8JSObjectEEjNS2_IP8JSStringEE(cx:
*mut JSContext,
obj:
HandleObject,
index:
u32,
v:
HandleString)
-> bool;
fn _Z13JS_SetElementP9JSContextN2JS6HandleIP8JSObjectEEji(cx:
*mut JSContext,
obj:
HandleObject,
index: u32,
v: i32) -> bool;
fn _Z13JS_SetElementP9JSContextN2JS6HandleIP8JSObjectEEjj(cx:
*mut JSContext,
obj:
HandleObject,
index: u32,
v: u32) -> bool;
fn _Z13JS_SetElementP9JSContextN2JS6HandleIP8JSObjectEEjd(cx:
*mut JSContext,
obj:
HandleObject,
index: u32,
v: f64) -> bool;
fn _Z16JS_DeleteElementP9JSContextN2JS6HandleIP8JSObjectEEj(cx:
*mut JSContext,
obj:
HandleObject,
index: u32)
-> bool;
fn _Z16JS_DeleteElementP9JSContextN2JS6HandleIP8JSObjectEEjRNS1_14ObjectOpResultE(cx:
*mut JSContext,
obj:
HandleObject,
index:
u32,
result:
&mut ObjectOpResult)
-> bool;
fn _Z36JS_SetAllNonReservedSlotsToUndefinedP9JSContextP8JSObject(cx:
*mut JSContext,
objArg:
*mut JSObject);
fn _Z29JS_NewArrayBufferWithContentsP9JSContextjPv(cx: *mut JSContext,
nbytes: size_t,
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: size_t,
contents:
*mut ::libc::c_void)
-> *mut JSObject;
fn _Z34JS_CreateMappedArrayBufferContentsijj(fd: i32, offset: size_t,
length: size_t)
-> *mut ::libc::c_void;
fn _Z35JS_ReleaseMappedArrayBufferContentsPvj(contents:
*mut ::libc::c_void,
length: size_t);
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 ::libc::c_char)
-> *mut JSFunction;
fn _Z18JS_NewFunctionByIdP9JSContextPFbS0_jPN2JS5ValueEEjjNS1_6HandleI4jsidEE(cx:
*mut JSContext,
call:
JSNative,
nargs:
u32,
flags:
u32,
id:
Handle<jsid>)
-> *mut JSFunction;
fn _ZN2JS21GetSelfHostedFunctionEP9JSContextPKcNS_6HandleI4jsidEEj(cx:
*mut JSContext,
selfHostedName:
*const ::libc::c_char,
id:
Handle<jsid>,
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) -> bool;
fn _ZN2JS13IsConstructorEP8JSObject(obj: *mut JSObject) -> bool;
fn _Z19JS_ObjectIsFunctionP9JSContextP8JSObject(cx: *mut JSContext,
obj: *mut JSObject)
-> bool;
fn _Z19JS_IsNativeFunctionP8JSObjectPFbP9JSContextjPN2JS5ValueEE(funobj:
*mut JSObject,
call:
JSNative)
-> bool;
fn _Z16JS_IsConstructorP10JSFunction(fun: *mut JSFunction) -> bool;
fn _Z18JS_DefineFunctionsP9JSContextN2JS6HandleIP8JSObjectEEPK14JSFunctionSpec26PropertyDefinitionBehavior(cx:
*mut JSContext,
obj:
Handle<*mut JSObject>,
fs:
*const JSFunctionSpec,
behavior:
PropertyDefinitionBehavior)
-> bool;
fn _Z17JS_DefineFunctionP9JSContextN2JS6HandleIP8JSObjectEEPKcPFbS0_jPNS1_5ValueEEjj(cx:
*mut JSContext,
obj:
Handle<*mut JSObject>,
name:
*const ::libc::c_char,
call:
JSNative,
nargs:
u32,
attrs:
u32)
-> *mut JSFunction;
fn _Z19JS_DefineUCFunctionP9JSContextN2JS6HandleIP8JSObjectEEPKDsjPFbS0_jPNS1_5ValueEEjj(cx:
*mut JSContext,
obj:
Handle<*mut JSObject>,
name:
*const u16,
namelen:
size_t,
call:
JSNative,
nargs:
u32,
attrs:
u32)
-> *mut JSFunction;
fn _Z21JS_DefineFunctionByIdP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEEPFbS0_jPNS1_5ValueEEjj(cx:
*mut JSContext,
obj:
Handle<*mut JSObject>,
id:
Handle<jsid>,
call:
JSNative,
nargs:
u32,
attrs:
u32)
-> *mut JSFunction;
fn _ZN2JS19CloneFunctionObjectEP9JSContextNS_6HandleIP8JSObjectEE(cx:
*mut JSContext,
funobj:
HandleObject)
-> *mut JSObject;
fn _ZN2JS19CloneFunctionObjectEP9JSContextNS_6HandleIP8JSObjectEERNS_16AutoVectorRooterIS4_EE(cx:
*mut JSContext,
funobj:
HandleObject,
scopeChain:
&mut AutoObjectVector)
-> *mut JSObject;
fn _Z25JS_BufferIsCompilableUnitP9JSContextN2JS6HandleIP8JSObjectEEPKcj(cx:
*mut JSContext,
obj:
Handle<*mut JSObject>,
utf8:
*const ::libc::c_char,
length:
size_t)
-> bool;
fn _Z16JS_CompileScriptP9JSContextPKcjRKN2JS14CompileOptionsENS3_13MutableHandleIP8JSScriptEE(cx:
*mut JSContext,
ascii:
*const ::libc::c_char,
length:
size_t,
options:
&CompileOptions,
script:
MutableHandleScript)
-> bool;
fn _Z18JS_CompileUCScriptP9JSContextPKDsjRKN2JS14CompileOptionsENS3_13MutableHandleIP8JSScriptEE(cx:
*mut JSContext,
chars:
*const u16,
length:
size_t,
options:
&CompileOptions,
script:
MutableHandleScript)
-> bool;
fn _Z22JS_GetGlobalFromScriptP8JSScript(script: *mut JSScript)
-> *mut JSObject;
fn _Z20JS_GetScriptFilenameP8JSScript(script: *mut JSScript)
-> *const ::libc::c_char;
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:
&ReadOnlyCompileOptions,
srcBuf:
&mut SourceBufferHolder,
script:
MutableHandleScript)
-> bool;
fn _ZN2JS7CompileEP9JSContextRKNS_22ReadOnlyCompileOptionsEPKcjNS_13MutableHandleIP8JSScriptEE(cx:
*mut JSContext,
options:
&ReadOnlyCompileOptions,
bytes:
*const ::libc::c_char,
length:
size_t,
script:
MutableHandleScript)
-> bool;
fn _ZN2JS7CompileEP9JSContextRKNS_22ReadOnlyCompileOptionsEPKDsjNS_13MutableHandleIP8JSScriptEE(cx:
*mut JSContext,
options:
&ReadOnlyCompileOptions,
chars:
*const u16,
length:
size_t,
script:
MutableHandleScript)
-> bool;
fn _ZN2JS7CompileEP9JSContextRKNS_22ReadOnlyCompileOptionsEP8_IO_FILENS_13MutableHandleIP8JSScriptEE(cx:
*mut JSContext,
options:
&ReadOnlyCompileOptions,
file:
*mut FILE,
script:
MutableHandleScript)
-> bool;
fn _ZN2JS7CompileEP9JSContextRKNS_22ReadOnlyCompileOptionsEPKcNS_13MutableHandleIP8JSScriptEE(cx:
*mut JSContext,
options:
&ReadOnlyCompileOptions,
filename:
*const ::libc::c_char,
script:
MutableHandleScript)
-> bool;
fn _ZN2JS27CompileForNonSyntacticScopeEP9JSContextRKNS_22ReadOnlyCompileOptionsERNS_18SourceBufferHolderENS_13MutableHandleIP8JSScriptEE(cx:
*mut JSContext,
options:
&ReadOnlyCompileOptions,
srcBuf:
&mut SourceBufferHolder,
script:
MutableHandleScript)
-> bool;
fn _ZN2JS27CompileForNonSyntacticScopeEP9JSContextRKNS_22ReadOnlyCompileOptionsEPKcjNS_13MutableHandleIP8JSScriptEE(cx:
*mut JSContext,
options:
&ReadOnlyCompileOptions,
bytes:
*const ::libc::c_char,
length:
size_t,
script:
MutableHandleScript)
-> bool;
fn _ZN2JS27CompileForNonSyntacticScopeEP9JSContextRKNS_22ReadOnlyCompileOptionsEPKDsjNS_13MutableHandleIP8JSScriptEE(cx:
*mut JSContext,
options:
&ReadOnlyCompileOptions,
chars:
*const u16,
length:
size_t,
script:
MutableHandleScript)
-> bool;
fn _ZN2JS27CompileForNonSyntacticScopeEP9JSContextRKNS_22ReadOnlyCompileOptionsEP8_IO_FILENS_13MutableHandleIP8JSScriptEE(cx:
*mut JSContext,
options:
&ReadOnlyCompileOptions,
file:
*mut FILE,
script:
MutableHandleScript)
-> bool;
fn _ZN2JS27CompileForNonSyntacticScopeEP9JSContextRKNS_22ReadOnlyCompileOptionsEPKcNS_13MutableHandleIP8JSScriptEE(cx:
*mut JSContext,
options:
&ReadOnlyCompileOptions,
filename:
*const ::libc::c_char,
script:
MutableHandleScript)
-> bool;
fn _ZN2JS19CanCompileOffThreadEP9JSContextRKNS_22ReadOnlyCompileOptionsEj(cx:
*mut JSContext,
options:
&ReadOnlyCompileOptions,
length:
size_t)
-> bool;
fn _ZN2JS16CompileOffThreadEP9JSContextRKNS_22ReadOnlyCompileOptionsEPKDsjPFvPvS7_ES7_(cx:
*mut JSContext,
options:
&ReadOnlyCompileOptions,
chars:
*const u16,
length:
size_t,
callback:
OffThreadCompileCallback,
callbackData:
*mut ::libc::c_void)
-> bool;
fn _ZN2JS21FinishOffThreadScriptEP9JSContextP9JSRuntimePv(maybecx:
*mut JSContext,
rt:
*mut JSRuntime,
token:
*mut ::libc::c_void)
-> *mut JSScript;
fn _ZN2JS15CompileFunctionEP9JSContextRNS_16AutoVectorRooterIP8JSObjectEERKNS_22ReadOnlyCompileOptionsEPKcjPKSB_PKDsjNS_13MutableHandleIP10JSFunctionEE(cx:
*mut JSContext,
scopeChain:
&mut AutoObjectVector,
options:
&ReadOnlyCompileOptions,
name:
*const ::libc::c_char,
nargs:
u32,
argnames:
*const *const ::libc::c_char,
chars:
*const u16,
length:
size_t,
fun:
MutableHandleFunction)
-> bool;
fn _ZN2JS15CompileFunctionEP9JSContextRNS_16AutoVectorRooterIP8JSObjectEERKNS_22ReadOnlyCompileOptionsEPKcjPKSB_RNS_18SourceBufferHolderENS_13MutableHandleIP10JSFunctionEE(cx:
*mut JSContext,
scopeChain:
&mut AutoObjectVector,
options:
&ReadOnlyCompileOptions,
name:
*const ::libc::c_char,
nargs:
u32,
argnames:
*const *const ::libc::c_char,
srcBuf:
&mut SourceBufferHolder,
fun:
MutableHandleFunction)
-> bool;
fn _ZN2JS15CompileFunctionEP9JSContextRNS_16AutoVectorRooterIP8JSObjectEERKNS_22ReadOnlyCompileOptionsEPKcjPKSB_SB_jNS_13MutableHandleIP10JSFunctionEE(cx:
*mut JSContext,
scopeChain:
&mut AutoObjectVector,
options:
&ReadOnlyCompileOptions,
name:
*const ::libc::c_char,
nargs:
u32,
argnames:
*const *const ::libc::c_char,
bytes:
*const ::libc::c_char,
length:
size_t,
fun:
MutableHandleFunction)
-> bool;
fn _Z18JS_DecompileScriptP9JSContextN2JS6HandleIP8JSScriptEEPKcj(cx:
*mut JSContext,
script:
Handle<*mut JSScript>,
name:
*const ::libc::c_char,
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)
-> bool;
fn _Z16JS_ExecuteScriptP9JSContextN2JS6HandleIP8JSScriptEE(cx:
*mut JSContext,
script:
HandleScript)
-> bool;
fn _Z16JS_ExecuteScriptP9JSContextRN2JS16AutoVectorRooterIP8JSObjectEENS1_6HandleIP8JSScriptEENS1_13MutableHandleINS1_5ValueEEE(cx:
*mut JSContext,
scopeChain:
&mut AutoObjectVector,
script:
HandleScript,
rval:
MutableHandleValue)
-> bool;
fn _Z16JS_ExecuteScriptP9JSContextRN2JS16AutoVectorRooterIP8JSObjectEENS1_6HandleIP8JSScriptEE(cx:
*mut JSContext,
scopeChain:
&mut AutoObjectVector,
script:
HandleScript)
-> bool;
fn _ZN2JS21CloneAndExecuteScriptEP9JSContextNS_6HandleIP8JSScriptEE(cx:
*mut JSContext,
script:
Handle<*mut JSScript>)
-> bool;
fn _ZN2JS8EvaluateEP9JSContextRKNS_22ReadOnlyCompileOptionsERNS_18SourceBufferHolderENS_13MutableHandleINS_5ValueEEE(cx:
*mut JSContext,
options:
&ReadOnlyCompileOptions,
srcBuf:
&mut SourceBufferHolder,
rval:
MutableHandleValue)
-> bool;
fn _ZN2JS8EvaluateEP9JSContextRNS_16AutoVectorRooterIP8JSObjectEERKNS_22ReadOnlyCompileOptionsERNS_18SourceBufferHolderENS_13MutableHandleINS_5ValueEEE(cx:
*mut JSContext,
scopeChain:
&mut AutoObjectVector,
options:
&ReadOnlyCompileOptions,
srcBuf:
&mut SourceBufferHolder,
rval:
MutableHandleValue)
-> bool;
fn _ZN2JS8EvaluateEP9JSContextRKNS_22ReadOnlyCompileOptionsEPKDsjNS_13MutableHandleINS_5ValueEEE(cx:
*mut JSContext,
options:
&ReadOnlyCompileOptions,
chars:
*const u16,
length:
size_t,
rval:
MutableHandleValue)
-> bool;
fn _ZN2JS8EvaluateEP9JSContextRNS_16AutoVectorRooterIP8JSObjectEERKNS_22ReadOnlyCompileOptionsEPKDsjNS_13MutableHandleINS_5ValueEEE(cx:
*mut JSContext,
scopeChain:
&mut AutoObjectVector,
options:
&ReadOnlyCompileOptions,
chars:
*const u16,
length:
size_t,
rval:
MutableHandleValue)
-> bool;
fn _ZN2JS8EvaluateEP9JSContextRKNS_22ReadOnlyCompileOptionsEPKcjNS_13MutableHandleINS_5ValueEEE(cx:
*mut JSContext,
options:
&ReadOnlyCompileOptions,
bytes:
*const ::libc::c_char,
length:
size_t,
rval:
MutableHandleValue)
-> bool;
fn _ZN2JS8EvaluateEP9JSContextRKNS_22ReadOnlyCompileOptionsEPKcNS_13MutableHandleINS_5ValueEEE(cx:
*mut JSContext,
options:
&ReadOnlyCompileOptions,
filename:
*const ::libc::c_char,
rval:
MutableHandleValue)
-> bool;
fn _Z15JS_CallFunctionP9JSContextN2JS6HandleIP8JSObjectEENS2_IP10JSFunctionEERKNS1_16HandleValueArrayENS1_13MutableHandleINS1_5ValueEEE(cx:
*mut JSContext,
obj:
HandleObject,
fun:
HandleFunction,
args:
&HandleValueArray,
rval:
MutableHandleValue)
-> bool;
fn _Z19JS_CallFunctionNameP9JSContextN2JS6HandleIP8JSObjectEEPKcRKNS1_16HandleValueArrayENS1_13MutableHandleINS1_5ValueEEE(cx:
*mut JSContext,
obj:
HandleObject,
name:
*const ::libc::c_char,
args:
&HandleValueArray,
rval:
MutableHandleValue)
-> bool;
fn _Z20JS_CallFunctionValueP9JSContextN2JS6HandleIP8JSObjectEENS2_INS1_5ValueEEERKNS1_16HandleValueArrayENS1_13MutableHandleIS6_EE(cx:
*mut JSContext,
obj:
HandleObject,
fval:
HandleValue,
args:
&HandleValueArray,
rval:
MutableHandleValue)
-> bool;
fn _ZN2JS4CallEP9JSContextNS_6HandleINS_5ValueEEES4_RKNS_16HandleValueArrayENS_13MutableHandleIS3_EE(cx:
*mut JSContext,
thisv:
HandleValue,
fun:
HandleValue,
args:
&HandleValueArray,
rval:
MutableHandleValue)
-> bool;
fn _ZN2JS9ConstructEP9JSContextNS_6HandleINS_5ValueEEERKNS_16HandleValueArrayENS_13MutableHandleIS3_EE(cx:
*mut JSContext,
fun:
HandleValue,
args:
&HandleValueArray,
rval:
MutableHandleValue)
-> bool;
fn _ZN2JS9ConstructEP9JSContextNS_6HandleINS_5ValueEEENS2_IP8JSObjectEERKNS_16HandleValueArrayENS_13MutableHandleIS3_EE(cx:
*mut JSContext,
fun:
HandleValue,
newTarget:
HandleObject,
args:
&HandleValueArray,
rval:
MutableHandleValue)
-> bool;
fn _Z20JS_CheckForInterruptP9JSContext(cx: *mut JSContext) -> bool;
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) -> bool;
fn _Z17JS_SaveFrameChainP9JSContext(cx: *mut JSContext) -> bool;
fn _Z20JS_RestoreFrameChainP9JSContext(cx: *mut JSContext);
fn _Z17JS_NewStringCopyNP9JSContextPKcj(cx: *mut JSContext,
s: *const ::libc::c_char,
n: size_t) -> *mut JSString;
fn _Z17JS_NewStringCopyZP9JSContextPKc(cx: *mut JSContext,
s: *const ::libc::c_char)
-> *mut JSString;
fn _Z24JS_AtomizeAndPinJSStringP9JSContextN2JS6HandleIP8JSStringEE(cx:
*mut JSContext,
str:
HandleString)
-> *mut JSString;
fn _Z23JS_AtomizeAndPinStringNP9JSContextPKcj(cx: *mut JSContext,
s: *const ::libc::c_char,
length: size_t)
-> *mut JSString;
fn _Z22JS_AtomizeAndPinStringP9JSContextPKc(cx: *mut JSContext,
s: *const ::libc::c_char)
-> *mut JSString;
fn _Z14JS_NewUCStringP9JSContextPDsj(cx: *mut JSContext, chars: *mut u16,
length: size_t) -> *mut JSString;
fn _Z19JS_NewUCStringCopyNP9JSContextPKDsj(cx: *mut JSContext,
s: *const u16, n: size_t)
-> *mut JSString;
fn _Z19JS_NewUCStringCopyZP9JSContextPKDs(cx: *mut JSContext,
s: *const u16) -> *mut JSString;
fn _Z25JS_AtomizeAndPinUCStringNP9JSContextPKDsj(cx: *mut JSContext,
s: *const u16,
length: size_t)
-> *mut JSString;
fn _Z24JS_AtomizeAndPinUCStringP9JSContextPKDs(cx: *mut JSContext,
s: *const u16)
-> *mut JSString;
fn _Z17JS_CompareStringsP9JSContextP8JSStringS2_Pi(cx: *mut JSContext,
str1: *mut JSString,
str2: *mut JSString,
result: *mut i32)
-> bool;
fn _Z20JS_StringEqualsAsciiP9JSContextP8JSStringPKcPb(cx: *mut JSContext,
str: *mut JSString,
asciiBytes:
*const ::libc::c_char,
_match: *mut bool)
-> bool;
fn _Z19JS_PutEscapedStringP9JSContextPcjP8JSStringc(cx: *mut JSContext,
buffer:
*mut ::libc::c_char,
size: size_t,
str: *mut JSString,
quote: ::libc::c_char)
-> size_t;
fn _Z20JS_FileEscapedStringP8_IO_FILEP8JSStringc(fp: *mut FILE,
str: *mut JSString,
quote: ::libc::c_char)
-> bool;
fn _Z18JS_GetStringLengthP8JSString(str: *mut JSString) -> size_t;
fn _Z15JS_StringIsFlatP8JSString(str: *mut JSString) -> bool;
fn _Z23JS_StringHasLatin1CharsP8JSString(str: *mut JSString) -> bool;
fn _Z32JS_GetLatin1StringCharsAndLengthP9JSContextRKN2JS17AutoCheckCannotGCEP8JSStringPj(cx:
*mut JSContext,
nogc:
&AutoCheckCannotGC,
str:
*mut JSString,
length:
*mut size_t)
-> *const Latin1Char;
fn _Z33JS_GetTwoByteStringCharsAndLengthP9JSContextRKN2JS17AutoCheckCannotGCEP8JSStringPj(cx:
*mut JSContext,
nogc:
&AutoCheckCannotGC,
str:
*mut JSString,
length:
*mut size_t)
-> *const u16;
fn _Z18JS_GetStringCharAtP9JSContextP8JSStringjPDs(cx: *mut JSContext,
str: *mut JSString,
index: size_t,
res: *mut u16) -> bool;
fn _Z22JS_GetFlatStringCharAtP12JSFlatStringj(str: *mut JSFlatString,
index: size_t) -> u16;
fn _Z32JS_GetTwoByteExternalStringCharsP8JSString(str: *mut JSString)
-> *const u16;
fn _Z18JS_CopyStringCharsP9JSContextN7mozilla5RangeIDsEEP8JSString(cx:
*mut JSContext,
dest:
Range<u16>,
str:
*mut JSString)
-> bool;
fn _Z16JS_FlattenStringP9JSContextP8JSString(cx: *mut JSContext,
str: *mut JSString)
-> *mut JSFlatString;
fn _Z27JS_GetLatin1FlatStringCharsRKN2JS17AutoCheckCannotGCEP12JSFlatString(nogc:
&AutoCheckCannotGC,
str:
*mut JSFlatString)
-> *const Latin1Char;
fn _Z28JS_GetTwoByteFlatStringCharsRKN2JS17AutoCheckCannotGCEP12JSFlatString(nogc:
&AutoCheckCannotGC,
str:
*mut JSFlatString)
-> *const u16;
fn _Z24JS_FlatStringEqualsAsciiP12JSFlatStringPKc(str: *mut JSFlatString,
asciiBytes:
*const ::libc::c_char)
-> bool;
fn _Z23JS_PutEscapedFlatStringPcjP12JSFlatStringc(buffer:
*mut ::libc::c_char,
size: size_t,
str: *mut JSFlatString,
quote: ::libc::c_char)
-> size_t;
fn _Z21JS_NewDependentStringP9JSContextN2JS6HandleIP8JSStringEEjj(cx:
*mut JSContext,
str:
HandleString,
start:
size_t,
length:
size_t)
-> *mut JSString;
fn _Z16JS_ConcatStringsP9JSContextN2JS6HandleIP8JSStringEES5_(cx:
*mut JSContext,
left:
HandleString,
right:
HandleString)
-> *mut JSString;
fn _Z14JS_DecodeBytesP9JSContextPKcjPDsPj(cx: *mut JSContext,
src: *const ::libc::c_char,
srclen: size_t, dst: *mut u16,
dstlenp: *mut size_t) -> bool;
fn _Z15JS_EncodeStringP9JSContextP8JSString(cx: *mut JSContext,
str: *mut JSString)
-> *mut ::libc::c_char;
fn _Z21JS_EncodeStringToUTF8P9JSContextN2JS6HandleIP8JSStringEE(cx:
*mut JSContext,
str:
HandleString)
-> *mut ::libc::c_char;
fn _Z26JS_GetStringEncodingLengthP9JSContextP8JSString(cx: *mut JSContext,
str: *mut JSString)
-> size_t;
fn _Z23JS_EncodeStringToBufferP9JSContextP8JSStringPcj(cx: *mut JSContext,
str: *mut JSString,
buffer:
*mut ::libc::c_char,
length: size_t)
-> size_t;
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 ::libc::c_char)
-> bool;
fn _ZN2JS24PropertySpecNameEqualsIdEPKcNS_6HandleI4jsidEE(name:
*const ::libc::c_char,
id: HandleId)
-> bool;
fn _ZN2JS29PropertySpecNameToPermanentIdEP9JSContextPKcP4jsid(cx:
*mut JSContext,
name:
*const ::libc::c_char,
idp:
*mut jsid)
-> bool;
fn _Z12JS_StringifyP9JSContextN2JS13MutableHandleINS1_5ValueEEENS1_6HandleIP8JSObjectEENS5_IS3_EEPFbPKDsjPvESC_(cx:
*mut JSContext,
value:
MutableHandleValue,
replacer:
HandleObject,
space:
HandleValue,
callback:
JSONWriteCallback,
data:
*mut ::libc::c_void)
-> bool;
fn _Z12JS_ParseJSONP9JSContextPKDsjN2JS13MutableHandleINS3_5ValueEEE(cx:
*mut JSContext,
chars:
*const u16,
len:
u32,
vp:
MutableHandleValue)
-> bool;
fn _Z12JS_ParseJSONP9JSContextN2JS6HandleIP8JSStringEENS1_13MutableHandleINS1_5ValueEEE(cx:
*mut JSContext,
str:
HandleString,
vp:
MutableHandleValue)
-> bool;
fn _Z23JS_ParseJSONWithReviverP9JSContextPKDsjN2JS6HandleINS3_5ValueEEENS3_13MutableHandleIS5_EE(cx:
*mut JSContext,
chars:
*const u16,
len:
u32,
reviver:
HandleValue,
vp:
MutableHandleValue)
-> bool;
fn _Z23JS_ParseJSONWithReviverP9JSContextN2JS6HandleIP8JSStringEENS2_INS1_5ValueEEENS1_13MutableHandleIS6_EE(cx:
*mut JSContext,
str:
HandleString,
reviver:
HandleValue,
vp:
MutableHandleValue)
-> bool;
fn _Z19JS_SetDefaultLocaleP9JSRuntimePKc(rt: *mut JSRuntime,
locale: *const ::libc::c_char)
-> bool;
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 ::libc::c_char, ...);
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 u16);
fn _Z16JS_ReportWarningP9JSContextPKcz(cx: *mut JSContext,
format: *const ::libc::c_char, ...)
-> bool;
fn _Z28JS_ReportErrorFlagsAndNumberP9JSContextjPFPK19JSErrorFormatStringPvjES4_jz(cx:
*mut JSContext,
flags:
u32,
errorCallback:
JSErrorCallback,
userRef:
*mut ::libc::c_void,
errorNumber:
u32, ...)
-> bool;
fn _Z30JS_ReportErrorFlagsAndNumberUCP9JSContextjPFPK19JSErrorFormatStringPvjES4_jz(cx:
*mut JSContext,
flags:
u32,
errorCallback:
JSErrorCallback,
userRef:
*mut ::libc::c_void,
errorNumber:
u32, ...)
-> bool;
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_6HandleIP8JSObjectEENS3_IP8JSStringEEjjP13JSErrorReportS9_NS_13MutableHandleINS_5ValueEEE(cx:
*mut JSContext,
_type:
JSExnType,
stack:
HandleObject,
fileName:
HandleString,
lineNumber:
u32,
columnNumber:
u32,
report:
*mut JSErrorReport,
message:
HandleString,
rval:
MutableHandleValue)
-> bool;
fn _ZN2JS16NewWeakMapObjectEP9JSContext(cx: *mut JSContext)
-> *mut JSObject;
fn _ZN2JS15IsWeakMapObjectEP8JSObject(obj: *mut JSObject) -> bool;
fn _ZN2JS15GetWeakMapEntryEP9JSContextNS_6HandleIP8JSObjectEES5_NS_13MutableHandleINS_5ValueEEE(cx:
*mut JSContext,
mapObj:
HandleObject,
key:
HandleObject,
val:
MutableHandleValue)
-> bool;
fn _ZN2JS15SetWeakMapEntryEP9JSContextNS_6HandleIP8JSObjectEES5_NS2_INS_5ValueEEE(cx:
*mut JSContext,
mapObj:
HandleObject,
key:
HandleObject,
val:
HandleValue)
-> bool;
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)
-> bool;
fn _ZN2JS6MapHasEP9JSContextNS_6HandleIP8JSObjectEENS2_INS_5ValueEEEPb(cx:
*mut JSContext,
obj:
HandleObject,
key:
HandleValue,
rval:
*mut bool)
-> bool;
fn _ZN2JS6MapSetEP9JSContextNS_6HandleIP8JSObjectEENS2_INS_5ValueEEES7_(cx:
*mut JSContext,
obj:
HandleObject,
key:
HandleValue,
val:
HandleValue)
-> bool;
fn _ZN2JS9MapDeleteEP9JSContextNS_6HandleIP8JSObjectEENS2_INS_5ValueEEEPb(cx:
*mut JSContext,
obj:
HandleObject,
key:
HandleValue,
rval:
*mut bool)
-> bool;
fn _ZN2JS8MapClearEP9JSContextNS_6HandleIP8JSObjectEE(cx: *mut JSContext,
obj: HandleObject)
-> bool;
fn _ZN2JS7MapKeysEP9JSContextNS_6HandleIP8JSObjectEENS_13MutableHandleINS_5ValueEEE(cx:
*mut JSContext,
obj:
HandleObject,
rval:
MutableHandleValue)
-> bool;
fn _ZN2JS9MapValuesEP9JSContextNS_6HandleIP8JSObjectEENS_13MutableHandleINS_5ValueEEE(cx:
*mut JSContext,
obj:
HandleObject,
rval:
MutableHandleValue)
-> bool;
fn _ZN2JS10MapEntriesEP9JSContextNS_6HandleIP8JSObjectEENS_13MutableHandleINS_5ValueEEE(cx:
*mut JSContext,
obj:
HandleObject,
rval:
MutableHandleValue)
-> bool;
fn _ZN2JS10MapForEachEP9JSContextNS_6HandleIP8JSObjectEENS2_INS_5ValueEEES7_(cx:
*mut JSContext,
obj:
HandleObject,
callbackFn:
HandleValue,
thisVal:
HandleValue)
-> bool;
fn _ZN2JS12NewSetObjectEP9JSContext(cx: *mut JSContext) -> *mut JSObject;
fn _ZN2JS7SetSizeEP9JSContextNS_6HandleIP8JSObjectEE(cx: *mut JSContext,
obj: HandleObject)
-> u32;
fn _ZN2JS6SetHasEP9JSContextNS_6HandleIP8JSObjectEENS2_INS_5ValueEEEPb(cx:
*mut JSContext,
obj:
HandleObject,
key:
HandleValue,
rval:
*mut bool)
-> bool;
fn _ZN2JS9SetDeleteEP9JSContextNS_6HandleIP8JSObjectEENS2_INS_5ValueEEEPb(cx:
*mut JSContext,
obj:
HandleObject,
key:
HandleValue,
rval:
*mut bool)
-> bool;
fn _ZN2JS6SetAddEP9JSContextNS_6HandleIP8JSObjectEENS2_INS_5ValueEEE(cx:
*mut JSContext,
obj:
HandleObject,
key:
HandleValue)
-> bool;
fn _ZN2JS8SetClearEP9JSContextNS_6HandleIP8JSObjectEE(cx: *mut JSContext,
obj: HandleObject)
-> bool;
fn _ZN2JS7SetKeysEP9JSContextNS_6HandleIP8JSObjectEENS_13MutableHandleINS_5ValueEEE(cx:
*mut JSContext,
obj:
HandleObject,
rval:
MutableHandleValue)
-> bool;
fn _ZN2JS9SetValuesEP9JSContextNS_6HandleIP8JSObjectEENS_13MutableHandleINS_5ValueEEE(cx:
*mut JSContext,
obj:
HandleObject,
rval:
MutableHandleValue)
-> bool;
fn _ZN2JS10SetEntriesEP9JSContextNS_6HandleIP8JSObjectEENS_13MutableHandleINS_5ValueEEE(cx:
*mut JSContext,
obj:
HandleObject,
rval:
MutableHandleValue)
-> bool;
fn _ZN2JS10SetForEachEP9JSContextNS_6HandleIP8JSObjectEENS2_INS_5ValueEEES7_(cx:
*mut JSContext,
obj:
HandleObject,
callbackFn:
HandleValue,
thisVal:
HandleValue)
-> bool;
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)
-> bool;
fn _Z18JS_ClearDateCachesP9JSContext(cx: *mut JSContext);
fn _Z18JS_NewRegExpObjectP9JSContextN2JS6HandleIP8JSObjectEEPKcjj(cx:
*mut JSContext,
obj:
HandleObject,
bytes:
*const ::libc::c_char,
length:
size_t,
flags:
u32)
-> *mut JSObject;
fn _Z20JS_NewUCRegExpObjectP9JSContextN2JS6HandleIP8JSObjectEEPKDsjj(cx:
*mut JSContext,
obj:
HandleObject,
chars:
*const u16,
length:
size_t,
flags:
u32)
-> *mut JSObject;
fn _Z17JS_SetRegExpInputP9JSContextN2JS6HandleIP8JSObjectEENS2_IP8JSStringEEb(cx:
*mut JSContext,
obj:
HandleObject,
input:
HandleString,
multiline:
bool)
-> bool;
fn _Z21JS_ClearRegExpStaticsP9JSContextN2JS6HandleIP8JSObjectEE(cx:
*mut JSContext,
obj:
HandleObject)
-> bool;
fn _Z16JS_ExecuteRegExpP9JSContextN2JS6HandleIP8JSObjectEES5_PDsjPjbNS1_13MutableHandleINS1_5ValueEEE(cx:
*mut JSContext,
obj:
HandleObject,
reobj:
HandleObject,
chars:
*mut u16,
length:
size_t,
indexp:
*mut size_t,
test:
bool,
rval:
MutableHandleValue)
-> bool;
fn _Z27JS_NewRegExpObjectNoStaticsP9JSContextPcjj(cx: *mut JSContext,
bytes:
*mut ::libc::c_char,
length: size_t,
flags: u32)
-> *mut JSObject;
fn _Z29JS_NewUCRegExpObjectNoStaticsP9JSContextPDsjj(cx: *mut JSContext,
chars: *mut u16,
length: size_t,
flags: u32)
-> *mut JSObject;
fn _Z25JS_ExecuteRegExpNoStaticsP9JSContextN2JS6HandleIP8JSObjectEEPDsjPjbNS1_13MutableHandleINS1_5ValueEEE(cx:
*mut JSContext,
reobj:
HandleObject,
chars:
*mut u16,
length:
size_t,
indexp:
*mut size_t,
test:
bool,
rval:
MutableHandleValue)
-> bool;
fn _Z17JS_ObjectIsRegExpP9JSContextN2JS6HandleIP8JSObjectEE(cx:
*mut JSContext,
obj:
HandleObject)
-> bool;
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) -> bool;
fn _Z22JS_GetPendingExceptionP9JSContextN2JS13MutableHandleINS1_5ValueEEE(cx:
*mut JSContext,
vp:
MutableHandleValue)
-> bool;
fn _Z22JS_SetPendingExceptionP9JSContextN2JS6HandleINS1_5ValueEEE(cx:
*mut JSContext,
v:
HandleValue);
fn _Z24JS_ClearPendingExceptionP9JSContext(cx: *mut JSContext);
fn _Z25JS_ReportPendingExceptionP9JSContext(cx: *mut JSContext) -> bool;
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 _Z20ExceptionStackOrNullP9JSContextN2JS6HandleIP8JSObjectEE(cx:
*mut JSContext,
obj:
HandleObject)
-> *mut JSObject;
fn _Z21JS_ThrowStopIterationP9JSContext(cx: *mut JSContext) -> bool;
fn _Z18JS_IsStopIterationN2JS5ValueE(v: Value) -> bool;
fn _Z19JS_GetCurrentThreadv() -> intptr_t;
fn _Z21JS_AbortIfWrongThreadP9JSRuntime(rt: *mut JSRuntime);
fn _Z26JS_NewObjectForConstructorP9JSContextPK7JSClassRKN2JS8CallArgsE(cx:
*mut JSContext,
clasp:
*const JSClass,
args:
&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: bool);
fn _Z36JS_SetOffthreadIonCompilationEnabledP9JSRuntimeb(rt:
*mut JSRuntime,
enabled: bool);
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)
-> bool;
fn _Z12JS_CharsToIdP9JSContextN2JS12TwoByteCharsENS1_13MutableHandleI4jsidEE(cx:
*mut JSContext,
chars:
TwoByteChars,
arg1:
MutableHandleId)
-> bool;
fn _Z15JS_IsIdentifierP9JSContextN2JS6HandleIP8JSStringEEPb(cx:
*mut JSContext,
str:
HandleString,
isIdentifier:
*mut bool)
-> bool;
fn _Z15JS_IsIdentifierPKDsj(chars: *const u16, length: size_t) -> bool;
fn _ZN2JS22DescribeScriptedCallerEP9JSContextPNS_12AutoFilenameEPj(cx:
*mut JSContext,
filename:
*mut AutoFilename,
lineno:
*mut u32)
-> bool;
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)
-> bool;
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 _ZN2JS16BuildStackStringEP9JSContextNS_6HandleIP8JSObjectEENS_13MutableHandleIP8JSStringEE(cx:
*mut JSContext,
stack:
HandleObject,
stringp:
MutableHandleString)
-> bool;
fn _ZN2js16ResetStopwatchesEP9JSRuntime(arg1: *mut JSRuntime);
fn _ZN2js28SetStopwatchIsMonitoringCPOWEP9JSRuntimeb(arg1: *mut JSRuntime,
arg2: bool) -> bool;
fn _ZN2js28GetStopwatchIsMonitoringCPOWEP9JSRuntime(arg1: *mut JSRuntime)
-> bool;
fn _ZN2js28SetStopwatchIsMonitoringJankEP9JSRuntimeb(arg1: *mut JSRuntime,
arg2: bool) -> bool;
fn _ZN2js28GetStopwatchIsMonitoringJankEP9JSRuntime(arg1: *mut JSRuntime)
-> bool;
fn _ZN2js17IsStopwatchActiveEP9JSRuntime(arg1: *mut JSRuntime) -> bool;
fn _ZN2js18GetPerformanceDataEP9JSRuntime(arg1: *mut JSRuntime)
-> *mut PerformanceData;
fn _ZN2js20IterPerformanceStatsEP9JSContextPFbS1_RKNS_15PerformanceDataEyPvEPS2_S5_(cx:
*mut JSContext,
walker:
*mut PerformanceStatsWalker,
process:
*mut PerformanceData,
closure:
*mut ::libc::c_void)
-> bool;
fn _Z30JS_SetCurrentPerfGroupCallbackP9JSRuntimePFPvP9JSContextE(rt:
*mut JSRuntime,
cb:
JSCurrentPerfGroupCallback);
fn _ZN2JS6detail19CallMethodIfWrappedEP9JSContextPFbNS_6HandleINS_5ValueEEEEPFbS2_NS_8CallArgsEES8_(cx:
*mut JSContext,
test:
IsAcceptableThis,
_impl:
NativeImpl,
args:
CallArgs)
-> bool;
fn _ZN2JS20CallNonGenericMethodEP9JSContextPFbNS_6HandleINS_5ValueEEEEPFbS1_NS_8CallArgsEES7_(cx:
*mut JSContext,
Test:
IsAcceptableThis,
Impl:
NativeImpl,
args:
CallArgs)
-> bool;
fn _Z23JS_SetGrayGCRootsTracerP9JSRuntimePFvP8JSTracerPvES3_(rt:
*mut JSRuntime,
traceOp:
JSTraceDataOp,
data:
*mut ::libc::c_void);
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)
-> bool;
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) -> size_t;
fn _Z25JS_GetCustomIteratorCountP9JSContext(cx: *mut JSContext) -> size_t;
fn _Z33JS_NondeterministicGetWeakMapKeysP9JSContextN2JS6HandleIP8JSObjectEENS1_13MutableHandleIS4_EE(cx:
*mut JSContext,
obj:
HandleObject,
ret:
MutableHandleObject)
-> bool;
fn _Z17JS_PCToLineNumberP8JSScriptPhPj(script: *mut JSScript,
pc: *mut jsbytecode,
columnp: *mut u32) -> u32;
fn _Z16JS_IsDeadWrapperP8JSObject(obj: *mut JSObject) -> bool;
fn _Z35JS_TraceShapeCycleCollectorChildrenPN2JS14CallbackTracerENS_9GCCellPtrE(trc:
*mut CallbackTracer,
shape:
GCCellPtr);
fn _Z41JS_TraceObjectGroupCycleCollectorChildrenPN2JS14CallbackTracerENS_9GCCellPtrE(trc:
*mut CallbackTracer,
group:
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) -> bool;
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)
-> bool;
fn _Z22JS_BasicObjectToStringP9JSContextN2JS6HandleIP8JSObjectEE(cx:
*mut JSContext,
obj:
HandleObject)
-> *mut JSString;
fn _ZN2js13ObjectClassIsEP9JSContextN2JS6HandleIP8JSObjectEENS_12ESClassValueE(cx:
*mut JSContext,
obj:
HandleObject,
classValue:
ESClassValue)
-> bool;
fn _ZN2js15ObjectClassNameEP9JSContextN2JS6HandleIP8JSObjectEE(cx:
*mut JSContext,
obj:
HandleObject)
-> *const ::libc::c_char;
fn _ZN2js18ReportOverRecursedEP9JSContext(maybecx: *mut JSContext);
fn _ZN2js15AddRawValueRootEP9JSContextPN2JS5ValueEPKc(cx: *mut JSContext,
vp: *mut Value,
name:
*const ::libc::c_char)
-> bool;
fn _ZN2js18RemoveRawValueRootEP9JSContextPN2JS5ValueE(cx: *mut JSContext,
vp: *mut Value);
fn _ZN2js21GetPropertyNameFromPCEP8JSScriptPh(script: *mut JSScript,
pc: *mut jsbytecode)
-> *mut JSAtom;
fn _ZN2js13DumpBacktraceEP9JSContext(cx: *mut JSContext);
fn _ZN2JS15FormatStackDumpEP9JSContextPcbbb(cx: *mut JSContext,
buf: *mut ::libc::c_char,
showArgs: bool,
showLocals: bool,
showThisProps: bool)
-> *mut ::libc::c_char;
fn _Z21JS_CopyPropertiesFromP9JSContextN2JS6HandleIP8JSObjectEES5_(cx:
*mut JSContext,
target:
HandleObject,
obj:
HandleObject)
-> bool;
fn _Z19JS_CopyPropertyFromP9JSContextN2JS6HandleI4jsidEENS2_IP8JSObjectEES7_20PropertyCopyBehavior(cx:
*mut JSContext,
id:
HandleId,
target:
HandleObject,
obj:
HandleObject,
copyBehavior:
PropertyCopyBehavior)
-> bool;
fn _Z25JS_WrapPropertyDescriptorP9JSContextN2JS13MutableHandleI20JSPropertyDescriptorEE(cx:
*mut JSContext,
desc:
MutableHandle<JSPropertyDescriptor>)
-> bool;
fn _Z26JS_DefineFunctionsWithHelpP9JSContextN2JS6HandleIP8JSObjectEEPK22JSFunctionSpecWithHelp(cx:
*mut JSContext,
obj:
HandleObject,
fs:
*const JSFunctionSpecWithHelp)
-> bool;
fn _ZN2js20proxy_LookupPropertyEP9JSContextN2JS6HandleIP8JSObjectEENS3_I4jsidEENS2_13MutableHandleIS5_EENS9_IPNS_5ShapeEEE(cx:
*mut JSContext,
obj:
HandleObject,
id:
HandleId,
objp:
MutableHandleObject,
propp:
MutableHandle<*mut Shape>)
-> bool;
fn _ZN2js20proxy_DefinePropertyEP9JSContextN2JS6HandleIP8JSObjectEENS3_I4jsidEENS3_I20JSPropertyDescriptorEERNS2_14ObjectOpResultE(cx:
*mut JSContext,
obj:
HandleObject,
id:
HandleId,
desc:
Handle<JSPropertyDescriptor>,
result:
&mut ObjectOpResult)
-> bool;
fn _ZN2js17proxy_HasPropertyEP9JSContextN2JS6HandleIP8JSObjectEENS3_I4jsidEEPb(cx:
*mut JSContext,
obj:
HandleObject,
id:
HandleId,
foundp:
*mut bool)
-> bool;
fn _ZN2js17proxy_GetPropertyEP9JSContextN2JS6HandleIP8JSObjectEES6_NS3_I4jsidEENS2_13MutableHandleINS2_5ValueEEE(cx:
*mut JSContext,
obj:
HandleObject,
receiver:
HandleObject,
id:
HandleId,
vp:
MutableHandleValue)
-> bool;
fn _ZN2js17proxy_SetPropertyEP9JSContextN2JS6HandleIP8JSObjectEENS3_I4jsidEENS3_INS2_5ValueEEESA_RNS2_14ObjectOpResultE(cx:
*mut JSContext,
obj:
HandleObject,
id:
HandleId,
bp:
HandleValue,
receiver:
HandleValue,
result:
&mut ObjectOpResult)
-> bool;
fn _ZN2js30proxy_GetOwnPropertyDescriptorEP9JSContextN2JS6HandleIP8JSObjectEENS3_I4jsidEENS2_13MutableHandleI20JSPropertyDescriptorEE(cx:
*mut JSContext,
obj:
HandleObject,
id:
HandleId,
desc:
MutableHandle<JSPropertyDescriptor>)
-> bool;
fn _ZN2js20proxy_DeletePropertyEP9JSContextN2JS6HandleIP8JSObjectEENS3_I4jsidEERNS2_14ObjectOpResultE(cx:
*mut JSContext,
obj:
HandleObject,
id:
HandleId,
result:
&mut ObjectOpResult)
-> bool;
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)
-> bool;
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 bool)
-> bool;
fn _ZN2js10proxy_CallEP9JSContextjPN2JS5ValueE(cx: *mut JSContext,
argc: u32, vp: *mut Value)
-> bool;
fn _ZN2js15proxy_ConstructEP9JSContextjPN2JS5ValueE(cx: *mut JSContext,
argc: u32,
vp: *mut Value)
-> bool;
fn _ZN2js17proxy_innerObjectEP8JSObject(obj: *mut JSObject)
-> *mut JSObject;
fn _ZN2js11proxy_WatchEP9JSContextN2JS6HandleIP8JSObjectEENS3_I4jsidEES6_(cx:
*mut JSContext,
obj:
HandleObject,
id:
HandleId,
callable:
HandleObject)
-> bool;
fn _ZN2js13proxy_UnwatchEP9JSContextN2JS6HandleIP8JSObjectEENS3_I4jsidEE(cx:
*mut JSContext,
obj:
HandleObject,
id:
HandleId)
-> bool;
fn _ZN2js17proxy_GetElementsEP9JSContextN2JS6HandleIP8JSObjectEEjjPNS_12ElementAdderE(cx:
*mut JSContext,
proxy:
HandleObject,
begin:
u32,
end:
u32,
adder:
*mut ElementAdder)
-> bool;
fn _ZN2js13SetSourceHookEP9JSRuntimeN7mozilla9UniquePtrINS_10SourceHookENS2_13DefaultDeleteIS4_EEEE(rt:
*mut JSRuntime,
hook:
UniquePtr<SourceHook,
DefaultDelete<SourceHook>>);
fn _ZN2js16ForgetSourceHookEP9JSRuntime(rt: *mut JSRuntime)
-> UniquePtr<SourceHook, DefaultDelete<SourceHook>>;
fn _ZN2js18GetCompartmentZoneEP13JSCompartment(comp: *mut JSCompartment)
-> *mut Zone;
fn _ZN2js8DumpHeapEP9JSRuntimeP8_IO_FILENS_24DumpHeapNurseryBehaviourE(rt:
*mut JSRuntime,
fp:
*mut FILE,
nurseryBehaviour:
DumpHeapNurseryBehaviour);
fn _ZN2js16obj_defineGetterEP9JSContextjPN2JS5ValueE(cx: *mut JSContext,
argc: u32,
vp: *mut Value)
-> bool;
fn _ZN2js16obj_defineSetterEP9JSContextjPN2JS5ValueE(cx: *mut JSContext,
argc: u32,
vp: *mut Value)
-> bool;
fn _ZN2js19IsSystemCompartmentEP13JSCompartment(comp: *mut JSCompartment)
-> bool;
fn _ZN2js12IsSystemZoneEPN2JS4ZoneE(zone: *mut Zone) -> bool;
fn _ZN2js18IsAtomsCompartmentEP13JSCompartment(comp: *mut JSCompartment)
-> bool;
fn _ZN2js11IsAtomsZoneEPN2JS4ZoneE(zone: *mut Zone) -> bool;
fn _ZN2js13TraceWeakMapsEPNS_13WeakMapTracerE(trc: *mut WeakMapTracer);
fn _ZN2js18AreGCGrayBitsValidEP9JSRuntime(rt: *mut JSRuntime) -> bool;
fn _ZN2js21ZoneGlobalsAreAllGrayEPN2JS4ZoneE(zone: *mut Zone) -> bool;
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) -> TraceKind;
fn _ZN2js18IterateGrayObjectsEPN2JS4ZoneEPFvPvNS0_9GCCellPtrEES3_(zone:
*mut Zone,
cellCallback:
GCThingCallback,
data:
*mut ::libc::c_void);
fn _ZN2js23SizeOfDataIfCDataObjectEPFjPKvEP8JSObject(mallocSizeOf:
MallocSizeOf,
obj: *mut JSObject)
-> size_t;
fn _ZN2js23GetAnyCompartmentInZoneEPN2JS4ZoneE(zone: *mut Zone)
-> *mut JSCompartment;
fn _ZN2js14GetObjectClassEPK8JSObject(obj: *const JSObject)
-> *const Class;
fn _ZN2js16GetObjectJSClassEP8JSObject(obj: *mut JSObject)
-> *const JSClass;
fn _ZN2js15ProtoKeyToClassE10JSProtoKey(key: JSProtoKey) -> *const Class;
fn _ZN2js24StandardClassIsDependentE10JSProtoKey(key: JSProtoKey) -> bool;
fn _ZN2js25ParentKeyForStandardClassE10JSProtoKey(key: JSProtoKey)
-> JSProtoKey;
fn _ZN2js13IsInnerObjectEP8JSObject(obj: *mut JSObject) -> bool;
fn _ZN2js13IsOuterObjectEP8JSObject(obj: *mut JSObject) -> bool;
fn _ZN2js16IsFunctionObjectEP8JSObject(obj: *mut JSObject) -> bool;
fn _ZN2js34GetGlobalForObjectCrossCompartmentEP8JSObject(obj:
*mut JSObject)
-> *mut JSObject;
fn _ZN2js19GetPrototypeNoProxyEP8JSObject(obj: *mut JSObject)
-> *mut JSObject;
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 ::libc::c_char,
call:
JSNative,
nargs:
u32,
attrs:
u32)
-> *mut JSFunction;
fn _ZN2js23NewFunctionWithReservedEP9JSContextPFbS1_jPN2JS5ValueEEjjPKc(cx:
*mut JSContext,
call:
JSNative,
nargs:
u32,
flags:
u32,
name:
*const ::libc::c_char)
-> *mut JSFunction;
fn _ZN2js27NewFunctionByIdWithReservedEP9JSContextPFbS1_jPN2JS5ValueEEjj4jsid(cx:
*mut JSContext,
native:
JSNative,
nargs:
u32,
flags:
u32,
id:
jsid)
-> *mut JSFunction;
fn _ZN2js25GetFunctionNativeReservedEP8JSObjectj(fun: *mut JSObject,
which: size_t)
-> *const Value;
fn _ZN2js25SetFunctionNativeReservedEP8JSObjectjRKN2JS5ValueE(fun:
*mut JSObject,
which:
size_t,
val:
&Value);
fn _ZN2js25FunctionHasNativeReservedEP8JSObject(fun: *mut JSObject)
-> bool;
fn _ZN2js14GetObjectProtoEP9JSContextN2JS6HandleIP8JSObjectEENS2_13MutableHandleIS5_EE(cx:
*mut JSContext,
obj:
HandleObject,
proto:
MutableHandleObject)
-> bool;
fn _ZN2js15GetOriginalEvalEP9JSContextN2JS6HandleIP8JSObjectEENS2_13MutableHandleIS5_EE(cx:
*mut JSContext,
scope:
HandleObject,
eval:
MutableHandleObject)
-> bool;
fn _ZN2js16GetObjectPrivateEP8JSObject(obj: *mut JSObject)
-> *mut ::libc::c_void;
fn _ZN2js15GetReservedSlotEP8JSObjectj(obj: *mut JSObject, slot: size_t)
-> *const Value;
fn _ZN2js40SetReservedOrProxyPrivateSlotWithBarrierEP8JSObjectjRKN2JS5ValueE(obj:
*mut JSObject,
slot:
size_t,
value:
&Value);
fn _ZN2js15SetReservedSlotEP8JSObjectjRKN2JS5ValueE(obj: *mut JSObject,
slot: size_t,
value: &Value);
fn _ZN2js17GetObjectSlotSpanEP8JSObject(obj: *mut JSObject) -> u32;
fn _ZN2js13GetObjectSlotEP8JSObjectj(obj: *mut JSObject, slot: size_t)
-> *const Value;
fn _ZN2js13GetAtomLengthEP6JSAtom(atom: *mut JSAtom) -> size_t;
fn _ZN2js15GetStringLengthEP8JSString(s: *mut JSString) -> size_t;
fn _ZN2js19GetFlatStringLengthEP12JSFlatString(s: *mut JSFlatString)
-> size_t;
fn _ZN2js21GetLinearStringLengthEP14JSLinearString(s: *mut JSLinearString)
-> size_t;
fn _ZN2js26LinearStringHasLatin1CharsEP14JSLinearString(s:
*mut JSLinearString)
-> bool;
fn _ZN2js18AtomHasLatin1CharsEP6JSAtom(atom: *mut JSAtom) -> bool;
fn _ZN2js20StringHasLatin1CharsEP8JSString(s: *mut JSString) -> bool;
fn _ZN2js26GetLatin1LinearStringCharsERKN2JS17AutoCheckCannotGCEP14JSLinearString(nogc:
&AutoCheckCannotGC,
linear:
*mut JSLinearString)
-> *const Latin1Char;
fn _ZN2js27GetTwoByteLinearStringCharsERKN2JS17AutoCheckCannotGCEP14JSLinearString(nogc:
&AutoCheckCannotGC,
linear:
*mut JSLinearString)
-> *const u16;
fn _ZN2js18AtomToLinearStringEP6JSAtom(atom: *mut JSAtom)
-> *mut JSLinearString;
fn _ZN2js16AtomToFlatStringEP6JSAtom(atom: *mut JSAtom)
-> *mut JSFlatString;
fn _ZN2js24FlatStringToLinearStringEP12JSFlatString(s: *mut JSFlatString)
-> *mut JSLinearString;
fn _ZN2js18GetLatin1AtomCharsERKN2JS17AutoCheckCannotGCEP6JSAtom(nogc:
&AutoCheckCannotGC,
atom:
*mut JSAtom)
-> *const Latin1Char;
fn _ZN2js19GetTwoByteAtomCharsERKN2JS17AutoCheckCannotGCEP6JSAtom(nogc:
&AutoCheckCannotGC,
atom:
*mut JSAtom)
-> *const u16;
fn _ZN2js24StringToLinearStringSlowEP9JSContextP8JSString(cx:
*mut JSContext,
str:
*mut JSString)
-> *mut JSLinearString;
fn _ZN2js20StringToLinearStringEP9JSContextP8JSString(cx: *mut JSContext,
str: *mut JSString)
-> *mut JSLinearString;
fn _ZN2js21CopyLinearStringCharsEPDsP14JSLinearStringj(dest: *mut u16,
s:
*mut JSLinearString,
len: size_t);
fn _ZN2js15CopyStringCharsEP9JSContextPDsP8JSStringj(cx: *mut JSContext,
dest: *mut u16,
s: *mut JSString,
len: size_t) -> bool;
fn _ZN2js19CopyFlatStringCharsEPDsP12JSFlatStringj(dest: *mut u16,
s: *mut JSFlatString,
len: size_t);
fn _ZN2js15GetPropertyKeysEP9JSContextN2JS6HandleIP8JSObjectEEjPNS2_16AutoVectorRooterI4jsidEE(cx:
*mut JSContext,
obj:
HandleObject,
flags:
u32,
props:
*mut AutoIdVector)
-> bool;
fn _ZN2js12AppendUniqueEP9JSContextRN2JS16AutoVectorRooterI4jsidEES6_(cx:
*mut JSContext,
base:
&mut AutoIdVector,
others:
&mut AutoIdVector)
-> bool;
fn _ZN2js18StringIsArrayIndexEP14JSLinearStringPj(str:
*mut JSLinearString,
indexp: *mut u32)
-> bool;
fn _ZN2js26SetPreserveWrapperCallbackEP9JSRuntimePFbP9JSContextP8JSObjectE(rt:
*mut JSRuntime,
callback:
PreserveWrapperCallback);
fn _ZN2js28IsObjectInContextCompartmentEP8JSObjectPK9JSContext(obj:
*mut JSObject,
cx:
*const JSContext)
-> bool;
fn _ZN2js28RunningWithTrustedPrincipalsEP9JSContext(cx: *mut JSContext)
-> bool;
fn _ZN2js19GetNativeStackLimitEP9JSContextNS_9StackKindEi(cx:
*mut JSContext,
kind: StackKind,
extraAllowance:
i32)
-> uintptr_t;
fn _ZN2js19GetNativeStackLimitEP9JSContexti(cx: *mut JSContext,
extraAllowance: i32)
-> uintptr_t;
fn _ZN2js21StartPCCountProfilingEP9JSContext(cx: *mut JSContext);
fn _ZN2js20StopPCCountProfilingEP9JSContext(cx: *mut JSContext);
fn _ZN2js13PurgePCCountsEP9JSContext(cx: *mut JSContext);
fn _ZN2js21GetPCCountScriptCountEP9JSContext(cx: *mut JSContext)
-> size_t;
fn _ZN2js23GetPCCountScriptSummaryEP9JSContextj(cx: *mut JSContext,
script: size_t)
-> *mut JSString;
fn _ZN2js24GetPCCountScriptContentsEP9JSContextj(cx: *mut JSContext,
script: size_t)
-> *mut JSString;
fn _ZN2js29ContextHasOutstandingRequestsEPK9JSContext(cx:
*const JSContext)
-> bool;
fn _ZN2js19SetActivityCallbackEP9JSRuntimePFvPvbES2_(rt: *mut JSRuntime,
cb: ActivityCallback,
arg:
*mut ::libc::c_void);
fn _ZN2js34GetContextStructuredCloneCallbacksEP9JSContext(cx:
*mut JSContext)
-> *const JSStructuredCloneCallbacks;
fn _ZN2js18IsContextRunningJSEP9JSContext(cx: *mut JSContext) -> bool;
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)
-> bool;
fn _ZN2js28NukeCrossCompartmentWrappersEP9JSContextRKNS_17CompartmentFilterES4_NS_22NukeReferencesToWindowE(cx:
*mut JSContext,
sourceFilter:
&CompartmentFilter,
targetFilter:
&CompartmentFilter,
nukeReferencesToWindow:
NukeReferencesToWindow)
-> bool;
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)
-> bool;
fn _ZN2js11DateIsValidEP9JSContextP8JSObject(cx: *mut JSContext,
obj: *mut JSObject) -> bool;
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 _Z23JS_NewSharedArrayBufferP9JSContextj(cx: *mut JSContext,
nbytes: u32) -> *mut JSObject;
fn _Z17JS_NewArrayBufferP9JSContextj(cx: *mut JSContext, nbytes: u32)
-> *mut JSObject;
fn _Z21JS_IsTypedArrayObjectP8JSObject(obj: *mut JSObject) -> bool;
fn _Z27JS_IsSharedTypedArrayObjectP8JSObject(obj: *mut JSObject) -> bool;
fn _Z26JS_IsArrayBufferViewObjectP8JSObject(obj: *mut JSObject) -> bool;
fn _Z14JS_IsInt8ArrayP8JSObject(obj: *mut JSObject) -> bool;
fn _Z15JS_IsUint8ArrayP8JSObject(obj: *mut JSObject) -> bool;
fn _Z22JS_IsUint8ClampedArrayP8JSObject(obj: *mut JSObject) -> bool;
fn _Z15JS_IsInt16ArrayP8JSObject(obj: *mut JSObject) -> bool;
fn _Z16JS_IsUint16ArrayP8JSObject(obj: *mut JSObject) -> bool;
fn _Z15JS_IsInt32ArrayP8JSObject(obj: *mut JSObject) -> bool;
fn _Z16JS_IsUint32ArrayP8JSObject(obj: *mut JSObject) -> bool;
fn _Z17JS_IsFloat32ArrayP8JSObject(obj: *mut JSObject) -> bool;
fn _Z17JS_IsFloat64ArrayP8JSObject(obj: *mut JSObject) -> bool;
fn _Z20JS_IsSharedInt8ArrayP8JSObject(obj: *mut JSObject) -> bool;
fn _Z21JS_IsSharedUint8ArrayP8JSObject(obj: *mut JSObject) -> bool;
fn _Z28JS_IsSharedUint8ClampedArrayP8JSObject(obj: *mut JSObject) -> bool;
fn _Z21JS_IsSharedInt16ArrayP8JSObject(obj: *mut JSObject) -> bool;
fn _Z22JS_IsSharedUint16ArrayP8JSObject(obj: *mut JSObject) -> bool;
fn _Z21JS_IsSharedInt32ArrayP8JSObject(obj: *mut JSObject) -> bool;
fn _Z22JS_IsSharedUint32ArrayP8JSObject(obj: *mut JSObject) -> bool;
fn _Z23JS_IsSharedFloat32ArrayP8JSObject(obj: *mut JSObject) -> bool;
fn _Z23JS_IsSharedFloat64ArrayP8JSObject(obj: *mut JSObject) -> bool;
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 _ZN2js23UnwrapSharedArrayBufferEP8JSObject(obj: *mut JSObject)
-> *mut JSObject;
fn _ZN2js27UnwrapSharedArrayBufferViewEP8JSObject(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 _ZN2js31GetSharedInt8ArrayLengthAndDataEP8JSObjectPjPPa(obj:
*mut JSObject,
length:
*mut u32,
data:
*mut *mut i8);
fn _ZN2js32GetSharedUint8ArrayLengthAndDataEP8JSObjectPjPPh(obj:
*mut JSObject,
length:
*mut u32,
data:
*mut *mut u8);
fn _ZN2js39GetSharedUint8ClampedArrayLengthAndDataEP8JSObjectPjPPh(obj:
*mut JSObject,
length:
*mut u32,
data:
*mut *mut u8);
fn _ZN2js32GetSharedInt16ArrayLengthAndDataEP8JSObjectPjPPs(obj:
*mut JSObject,
length:
*mut u32,
data:
*mut *mut i16);
fn _ZN2js33GetSharedUint16ArrayLengthAndDataEP8JSObjectPjPPt(obj:
*mut JSObject,
length:
*mut u32,
data:
*mut *mut u16);
fn _ZN2js32GetSharedInt32ArrayLengthAndDataEP8JSObjectPjPPi(obj:
*mut JSObject,
length:
*mut u32,
data:
*mut *mut i32);
fn _ZN2js33GetSharedUint32ArrayLengthAndDataEP8JSObjectPjPS2_(obj:
*mut JSObject,
length:
*mut u32,
data:
*mut *mut u32);
fn _ZN2js34GetSharedFloat32ArrayLengthAndDataEP8JSObjectPjPPf(obj:
*mut JSObject,
length:
*mut u32,
data:
*mut *mut f32);
fn _ZN2js34GetSharedFloat64ArrayLengthAndDataEP8JSObjectPjPPd(obj:
*mut JSObject,
length:
*mut u32,
data:
*mut *mut f64);
fn _ZN2js31GetArrayBufferViewLengthAndDataEP8JSObjectPjPPh(obj:
*mut JSObject,
length:
*mut u32,
data:
*mut *mut u8);
fn _ZN2js37GetSharedArrayBufferViewLengthAndDataEP8JSObjectPjPPh(obj:
*mut JSObject,
length:
*mut u32,
data:
*mut *mut u8);
fn _ZN2js27GetArrayBufferLengthAndDataEP8JSObjectPjPPh(obj: *mut JSObject,
length: *mut u32,
data:
*mut *mut u8);
fn _ZN2js33GetSharedArrayBufferLengthAndDataEP8JSObjectPjPPh(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 _Z31JS_GetSharedArrayBufferViewTypeP8JSObject(obj: *mut JSObject)
-> Type;
fn _Z22JS_IsArrayBufferObjectP8JSObject(obj: *mut JSObject) -> bool;
fn _Z28JS_IsSharedArrayBufferObjectP8JSObject(obj: *mut JSObject) -> bool;
fn _Z27JS_GetArrayBufferByteLengthP8JSObject(obj: *mut JSObject) -> u32;
fn _Z21JS_ArrayBufferHasDataP8JSObject(obj: *mut JSObject) -> bool;
fn _Z28JS_IsMappedArrayBufferObjectP8JSObject(obj: *mut JSObject) -> bool;
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:
&AutoCheckCannotGC)
-> *mut u8;
fn _Z19JS_GetInt8ArrayDataP8JSObjectRKN2JS17AutoCheckCannotGCE(obj:
*mut JSObject,
arg1:
&AutoCheckCannotGC)
-> *mut i8;
fn _Z20JS_GetUint8ArrayDataP8JSObjectRKN2JS17AutoCheckCannotGCE(obj:
*mut JSObject,
arg1:
&AutoCheckCannotGC)
-> *mut u8;
fn _Z27JS_GetUint8ClampedArrayDataP8JSObjectRKN2JS17AutoCheckCannotGCE(obj:
*mut JSObject,
arg1:
&AutoCheckCannotGC)
-> *mut u8;
fn _Z20JS_GetInt16ArrayDataP8JSObjectRKN2JS17AutoCheckCannotGCE(obj:
*mut JSObject,
arg1:
&AutoCheckCannotGC)
-> *mut i16;
fn _Z21JS_GetUint16ArrayDataP8JSObjectRKN2JS17AutoCheckCannotGCE(obj:
*mut JSObject,
arg1:
&AutoCheckCannotGC)
-> *mut u16;
fn _Z20JS_GetInt32ArrayDataP8JSObjectRKN2JS17AutoCheckCannotGCE(obj:
*mut JSObject,
arg1:
&AutoCheckCannotGC)
-> *mut i32;
fn _Z21JS_GetUint32ArrayDataP8JSObjectRKN2JS17AutoCheckCannotGCE(obj:
*mut JSObject,
arg1:
&AutoCheckCannotGC)
-> *mut u32;
fn _Z22JS_GetFloat32ArrayDataP8JSObjectRKN2JS17AutoCheckCannotGCE(obj:
*mut JSObject,
arg1:
&AutoCheckCannotGC)
-> *mut f32;
fn _Z22JS_GetFloat64ArrayDataP8JSObjectRKN2JS17AutoCheckCannotGCE(obj:
*mut JSObject,
arg1:
&AutoCheckCannotGC)
-> *mut f64;
fn _Z27JS_GetSharedArrayBufferDataP8JSObjectRKN2JS17AutoCheckCannotGCE(obj:
*mut JSObject,
arg1:
&AutoCheckCannotGC)
-> *mut u8;
fn _Z25JS_GetSharedInt8ArrayDataP8JSObjectRKN2JS17AutoCheckCannotGCE(obj:
*mut JSObject,
arg1:
&AutoCheckCannotGC)
-> *mut i8;
fn _Z26JS_GetSharedUint8ArrayDataP8JSObjectRKN2JS17AutoCheckCannotGCE(obj:
*mut JSObject,
arg1:
&AutoCheckCannotGC)
-> *mut u8;
fn _Z33JS_GetSharedUint8ClampedArrayDataP8JSObjectRKN2JS17AutoCheckCannotGCE(obj:
*mut JSObject,
arg1:
&AutoCheckCannotGC)
-> *mut u8;
fn _Z26JS_GetSharedInt16ArrayDataP8JSObjectRKN2JS17AutoCheckCannotGCE(obj:
*mut JSObject,
arg1:
&AutoCheckCannotGC)
-> *mut i16;
fn _Z27JS_GetSharedUint16ArrayDataP8JSObjectRKN2JS17AutoCheckCannotGCE(obj:
*mut JSObject,
arg1:
&AutoCheckCannotGC)
-> *mut u16;
fn _Z26JS_GetSharedInt32ArrayDataP8JSObjectRKN2JS17AutoCheckCannotGCE(obj:
*mut JSObject,
arg1:
&AutoCheckCannotGC)
-> *mut i32;
fn _Z27JS_GetSharedUint32ArrayDataP8JSObjectRKN2JS17AutoCheckCannotGCE(obj:
*mut JSObject,
arg1:
&AutoCheckCannotGC)
-> *mut u32;
fn _Z28JS_GetSharedFloat32ArrayDataP8JSObjectRKN2JS17AutoCheckCannotGCE(obj:
*mut JSObject,
arg1:
&AutoCheckCannotGC)
-> *mut f32;
fn _Z28JS_GetSharedFloat64ArrayDataP8JSObjectRKN2JS17AutoCheckCannotGCE(obj:
*mut JSObject,
arg1:
&AutoCheckCannotGC)
-> *mut f64;
fn _Z25JS_GetArrayBufferViewDataP8JSObjectRKN2JS17AutoCheckCannotGCE(obj:
*mut JSObject,
arg1:
&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)
-> bool;
fn _Z30JS_IsNeuteredArrayBufferObjectP8JSObject(obj: *mut JSObject)
-> bool;
fn _Z19JS_IsDataViewObjectP8JSObject(obj: *mut JSObject) -> bool;
fn _Z24JS_GetDataViewByteOffsetP8JSObject(obj: *mut JSObject) -> u32;
fn _Z24JS_GetDataViewByteLengthP8JSObject(obj: *mut JSObject) -> u32;
fn _Z18JS_GetDataViewDataP8JSObjectRKN2JS17AutoCheckCannotGCE(obj:
*mut JSObject,
arg1:
&AutoCheckCannotGC)
-> *mut ::libc::c_void;
fn _ZN2js9WatchGutsEP9JSContextN2JS6HandleIP8JSObjectEENS3_I4jsidEES6_(cx:
*mut JSContext,
obj:
HandleObject,
id:
HandleId,
callable:
HandleObject)
-> bool;
fn _ZN2js11UnwatchGutsEP9JSContextN2JS6HandleIP8JSObjectEENS3_I4jsidEE(cx:
*mut JSContext,
obj:
HandleObject,
id:
HandleId)
-> bool;
fn _ZN2js6detail13IdMatchesAtomE4jsidP6JSAtom(id: jsid, atom: *mut JSAtom)
-> bool;
fn _ZN2js33PrepareScriptEnvironmentAndInvokeEP9JSRuntimeN2JS6HandleIP8JSObjectEERNS_25ScriptEnvironmentPreparer7ClosureE(rt:
*mut JSRuntime,
scope:
HandleObject,
closure:
&mut Closure)
-> bool;
fn _ZN2js28SetScriptEnvironmentPreparerEP9JSRuntimePNS_25ScriptEnvironmentPreparerE(rt:
*mut JSRuntime,
preparer:
*mut ScriptEnvironmentPreparer);
fn _ZN2js24Debug_SetActiveJSContextEP9JSRuntimeP9JSContext(rt:
*mut JSRuntime,
cx:
*mut JSContext);
fn _ZN2js25SetCTypesActivityCallbackEP9JSRuntimePFvP9JSContextNS_18CTypesActivityTypeEE(rt:
*mut JSRuntime,
cb:
CTypesActivityCallback);
fn _ZN2js25SetObjectMetadataCallbackEP9JSContextPFP8JSObjectS1_S3_E(cx:
*mut JSContext,
callback:
ObjectMetadataCallback);
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)
-> bool;
fn _ZN2js15ForwardToNativeEP9JSContextPFbS1_jPN2JS5ValueEERKNS2_8CallArgsE(cx:
*mut JSContext,
native:
JSNative,
args:
&CallArgs)
-> bool;
fn _ZN2js30SetPropertyIgnoringNamedGetterEP9JSContextN2JS6HandleIP8JSObjectEENS3_I4jsidEENS3_INS2_5ValueEEESA_NS3_I20JSPropertyDescriptorEERNS2_14ObjectOpResultE(cx:
*mut JSContext,
obj:
HandleObject,
id:
HandleId,
v:
HandleValue,
receiver:
HandleValue,
ownDesc:
Handle<JSPropertyDescriptor>,
result:
&mut ObjectOpResult)
-> bool;
fn _ZN2js17ReportErrorWithIdEP9JSContextPKcN2JS6HandleI4jsidEE(cx:
*mut JSContext,
msg:
*const ::libc::c_char,
id:
HandleId);
fn _ZN2js29ExecuteInGlobalAndReturnScopeEP9JSContextN2JS6HandleIP8JSObjectEENS3_IP8JSScriptEENS2_13MutableHandleIS5_EE(cx:
*mut JSContext,
obj:
HandleObject,
script:
HandleScript,
scope:
MutableHandleObject)
-> bool;
fn _ZN2js37GetObjectEnvironmentObjectForFunctionEP10JSFunction(fun:
*mut JSFunction)
-> *mut JSObject;
fn _ZN2js26GetFirstSubsumedSavedFrameEP9JSContextN2JS6HandleIP8JSObjectEE(cx:
*mut JSContext,
savedFrame:
HandleObject)
-> *mut JSObject;
fn _ZN2js19ReportIsNotFunctionEP9JSContextN2JS6HandleINS2_5ValueEEE(cx:
*mut JSContext,
v:
HandleValue)
-> bool;
fn _ZN2js18ConvertArgsToArrayEP9JSContextRKN2JS8CallArgsE(cx:
*mut JSContext,
args: &CallArgs)
-> *mut JSObject;
fn _Z33JS_StoreObjectPostBarrierCallbackP9JSContextPFvP8JSTracerP8JSObjectPvES4_S5_(cx:
*mut JSContext,
callback:
::std::option::Option<unsafe extern "C" fn(trc:
*mut JSTracer,
key:
*mut JSObject,
data:
*mut ::libc::c_void)>,
key:
*mut JSObject,
data:
*mut ::libc::c_void);
fn _Z33JS_StoreStringPostBarrierCallbackP9JSContextPFvP8JSTracerP8JSStringPvES4_S5_(cx:
*mut JSContext,
callback:
::std::option::Option<unsafe extern "C" fn(trc:
*mut JSTracer,
key:
*mut JSString,
data:
*mut ::libc::c_void)>,
key:
*mut JSString,
data:
*mut ::libc::c_void);
fn _Z31JS_ClearAllPostBarrierCallbacksP9JSRuntime(rt: *mut JSRuntime);
}
#[inline]
pub unsafe extern "C" fn JS_Assert(s: *const ::libc::c_char,
file: *const ::libc::c_char, ln: i32) {
_Z9JS_AssertPKcS0_i(s, file, ln)
}
#[inline]
pub unsafe extern "C" fn ScrambleHashCode(h: HashNumber) -> HashNumber {
_ZN2js6detail16ScrambleHashCodeEj(h)
}
#[inline]
pub unsafe extern "C" fn FinishGC(rt: *mut JSRuntime) {
_ZN2js8FinishGCEP9JSRuntime(rt)
}
#[inline]
pub unsafe extern "C" fn MarkPersistentRootedChains(arg1: *mut JSTracer) {
_ZN2js2gc26MarkPersistentRootedChainsEP8JSTracer(arg1)
}
#[inline]
pub unsafe extern "C" fn FinishPersistentRootedChains(arg1: *mut JSRuntime) {
_ZN2js2gc28FinishPersistentRootedChainsEP9JSRuntime(arg1)
}
#[inline]
pub unsafe extern "C" fn GetRuntime(cx: *const JSContext) -> *mut JSRuntime {
_ZN2js10GetRuntimeEPK9JSContext(cx)
}
#[inline]
pub unsafe extern "C" fn GetContextCompartment(cx: *const JSContext)
-> *mut JSCompartment {
_ZN2js21GetContextCompartmentEPK9JSContext(cx)
}
#[inline]
pub unsafe extern "C" fn GetContextZone(cx: *const JSContext) -> *mut Zone {
_ZN2js14GetContextZoneEPK9JSContext(cx)
}
#[inline]
pub unsafe extern "C" fn CurrentThreadCanAccessRuntime(rt: *mut JSRuntime)
-> bool {
_ZN2js29CurrentThreadCanAccessRuntimeEP9JSRuntime(rt)
}
#[inline]
pub unsafe extern "C" fn CurrentThreadCanAccessZone(zone: *mut Zone) -> bool {
_ZN2js26CurrentThreadCanAccessZoneEPN2JS4ZoneE(zone)
}
#[inline]
pub unsafe extern "C" fn AssertGCThingHasType(cell: *mut Cell,
kind: TraceKind) {
_ZN2js2gc20AssertGCThingHasTypeEPNS0_4CellEN2JS9TraceKindE(cell, kind)
}
#[inline]
pub unsafe extern "C" fn IsInsideNursery(cell: *const Cell) -> bool {
_ZN2js2gc15IsInsideNurseryEPKNS0_4CellE(cell)
}
#[inline]
pub unsafe extern "C" fn GetObjectZone(obj: *mut JSObject) -> *mut Zone {
_ZN2JS13GetObjectZoneEP8JSObject(obj)
}
#[inline]
pub unsafe extern "C" fn NewMemoryInfoObject(cx: *mut JSContext)
-> *mut JSObject {
_ZN2js2gc19NewMemoryInfoObjectEP9JSContext(cx)
}
#[inline]
pub unsafe extern "C" fn PrepareZoneForGC(zone: *mut Zone) {
_ZN2JS16PrepareZoneForGCEPNS_4ZoneE(zone)
}
#[inline]
pub unsafe extern "C" fn PrepareForFullGC(rt: *mut JSRuntime) {
_ZN2JS16PrepareForFullGCEP9JSRuntime(rt)
}
#[inline]
pub unsafe extern "C" fn PrepareForIncrementalGC(rt: *mut JSRuntime) {
_ZN2JS23PrepareForIncrementalGCEP9JSRuntime(rt)
}
#[inline]
pub unsafe extern "C" fn IsGCScheduled(rt: *mut JSRuntime) -> bool {
_ZN2JS13IsGCScheduledEP9JSRuntime(rt)
}
#[inline]
pub unsafe extern "C" fn SkipZoneForGC(zone: *mut Zone) {
_ZN2JS13SkipZoneForGCEPNS_4ZoneE(zone)
}
#[inline]
pub unsafe extern "C" fn GCForReason(rt: *mut JSRuntime,
gckind: JSGCInvocationKind,
reason: Reason) {
_ZN2JS11GCForReasonEP9JSRuntime18JSGCInvocationKindNS_8gcreason6ReasonE(rt,
gckind,
reason)
}
#[inline]
pub unsafe extern "C" fn StartIncrementalGC(rt: *mut JSRuntime,
gckind: JSGCInvocationKind,
reason: Reason, millis: i64) {
_ZN2JS18StartIncrementalGCEP9JSRuntime18JSGCInvocationKindNS_8gcreason6ReasonEx(rt,
gckind,
reason,
millis)
}
#[inline]
pub unsafe extern "C" fn IncrementalGCSlice(rt: *mut JSRuntime,
reason: Reason, millis: i64) {
_ZN2JS18IncrementalGCSliceEP9JSRuntimeNS_8gcreason6ReasonEx(rt, reason,
millis)
}
#[inline]
pub unsafe extern "C" fn FinishIncrementalGC(rt: *mut JSRuntime,
reason: Reason) {
_ZN2JS19FinishIncrementalGCEP9JSRuntimeNS_8gcreason6ReasonE(rt, reason)
}
#[inline]
pub unsafe extern "C" fn AbortIncrementalGC(rt: *mut JSRuntime) {
_ZN2JS18AbortIncrementalGCEP9JSRuntime(rt)
}
#[inline]
pub unsafe extern "C" fn SetGCSliceCallback(rt: *mut JSRuntime,
callback: GCSliceCallback)
-> GCSliceCallback {
_ZN2JS18SetGCSliceCallbackEP9JSRuntimePFvS1_NS_10GCProgressERKNS_13GCDescriptionEE(rt,
callback)
}
#[inline]
pub unsafe extern "C" fn DisableIncrementalGC(rt: *mut JSRuntime) {
_ZN2JS20DisableIncrementalGCEP9JSRuntime(rt)
}
#[inline]
pub unsafe extern "C" fn IsIncrementalGCEnabled(rt: *mut JSRuntime) -> bool {
_ZN2JS22IsIncrementalGCEnabledEP9JSRuntime(rt)
}
#[inline]
pub unsafe extern "C" fn IsIncrementalGCInProgress(rt: *mut JSRuntime)
-> bool {
_ZN2JS25IsIncrementalGCInProgressEP9JSRuntime(rt)
}
#[inline]
pub unsafe extern "C" fn IsIncrementalBarrierNeeded(rt: *mut JSRuntime)
-> bool {
_ZN2JS26IsIncrementalBarrierNeededEP9JSRuntime(rt)
}
#[inline]
pub unsafe extern "C" fn IsIncrementalBarrierNeeded1(cx: *mut JSContext)
-> bool {
_ZN2JS26IsIncrementalBarrierNeededEP9JSContext(cx)
}
#[inline]
pub unsafe extern "C" fn IncrementalReferenceBarrier(thing: GCCellPtr) {
_ZN2JS27IncrementalReferenceBarrierENS_9GCCellPtrE(thing)
}
#[inline]
pub unsafe extern "C" fn IncrementalValueBarrier(v: &Value) {
_ZN2JS23IncrementalValueBarrierERKNS_5ValueE(v)
}
#[inline]
pub unsafe extern "C" fn IncrementalObjectBarrier(obj: *mut JSObject) {
_ZN2JS24IncrementalObjectBarrierEP8JSObject(obj)
}
#[inline]
pub unsafe extern "C" fn WasIncrementalGC(rt: *mut JSRuntime) -> bool {
_ZN2JS16WasIncrementalGCEP9JSRuntime(rt)
}
#[inline]
pub unsafe extern "C" fn IsGenerationalGCEnabled(rt: *mut JSRuntime) -> bool {
_ZN2JS23IsGenerationalGCEnabledEP9JSRuntime(rt)
}
#[inline]
pub unsafe extern "C" fn GetGCNumber() -> size_t { _ZN2JS11GetGCNumberEv() }
#[inline]
pub unsafe extern "C" fn ShrinkGCBuffers(rt: *mut JSRuntime) {
_ZN2JS15ShrinkGCBuffersEP9JSRuntime(rt)
}
#[inline]
pub unsafe extern "C" fn UnmarkGrayGCThingRecursively(thing: GCCellPtr)
-> bool {
_ZN2JS28UnmarkGrayGCThingRecursivelyENS_9GCCellPtrE(thing)
}
#[inline]
pub unsafe extern "C" fn PokeGC(rt: *mut JSRuntime) {
_ZN2JS6PokeGCEP9JSRuntime(rt)
}
#[inline]
pub unsafe extern "C" fn NotifyDidPaint(rt: *mut JSRuntime) {
_ZN2JS14NotifyDidPaintEP9JSRuntime(rt)
}
#[inline]
pub unsafe extern "C" fn isGCEnabled() -> bool { _ZN2JS11isGCEnabledEv() }
#[inline]
pub unsafe extern "C" fn HeapObjectPostBarrier(objp: *mut *mut JSObject,
prev: *mut JSObject,
next: *mut JSObject) {
_ZN2JS21HeapObjectPostBarrierEPP8JSObjectS1_S1_(objp, prev, next)
}
#[inline]
pub unsafe extern "C" fn AssertGCThingMustBeTenured(obj: *mut JSObject) {
_ZN2JS26AssertGCThingMustBeTenuredEP8JSObject(obj)
}
#[inline]
pub unsafe extern "C" fn AssertGCThingIsNotAnObjectSubclass(cell: *mut Cell) {
_ZN2JS34AssertGCThingIsNotAnObjectSubclassEPN2js2gc4CellE(cell)
}
#[inline]
pub unsafe extern "C" fn IsOptimizedPlaceholderMagicValue(v: &Value) -> bool {
_ZN2JS32IsOptimizedPlaceholderMagicValueERKNS_5ValueE(v)
}
#[inline]
pub unsafe extern "C" fn SameType(lhs: &Value, rhs: &Value) -> bool {
_ZN2JS8SameTypeERKNS_5ValueES2_(lhs, rhs)
}
#[inline]
pub unsafe extern "C" fn HeapValuePostBarrier(valuep: *mut Value,
prev: &Value, next: &Value) {
_ZN2JS20HeapValuePostBarrierEPNS_5ValueERKS0_S3_(valuep, prev, next)
}
#[inline]
pub unsafe extern "C" fn JS_ComputeThis(cx: *mut JSContext, vp: *mut Value)
-> Value {
_Z14JS_ComputeThisP9JSContextPN2JS5ValueE(cx, vp)
}
#[inline]
pub unsafe extern "C" fn CallReceiverFromArgv(argv: *mut Value)
-> CallReceiver {
_ZN2JS20CallReceiverFromArgvEPNS_5ValueE(argv)
}
#[inline]
pub unsafe extern "C" fn CallReceiverFromVp(vp: *mut Value) -> CallReceiver {
_ZN2JS18CallReceiverFromVpEPNS_5ValueE(vp)
}
#[inline]
pub unsafe extern "C" fn CallArgsFromVp(argc: u32, vp: *mut Value)
-> CallArgs {
_ZN2JS14CallArgsFromVpEjPNS_5ValueE(argc, vp)
}
#[inline]
pub unsafe extern "C" fn CallArgsFromSp(stackSlots: u32, sp: *mut Value,
constructing: bool) -> CallArgs {
_ZN2JS14CallArgsFromSpEjPNS_5ValueEb(stackSlots, sp, constructing)
}
#[inline]
pub unsafe extern "C" fn JS_THIS(cx: *mut JSContext, vp: *mut Value)
-> Value {
_Z7JS_THISP9JSContextPN2JS5ValueE(cx, vp)
}
#[inline]
pub unsafe extern "C" fn INTERNED_STRING_TO_JSID(cx: *mut JSContext,
str: *mut JSString) -> jsid {
_Z23INTERNED_STRING_TO_JSIDP9JSContextP8JSString(cx, str)
}
#[inline]
pub unsafe extern "C" fn DELEGATED_CLASSSPEC(spec: *const ClassSpec)
-> ClassObjectCreationOp {
_ZN2js19DELEGATED_CLASSSPECEPKNS_9ClassSpecE(spec)
}
#[inline]
pub unsafe extern "C" fn ObjectClassIs(obj: &mut JSObject,
classValue: ESClassValue,
cx: *mut JSContext) -> bool {
_ZN2js13ObjectClassIsER8JSObjectNS_12ESClassValueEP9JSContext(obj,
classValue,
cx)
}
#[inline]
pub unsafe extern "C" fn IsObjectWithClass(v: &Value,
classValue: ESClassValue,
cx: *mut JSContext) -> bool {
_ZN2js17IsObjectWithClassERKN2JS5ValueENS_12ESClassValueEP9JSContext(v,
classValue,
cx)
}
#[inline]
pub unsafe extern "C" fn Unbox(cx: *mut JSContext, obj: HandleObject,
vp: MutableHandleValue) -> bool {
_ZN2js5UnboxEP9JSContextN2JS6HandleIP8JSObjectEENS2_13MutableHandleINS2_5ValueEEE(cx,
obj,
vp)
}
#[inline]
pub unsafe extern "C" fn JS_HoldPrincipals(principals: *mut JSPrincipals) {
_Z17JS_HoldPrincipalsP12JSPrincipals(principals)
}
#[inline]
pub unsafe extern "C" fn JS_DropPrincipals(rt: *mut JSRuntime,
principals: *mut JSPrincipals) {
_Z17JS_DropPrincipalsP9JSRuntimeP12JSPrincipals(rt, principals)
}
#[inline]
pub unsafe extern "C" fn JS_SetSecurityCallbacks(rt: *mut JSRuntime,
callbacks:
*const JSSecurityCallbacks) {
_Z23JS_SetSecurityCallbacksP9JSRuntimePK19JSSecurityCallbacks(rt,
callbacks)
}
#[inline]
pub unsafe extern "C" fn JS_GetSecurityCallbacks(rt: *mut JSRuntime)
-> *const JSSecurityCallbacks {
_Z23JS_GetSecurityCallbacksP9JSRuntime(rt)
}
#[inline]
pub unsafe extern "C" fn JS_SetTrustedPrincipals(rt: *mut JSRuntime,
prin: *const JSPrincipals) {
_Z23JS_SetTrustedPrincipalsP9JSRuntimePK12JSPrincipals(rt, prin)
}
#[inline]
pub unsafe extern "C" fn JS_InitDestroyPrincipalsCallback(rt: *mut JSRuntime,
destroyPrincipals:
JSDestroyPrincipalsOp) {
_Z32JS_InitDestroyPrincipalsCallbackP9JSRuntimePFvP12JSPrincipalsE(rt,
destroyPrincipals)
}
#[inline]
pub unsafe extern "C" fn GCTraceKindToAscii(kind: TraceKind)
-> *const ::libc::c_char {
_ZN2JS18GCTraceKindToAsciiENS_9TraceKindE(kind)
}
#[inline]
pub unsafe extern "C" fn JS_CallValueTracer(trc: *mut JSTracer,
valuep: *mut Heap<Value>,
name: *const ::libc::c_char) {
_Z18JS_CallValueTracerP8JSTracerPN2JS4HeapINS1_5ValueEEEPKc(trc, valuep,
name)
}
#[inline]
pub unsafe extern "C" fn JS_CallIdTracer(trc: *mut JSTracer,
idp: *mut Heap<jsid>,
name: *const ::libc::c_char) {
_Z15JS_CallIdTracerP8JSTracerPN2JS4HeapI4jsidEEPKc(trc, idp, name)
}
#[inline]
pub unsafe extern "C" fn JS_CallObjectTracer(trc: *mut JSTracer,
objp: *mut Heap<*mut JSObject>,
name: *const ::libc::c_char) {
_Z19JS_CallObjectTracerP8JSTracerPN2JS4HeapIP8JSObjectEEPKc(trc, objp,
name)
}
#[inline]
pub unsafe extern "C" fn JS_CallStringTracer(trc: *mut JSTracer,
strp: *mut Heap<*mut JSString>,
name: *const ::libc::c_char) {
_Z19JS_CallStringTracerP8JSTracerPN2JS4HeapIP8JSStringEEPKc(trc, strp,
name)
}
#[inline]
pub unsafe extern "C" fn JS_CallScriptTracer(trc: *mut JSTracer,
scriptp:
*mut Heap<*mut JSScript>,
name: *const ::libc::c_char) {
_Z19JS_CallScriptTracerP8JSTracerPN2JS4HeapIP8JSScriptEEPKc(trc, scriptp,
name)
}
#[inline]
pub unsafe extern "C" fn JS_CallFunctionTracer(trc: *mut JSTracer,
funp:
*mut Heap<*mut JSFunction>,
name: *const ::libc::c_char) {
_Z21JS_CallFunctionTracerP8JSTracerPN2JS4HeapIP10JSFunctionEEPKc(trc,
funp,
name)
}
#[inline]
pub unsafe extern "C" fn JS_CallUnbarrieredValueTracer(trc: *mut JSTracer,
valuep: *mut Value,
name:
*const ::libc::c_char) {
_Z29JS_CallUnbarrieredValueTracerP8JSTracerPN2JS5ValueEPKc(trc, valuep,
name)
}
#[inline]
pub unsafe extern "C" fn JS_CallUnbarrieredIdTracer(trc: *mut JSTracer,
idp: *mut jsid,
name:
*const ::libc::c_char) {
_Z26JS_CallUnbarrieredIdTracerP8JSTracerP4jsidPKc(trc, idp, name)
}
#[inline]
pub unsafe extern "C" fn JS_CallUnbarrieredObjectTracer(trc: *mut JSTracer,
objp:
*mut *mut JSObject,
name:
*const ::libc::c_char) {
_Z30JS_CallUnbarrieredObjectTracerP8JSTracerPP8JSObjectPKc(trc, objp,
name)
}
#[inline]
pub unsafe extern "C" fn JS_CallUnbarrieredStringTracer(trc: *mut JSTracer,
strp:
*mut *mut JSString,
name:
*const ::libc::c_char) {
_Z30JS_CallUnbarrieredStringTracerP8JSTracerPP8JSStringPKc(trc, strp,
name)
}
#[inline]
pub unsafe extern "C" fn JS_CallUnbarrieredScriptTracer(trc: *mut JSTracer,
scriptp:
*mut *mut JSScript,
name:
*const ::libc::c_char) {
_Z30JS_CallUnbarrieredScriptTracerP8JSTracerPP8JSScriptPKc(trc, scriptp,
name)
}
#[inline]
pub unsafe extern "C" fn JS_CallTenuredObjectTracer(trc: *mut JSTracer,
objp:
*mut TenuredHeap<*mut JSObject>,
name:
*const ::libc::c_char) {
_Z26JS_CallTenuredObjectTracerP8JSTracerPN2JS11TenuredHeapIP8JSObjectEEPKc(trc,
objp,
name)
}
#[inline]
pub unsafe extern "C" fn JS_TraceChildren(trc: *mut JSTracer,
thing: *mut ::libc::c_void,
kind: TraceKind) {
_Z16JS_TraceChildrenP8JSTracerPvN2JS9TraceKindE(trc, thing, kind)
}
#[inline]
pub unsafe extern "C" fn JS_TraceRuntime(trc: *mut JSTracer) {
_Z15JS_TraceRuntimeP8JSTracer(trc)
}
#[inline]
pub unsafe extern "C" fn JS_TraceIncomingCCWs(trc: *mut JSTracer,
zones: &ZoneSet) {
_Z20JS_TraceIncomingCCWsP8JSTracerRKN2js7HashSetIPN2JS4ZoneENS1_13DefaultHasherIS5_EENS1_17SystemAllocPolicyEEE(trc,
zones)
}
#[inline]
pub unsafe extern "C" fn JS_GetTraceThingInfo(buf: *mut ::libc::c_char,
bufsize: size_t,
trc: *mut JSTracer,
thing: *mut ::libc::c_void,
kind: TraceKind,
includeDetails: bool) {
_Z20JS_GetTraceThingInfoPcjP8JSTracerPvN2JS9TraceKindEb(buf, bufsize, trc,
thing, kind,
includeDetails)
}
/************************************************************************/
#[inline]
pub unsafe extern "C" fn JS_StringHasBeenPinned(cx: *mut JSContext,
str: *mut JSString) -> bool {
_Z22JS_StringHasBeenPinnedP9JSContextP8JSString(cx, str)
}
#[inline]
pub unsafe extern "C" fn JS_CallOnce(once: *mut JSCallOnceType,
func: JSInitCallback) -> bool {
_Z11JS_CallOnceP14PRCallOnceTypePFbvE(once, func)
}
#[inline]
pub unsafe extern "C" fn JS_Now() -> i64 { _Z6JS_Nowv() }
#[inline]
pub unsafe extern "C" fn JS_GetNaNValue(cx: *mut JSContext) -> Value {
_Z14JS_GetNaNValueP9JSContext(cx)
}
#[inline]
pub unsafe extern "C" fn JS_GetNegativeInfinityValue(cx: *mut JSContext)
-> Value {
_Z27JS_GetNegativeInfinityValueP9JSContext(cx)
}
#[inline]
pub unsafe extern "C" fn JS_GetPositiveInfinityValue(cx: *mut JSContext)
-> Value {
_Z27JS_GetPositiveInfinityValueP9JSContext(cx)
}
#[inline]
pub unsafe extern "C" fn JS_GetEmptyStringValue(cx: *mut JSContext) -> Value {
_Z22JS_GetEmptyStringValueP9JSContext(cx)
}
#[inline]
pub unsafe extern "C" fn JS_GetEmptyString(rt: *mut JSRuntime)
-> *mut JSString {
_Z17JS_GetEmptyStringP9JSRuntime(rt)
}
#[inline]
pub unsafe extern "C" fn JS_ValueToObject(cx: *mut JSContext, v: HandleValue,
objp: MutableHandleObject) -> bool {
_Z16JS_ValueToObjectP9JSContextN2JS6HandleINS1_5ValueEEENS1_13MutableHandleIP8JSObjectEE(cx,
v,
objp)
}
#[inline]
pub unsafe extern "C" fn JS_ValueToFunction(cx: *mut JSContext,
v: HandleValue)
-> *mut JSFunction {
_Z18JS_ValueToFunctionP9JSContextN2JS6HandleINS1_5ValueEEE(cx, v)
}
#[inline]
pub unsafe extern "C" fn JS_ValueToConstructor(cx: *mut JSContext,
v: HandleValue)
-> *mut JSFunction {
_Z21JS_ValueToConstructorP9JSContextN2JS6HandleINS1_5ValueEEE(cx, v)
}
#[inline]
pub unsafe extern "C" fn JS_ValueToSource(cx: *mut JSContext,
v: Handle<Value>) -> *mut JSString {
_Z16JS_ValueToSourceP9JSContextN2JS6HandleINS1_5ValueEEE(cx, v)
}
#[inline]
pub unsafe extern "C" fn JS_DoubleIsInt32(d: f64, ip: *mut i32) -> bool {
_Z16JS_DoubleIsInt32dPi(d, ip)
}
#[inline]
pub unsafe extern "C" fn JS_TypeOfValue(cx: *mut JSContext, v: Handle<Value>)
-> JSType {
_Z14JS_TypeOfValueP9JSContextN2JS6HandleINS1_5ValueEEE(cx, v)
}
#[inline]
pub unsafe extern "C" fn JS_StrictlyEqual(cx: *mut JSContext,
v1: Handle<Value>,
v2: Handle<Value>, equal: *mut bool)
-> bool {
_Z16JS_StrictlyEqualP9JSContextN2JS6HandleINS1_5ValueEEES4_Pb(cx, v1, v2,
equal)
}
#[inline]
pub unsafe extern "C" fn JS_LooselyEqual(cx: *mut JSContext,
v1: Handle<Value>, v2: Handle<Value>,
equal: *mut bool) -> bool {
_Z15JS_LooselyEqualP9JSContextN2JS6HandleINS1_5ValueEEES4_Pb(cx, v1, v2,
equal)
}
#[inline]
pub unsafe extern "C" fn JS_SameValue(cx: *mut JSContext, v1: Handle<Value>,
v2: Handle<Value>, same: *mut bool)
-> bool {
_Z12JS_SameValueP9JSContextN2JS6HandleINS1_5ValueEEES4_Pb(cx, v1, v2,
same)
}
#[inline]
pub unsafe extern "C" fn JS_IsBuiltinEvalFunction(fun: *mut JSFunction)
-> bool {
_Z24JS_IsBuiltinEvalFunctionP10JSFunction(fun)
}
#[inline]
pub unsafe extern "C" fn JS_IsBuiltinFunctionConstructor(fun: *mut JSFunction)
-> bool {
_Z31JS_IsBuiltinFunctionConstructorP10JSFunction(fun)
}
/**
* Initialize SpiderMonkey, returning true only if initialization succeeded.
* Once this method has succeeded, it is safe to call JS_NewRuntime and other
* JSAPI methods.
*
* This method must be called before any other JSAPI method is used on any
* thread. Once it has been used, it is safe to call any JSAPI method, and it
* remains safe to do so until JS_ShutDown is correctly called.
*
* It is currently not possible to initialize SpiderMonkey multiple times (that
* is, calling JS_Init/JSAPI methods/JS_ShutDown in that order, then doing so
* again). This restriction may eventually be lifted.
*/
#[inline]
pub unsafe extern "C" fn JS_Init() -> bool { _Z7JS_Initv() }
/**
* Destroy free-standing resources allocated by SpiderMonkey, not associated
* with any runtime, context, or other structure.
*
* This method should be called after all other JSAPI data has been properly
* cleaned up: every new runtime must have been destroyed, every new context
* must have been destroyed, and so on. Calling this method before all other
* resources have been destroyed has undefined behavior.
*
* Failure to call this method, at present, has no adverse effects other than
* leaking memory. This may not always be the case; it's recommended that all
* embedders call this method when all other JSAPI operations have completed.
*
* It is currently not possible to initialize SpiderMonkey multiple times (that
* is, calling JS_Init/JSAPI methods/JS_ShutDown in that order, then doing so
* again). This restriction may eventually be lifted.
*/
#[inline]
pub unsafe extern "C" fn JS_ShutDown() { _Z11JS_ShutDownv() }
#[inline]
pub unsafe extern "C" fn JS_NewRuntime(maxbytes: u32, maxNurseryBytes: u32,
parentRuntime: *mut JSRuntime)
-> *mut JSRuntime {
_Z13JS_NewRuntimejjP9JSRuntime(maxbytes, maxNurseryBytes, parentRuntime)
}
#[inline]
pub unsafe extern "C" fn JS_DestroyRuntime(rt: *mut JSRuntime) {
_Z17JS_DestroyRuntimeP9JSRuntime(rt)
}
#[inline]
pub unsafe extern "C" fn JS_SetICUMemoryFunctions(allocFn: JS_ICUAllocFn,
reallocFn: JS_ICUReallocFn,
freeFn: JS_ICUFreeFn)
-> bool {
_Z24JS_SetICUMemoryFunctionsPFPvPKvjEPFS_S1_S_jEPFvS1_S_E(allocFn,
reallocFn,
freeFn)
}
#[inline]
pub unsafe extern "C" fn JS_SetCurrentEmbedderTimeFunction(timeFn:
JS_CurrentEmbedderTimeFunction) {
_Z33JS_SetCurrentEmbedderTimeFunctionPFdvE(timeFn)
}
#[inline]
pub unsafe extern "C" fn JS_GetCurrentEmbedderTime() -> f64 {
_Z25JS_GetCurrentEmbedderTimev()
}
#[inline]
pub unsafe extern "C" fn JS_GetRuntimePrivate(rt: *mut JSRuntime)
-> *mut ::libc::c_void {
_Z20JS_GetRuntimePrivateP9JSRuntime(rt)
}
#[inline]
pub unsafe extern "C" fn JS_GetRuntime(cx: *mut JSContext) -> *mut JSRuntime {
_Z13JS_GetRuntimeP9JSContext(cx)
}
#[inline]
pub unsafe extern "C" fn JS_GetParentRuntime(cx: *mut JSContext)
-> *mut JSRuntime {
_Z19JS_GetParentRuntimeP9JSContext(cx)
}
#[inline]
pub unsafe extern "C" fn JS_SetRuntimePrivate(rt: *mut JSRuntime,
data: *mut ::libc::c_void) {
_Z20JS_SetRuntimePrivateP9JSRuntimePv(rt, data)
}
#[inline]
pub unsafe extern "C" fn JS_BeginRequest(cx: *mut JSContext) {
_Z15JS_BeginRequestP9JSContext(cx)
}
#[inline]
pub unsafe extern "C" fn JS_EndRequest(cx: *mut JSContext) {
_Z13JS_EndRequestP9JSContext(cx)
}
#[inline]
pub unsafe extern "C" fn AssertHeapIsIdle(rt: *mut JSRuntime) {
_ZN2js16AssertHeapIsIdleEP9JSRuntime(rt)
}
#[inline]
pub unsafe extern "C" fn AssertHeapIsIdle1(cx: *mut JSContext) {
_ZN2js16AssertHeapIsIdleEP9JSContext(cx)
}
#[inline]
pub unsafe extern "C" fn JS_SetContextCallback(rt: *mut JSRuntime,
cxCallback: JSContextCallback,
data: *mut ::libc::c_void) {
_Z21JS_SetContextCallbackP9JSRuntimePFbP9JSContextjPvES3_(rt, cxCallback,
data)
}
#[inline]
pub unsafe extern "C" fn JS_NewContext(rt: *mut JSRuntime,
stackChunkSize: size_t)
-> *mut JSContext {
_Z13JS_NewContextP9JSRuntimej(rt, stackChunkSize)
}
#[inline]
pub unsafe extern "C" fn JS_DestroyContext(cx: *mut JSContext) {
_Z17JS_DestroyContextP9JSContext(cx)
}
#[inline]
pub unsafe extern "C" fn JS_DestroyContextNoGC(cx: *mut JSContext) {
_Z21JS_DestroyContextNoGCP9JSContext(cx)
}
#[inline]
pub unsafe extern "C" fn JS_GetContextPrivate(cx: *mut JSContext)
-> *mut ::libc::c_void {
_Z20JS_GetContextPrivateP9JSContext(cx)
}
#[inline]
pub unsafe extern "C" fn JS_SetContextPrivate(cx: *mut JSContext,
data: *mut ::libc::c_void) {
_Z20JS_SetContextPrivateP9JSContextPv(cx, data)
}
#[inline]
pub unsafe extern "C" fn JS_GetSecondContextPrivate(cx: *mut JSContext)
-> *mut ::libc::c_void {
_Z26JS_GetSecondContextPrivateP9JSContext(cx)
}
#[inline]
pub unsafe extern "C" fn JS_SetSecondContextPrivate(cx: *mut JSContext,
data:
*mut ::libc::c_void) {
_Z26JS_SetSecondContextPrivateP9JSContextPv(cx, data)
}
#[inline]
pub unsafe extern "C" fn JS_ContextIterator(rt: *mut JSRuntime,
iterp: *mut *mut JSContext)
-> *mut JSContext {
_Z18JS_ContextIteratorP9JSRuntimePP9JSContext(rt, iterp)
}
#[inline]
pub unsafe extern "C" fn JS_GetVersion(cx: *mut JSContext) -> JSVersion {
_Z13JS_GetVersionP9JSContext(cx)
}
#[inline]
pub unsafe extern "C" fn JS_SetVersionForCompartment(compartment:
*mut JSCompartment,
version: JSVersion) {
_Z27JS_SetVersionForCompartmentP13JSCompartment9JSVersion(compartment,
version)
}
#[inline]
pub unsafe extern "C" fn JS_VersionToString(version: JSVersion)
-> *const ::libc::c_char {
_Z18JS_VersionToString9JSVersion(version)
}
#[inline]
pub unsafe extern "C" fn JS_StringToVersion(string: *const ::libc::c_char)
-> JSVersion {
_Z18JS_StringToVersionPKc(string)
}
#[inline]
pub unsafe extern "C" fn RuntimeOptionsRef(rt: *mut JSRuntime)
-> *mut RuntimeOptions {
_ZN2JS17RuntimeOptionsRefEP9JSRuntime(rt)
}
#[inline]
pub unsafe extern "C" fn RuntimeOptionsRef1(cx: *mut JSContext)
-> *mut RuntimeOptions {
_ZN2JS17RuntimeOptionsRefEP9JSContext(cx)
}
#[inline]
pub unsafe extern "C" fn ContextOptionsRef(cx: *mut JSContext)
-> *mut ContextOptions {
_ZN2JS17ContextOptionsRefEP9JSContext(cx)
}
#[inline]
pub unsafe extern "C" fn JS_GetImplementationVersion()
-> *const ::libc::c_char {
_Z27JS_GetImplementationVersionv()
}
#[inline]
pub unsafe extern "C" fn JS_SetDestroyCompartmentCallback(rt: *mut JSRuntime,
callback:
JSDestroyCompartmentCallback) {
_Z32JS_SetDestroyCompartmentCallbackP9JSRuntimePFvP8JSFreeOpP13JSCompartmentE(rt,
callback)
}
#[inline]
pub unsafe extern "C" fn JS_SetDestroyZoneCallback(rt: *mut JSRuntime,
callback: JSZoneCallback) {
_Z25JS_SetDestroyZoneCallbackP9JSRuntimePFvPN2JS4ZoneEE(rt, callback)
}
#[inline]
pub unsafe extern "C" fn JS_SetSweepZoneCallback(rt: *mut JSRuntime,
callback: JSZoneCallback) {
_Z23JS_SetSweepZoneCallbackP9JSRuntimePFvPN2JS4ZoneEE(rt, callback)
}
#[inline]
pub unsafe extern "C" fn JS_SetCompartmentNameCallback(rt: *mut JSRuntime,
callback:
JSCompartmentNameCallback) {
_Z29JS_SetCompartmentNameCallbackP9JSRuntimePFvS0_P13JSCompartmentPcjE(rt,
callback)
}
#[inline]
pub unsafe extern "C" fn JS_SetWrapObjectCallbacks(rt: *mut JSRuntime,
callbacks:
*const JSWrapObjectCallbacks) {
_Z25JS_SetWrapObjectCallbacksP9JSRuntimePK21JSWrapObjectCallbacks(rt,
callbacks)
}
#[inline]
pub unsafe extern "C" fn JS_SetCompartmentPrivate(compartment:
*mut JSCompartment,
data: *mut ::libc::c_void) {
_Z24JS_SetCompartmentPrivateP13JSCompartmentPv(compartment, data)
}
#[inline]
pub unsafe extern "C" fn JS_GetCompartmentPrivate(compartment:
*mut JSCompartment)
-> *mut ::libc::c_void {
_Z24JS_GetCompartmentPrivateP13JSCompartment(compartment)
}
#[inline]
pub unsafe extern "C" fn JS_SetZoneUserData(zone: *mut Zone,
data: *mut ::libc::c_void) {
_Z18JS_SetZoneUserDataPN2JS4ZoneEPv(zone, data)
}
#[inline]
pub unsafe extern "C" fn JS_GetZoneUserData(zone: *mut Zone)
-> *mut ::libc::c_void {
_Z18JS_GetZoneUserDataPN2JS4ZoneE(zone)
}
#[inline]
pub unsafe extern "C" fn JS_WrapObject(cx: *mut JSContext,
objp: MutableHandleObject) -> bool {
_Z13JS_WrapObjectP9JSContextN2JS13MutableHandleIP8JSObjectEE(cx, objp)
}
#[inline]
pub unsafe extern "C" fn JS_WrapValue(cx: *mut JSContext,
vp: MutableHandleValue) -> bool {
_Z12JS_WrapValueP9JSContextN2JS13MutableHandleINS1_5ValueEEE(cx, vp)
}
#[inline]
pub unsafe extern "C" fn JS_TransplantObject(cx: *mut JSContext,
origobj: HandleObject,
target: HandleObject)
-> *mut JSObject {
_Z19JS_TransplantObjectP9JSContextN2JS6HandleIP8JSObjectEES5_(cx, origobj,
target)
}
#[inline]
pub unsafe extern "C" fn JS_RefreshCrossCompartmentWrappers(cx:
*mut JSContext,
obj:
Handle<*mut JSObject>)
-> bool {
_Z34JS_RefreshCrossCompartmentWrappersP9JSContextN2JS6HandleIP8JSObjectEE(cx,
obj)
}
#[inline]
pub unsafe extern "C" fn JS_EnterCompartment(cx: *mut JSContext,
target: *mut JSObject)
-> *mut JSCompartment {
_Z19JS_EnterCompartmentP9JSContextP8JSObject(cx, target)
}
#[inline]
pub unsafe extern "C" fn JS_LeaveCompartment(cx: *mut JSContext,
oldCompartment:
*mut JSCompartment) {
_Z19JS_LeaveCompartmentP9JSContextP13JSCompartment(cx, oldCompartment)
}
#[inline]
pub unsafe extern "C" fn JS_IterateCompartments(rt: *mut JSRuntime,
data: *mut ::libc::c_void,
compartmentCallback:
JSIterateCompartmentCallback) {
_Z22JS_IterateCompartmentsP9JSRuntimePvPFvS0_S1_P13JSCompartmentE(rt,
data,
compartmentCallback)
}
#[inline]
pub unsafe extern "C" fn JS_InitStandardClasses(cx: *mut JSContext,
obj: Handle<*mut JSObject>)
-> bool {
_Z22JS_InitStandardClassesP9JSContextN2JS6HandleIP8JSObjectEE(cx, obj)
}
#[inline]
pub unsafe extern "C" fn JS_ResolveStandardClass(cx: *mut JSContext,
obj: HandleObject,
id: HandleId,
resolved: *mut bool)
-> bool {
_Z23JS_ResolveStandardClassP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEEPb(cx,
obj,
id,
resolved)
}
#[inline]
pub unsafe extern "C" fn JS_MayResolveStandardClass(names: &JSAtomState,
id: jsid,
maybeObj: *mut JSObject)
-> bool {
_Z26JS_MayResolveStandardClassRK11JSAtomState4jsidP8JSObject(names, id,
maybeObj)
}
#[inline]
pub unsafe extern "C" fn JS_EnumerateStandardClasses(cx: *mut JSContext,
obj: HandleObject)
-> bool {
_Z27JS_EnumerateStandardClassesP9JSContextN2JS6HandleIP8JSObjectEE(cx,
obj)
}
#[inline]
pub unsafe extern "C" fn JS_GetClassObject(cx: *mut JSContext,
key: JSProtoKey,
objp: MutableHandle<*mut JSObject>)
-> bool {
_Z17JS_GetClassObjectP9JSContext10JSProtoKeyN2JS13MutableHandleIP8JSObjectEE(cx,
key,
objp)
}
#[inline]
pub unsafe extern "C" fn JS_GetClassPrototype(cx: *mut JSContext,
key: JSProtoKey,
objp:
MutableHandle<*mut JSObject>)
-> bool {
_Z20JS_GetClassPrototypeP9JSContext10JSProtoKeyN2JS13MutableHandleIP8JSObjectEE(cx,
key,
objp)
}
#[inline]
pub unsafe extern "C" fn IdentifyStandardInstance(obj: *mut JSObject)
-> JSProtoKey {
_ZN2JS24IdentifyStandardInstanceEP8JSObject(obj)
}
#[inline]
pub unsafe extern "C" fn IdentifyStandardPrototype(obj: *mut JSObject)
-> JSProtoKey {
_ZN2JS25IdentifyStandardPrototypeEP8JSObject(obj)
}
#[inline]
pub unsafe extern "C" fn IdentifyStandardInstanceOrPrototype(obj:
*mut JSObject)
-> JSProtoKey {
_ZN2JS35IdentifyStandardInstanceOrPrototypeEP8JSObject(obj)
}
#[inline]
pub unsafe extern "C" fn IdentifyStandardConstructor(obj: *mut JSObject)
-> JSProtoKey {
_ZN2JS27IdentifyStandardConstructorEP8JSObject(obj)
}
#[inline]
pub unsafe extern "C" fn ProtoKeyToId(cx: *mut JSContext, key: JSProtoKey,
idp: MutableHandleId) {
_ZN2JS12ProtoKeyToIdEP9JSContext10JSProtoKeyNS_13MutableHandleI4jsidEE(cx,
key,
idp)
}
#[inline]
pub unsafe extern "C" fn JS_IdToProtoKey(cx: *mut JSContext, id: HandleId)
-> JSProtoKey {
_Z15JS_IdToProtoKeyP9JSContextN2JS6HandleI4jsidEE(cx, id)
}
#[inline]
pub unsafe extern "C" fn JS_GetFunctionPrototype(cx: *mut JSContext,
forObj: HandleObject)
-> *mut JSObject {
_Z23JS_GetFunctionPrototypeP9JSContextN2JS6HandleIP8JSObjectEE(cx, forObj)
}
#[inline]
pub unsafe extern "C" fn JS_GetObjectPrototype(cx: *mut JSContext,
forObj: HandleObject)
-> *mut JSObject {
_Z21JS_GetObjectPrototypeP9JSContextN2JS6HandleIP8JSObjectEE(cx, forObj)
}
#[inline]
pub unsafe extern "C" fn JS_GetArrayPrototype(cx: *mut JSContext,
forObj: HandleObject)
-> *mut JSObject {
_Z20JS_GetArrayPrototypeP9JSContextN2JS6HandleIP8JSObjectEE(cx, forObj)
}
#[inline]
pub unsafe extern "C" fn JS_GetErrorPrototype(cx: *mut JSContext)
-> *mut JSObject {
_Z20JS_GetErrorPrototypeP9JSContext(cx)
}
#[inline]
pub unsafe extern "C" fn JS_GetGlobalForObject(cx: *mut JSContext,
obj: *mut JSObject)
-> *mut JSObject {
_Z21JS_GetGlobalForObjectP9JSContextP8JSObject(cx, obj)
}
#[inline]
pub unsafe extern "C" fn JS_IsGlobalObject(obj: *mut JSObject) -> bool {
_Z17JS_IsGlobalObjectP8JSObject(obj)
}
#[inline]
pub unsafe extern "C" fn JS_GetGlobalForCompartmentOrNull(cx: *mut JSContext,
c:
*mut JSCompartment)
-> *mut JSObject {
_Z32JS_GetGlobalForCompartmentOrNullP9JSContextP13JSCompartment(cx, c)
}
#[inline]
pub unsafe extern "C" fn CurrentGlobalOrNull(cx: *mut JSContext)
-> *mut JSObject {
_ZN2JS19CurrentGlobalOrNullEP9JSContext(cx)
}
#[inline]
pub unsafe extern "C" fn JS_InitReflectParse(cx: *mut JSContext,
global: HandleObject) -> bool {
_Z19JS_InitReflectParseP9JSContextN2JS6HandleIP8JSObjectEE(cx, global)
}
#[inline]
pub unsafe extern "C" fn JS_DefineProfilingFunctions(cx: *mut JSContext,
obj: HandleObject)
-> bool {
_Z27JS_DefineProfilingFunctionsP9JSContextN2JS6HandleIP8JSObjectEE(cx,
obj)
}
#[inline]
pub unsafe extern "C" fn JS_DefineDebuggerObject(cx: *mut JSContext,
obj: HandleObject) -> bool {
_Z23JS_DefineDebuggerObjectP9JSContextN2JS6HandleIP8JSObjectEE(cx, obj)
}
#[inline]
pub unsafe extern "C" fn JS_InitCTypesClass(cx: *mut JSContext,
global: HandleObject) -> bool {
_Z18JS_InitCTypesClassP9JSContextN2JS6HandleIP8JSObjectEE(cx, global)
}
#[inline]
pub unsafe extern "C" fn JS_SetCTypesCallbacks(ctypesObj: *mut JSObject,
callbacks:
*const JSCTypesCallbacks) {
_Z21JS_SetCTypesCallbacksP8JSObjectPK17JSCTypesCallbacks(ctypesObj,
callbacks)
}
#[inline]
pub unsafe extern "C" fn JS_malloc(cx: *mut JSContext, nbytes: size_t)
-> *mut ::libc::c_void {
_Z9JS_mallocP9JSContextj(cx, nbytes)
}
#[inline]
pub unsafe extern "C" fn JS_realloc(cx: *mut JSContext,
p: *mut ::libc::c_void, oldBytes: size_t,
newBytes: size_t) -> *mut ::libc::c_void {
_Z10JS_reallocP9JSContextPvjj(cx, p, oldBytes, newBytes)
}
#[inline]
pub unsafe extern "C" fn JS_free(cx: *mut JSContext, p: *mut ::libc::c_void) {
_Z7JS_freeP9JSContextPv(cx, p)
}
#[inline]
pub unsafe extern "C" fn JS_freeop(fop: *mut JSFreeOp,
p: *mut ::libc::c_void) {
_Z9JS_freeopP8JSFreeOpPv(fop, p)
}
#[inline]
pub unsafe extern "C" fn JS_GetDefaultFreeOp(rt: *mut JSRuntime)
-> *mut JSFreeOp {
_Z19JS_GetDefaultFreeOpP9JSRuntime(rt)
}
#[inline]
pub unsafe extern "C" fn JS_updateMallocCounter(cx: *mut JSContext,
nbytes: size_t) {
_Z22JS_updateMallocCounterP9JSContextj(cx, nbytes)
}
#[inline]
pub unsafe extern "C" fn JS_strdup(cx: *mut JSContext,
s: *const ::libc::c_char)
-> *mut ::libc::c_char {
_Z9JS_strdupP9JSContextPKc(cx, s)
}
#[inline]
pub unsafe extern "C" fn JS_strdup1(rt: *mut JSRuntime,
s: *const ::libc::c_char)
-> *mut ::libc::c_char {
_Z9JS_strdupP9JSRuntimePKc(rt, s)
}
#[inline]
pub unsafe extern "C" fn JS_AddExtraGCRootsTracer(rt: *mut JSRuntime,
traceOp: JSTraceDataOp,
data: *mut ::libc::c_void)
-> bool {
_Z24JS_AddExtraGCRootsTracerP9JSRuntimePFvP8JSTracerPvES3_(rt, traceOp,
data)
}
#[inline]
pub unsafe extern "C" fn JS_RemoveExtraGCRootsTracer(rt: *mut JSRuntime,
traceOp: JSTraceDataOp,
data:
*mut ::libc::c_void) {
_Z27JS_RemoveExtraGCRootsTracerP9JSRuntimePFvP8JSTracerPvES3_(rt, traceOp,
data)
}
#[inline]
pub unsafe extern "C" fn JS_GC(rt: *mut JSRuntime) { _Z5JS_GCP9JSRuntime(rt) }
#[inline]
pub unsafe extern "C" fn JS_MaybeGC(cx: *mut JSContext) {
_Z10JS_MaybeGCP9JSContext(cx)
}
#[inline]
pub unsafe extern "C" fn JS_SetGCCallback(rt: *mut JSRuntime,
cb: JSGCCallback,
data: *mut ::libc::c_void) {
_Z16JS_SetGCCallbackP9JSRuntimePFvS0_10JSGCStatusPvES2_(rt, cb, data)
}
#[inline]
pub unsafe extern "C" fn JS_AddFinalizeCallback(rt: *mut JSRuntime,
cb: JSFinalizeCallback,
data: *mut ::libc::c_void)
-> bool {
_Z22JS_AddFinalizeCallbackP9JSRuntimePFvP8JSFreeOp16JSFinalizeStatusbPvES4_(rt,
cb,
data)
}
#[inline]
pub unsafe extern "C" fn JS_RemoveFinalizeCallback(rt: *mut JSRuntime,
cb: JSFinalizeCallback) {
_Z25JS_RemoveFinalizeCallbackP9JSRuntimePFvP8JSFreeOp16JSFinalizeStatusbPvE(rt,
cb)
}
#[inline]
pub unsafe extern "C" fn JS_AddWeakPointerCallback(rt: *mut JSRuntime,
cb: JSWeakPointerCallback,
data: *mut ::libc::c_void)
-> bool {
_Z25JS_AddWeakPointerCallbackP9JSRuntimePFvS0_PvES1_(rt, cb, data)
}
#[inline]
pub unsafe extern "C" fn JS_RemoveWeakPointerCallback(rt: *mut JSRuntime,
cb:
JSWeakPointerCallback) {
_Z28JS_RemoveWeakPointerCallbackP9JSRuntimePFvS0_PvE(rt, cb)
}
#[inline]
pub unsafe extern "C" fn JS_UpdateWeakPointerAfterGC(objp:
*mut Heap<*mut JSObject>) {
_Z27JS_UpdateWeakPointerAfterGCPN2JS4HeapIP8JSObjectEE(objp)
}
#[inline]
pub unsafe extern "C" fn JS_UpdateWeakPointerAfterGCUnbarriered(objp:
*mut *mut JSObject) {
_Z38JS_UpdateWeakPointerAfterGCUnbarrieredPP8JSObject(objp)
}
#[inline]
pub unsafe extern "C" fn JS_SetGCParameter(rt: *mut JSRuntime,
key: JSGCParamKey, value: u32) {
_Z17JS_SetGCParameterP9JSRuntime12JSGCParamKeyj(rt, key, value)
}
#[inline]
pub unsafe extern "C" fn JS_GetGCParameter(rt: *mut JSRuntime,
key: JSGCParamKey) -> u32 {
_Z17JS_GetGCParameterP9JSRuntime12JSGCParamKey(rt, key)
}
#[inline]
pub unsafe extern "C" fn JS_SetGCParameterForThread(cx: *mut JSContext,
key: JSGCParamKey,
value: u32) {
_Z26JS_SetGCParameterForThreadP9JSContext12JSGCParamKeyj(cx, key, value)
}
#[inline]
pub unsafe extern "C" fn JS_GetGCParameterForThread(cx: *mut JSContext,
key: JSGCParamKey)
-> u32 {
_Z26JS_GetGCParameterForThreadP9JSContext12JSGCParamKey(cx, key)
}
#[inline]
pub unsafe extern "C" fn JS_SetGCParametersBasedOnAvailableMemory(rt:
*mut JSRuntime,
availMem:
u32) {
_Z40JS_SetGCParametersBasedOnAvailableMemoryP9JSRuntimej(rt, availMem)
}
#[inline]
pub unsafe extern "C" fn JS_NewExternalString(cx: *mut JSContext,
chars: *const u16,
length: size_t,
fin: *const JSStringFinalizer)
-> *mut JSString {
_Z20JS_NewExternalStringP9JSContextPKDsjPK17JSStringFinalizer(cx, chars,
length, fin)
}
#[inline]
pub unsafe extern "C" fn JS_IsExternalString(str: *mut JSString) -> bool {
_Z19JS_IsExternalStringP8JSString(str)
}
#[inline]
pub unsafe extern "C" fn JS_GetExternalStringFinalizer(str: *mut JSString)
-> *const JSStringFinalizer {
_Z29JS_GetExternalStringFinalizerP8JSString(str)
}
#[inline]
pub unsafe extern "C" fn JS_SetNativeStackQuota(cx: *mut JSRuntime,
systemCodeStackSize: size_t,
trustedScriptStackSize:
size_t,
untrustedScriptStackSize:
size_t) {
_Z22JS_SetNativeStackQuotaP9JSRuntimejjj(cx, systemCodeStackSize,
trustedScriptStackSize,
untrustedScriptStackSize)
}
/************************************************************************/
#[inline]
pub unsafe extern "C" fn JS_IdArrayLength(cx: *mut JSContext,
ida: *mut JSIdArray) -> i32 {
_Z16JS_IdArrayLengthP9JSContextP9JSIdArray(cx, ida)
}
#[inline]
pub unsafe extern "C" fn JS_IdArrayGet(cx: *mut JSContext,
ida: *mut JSIdArray, index: u32)
-> jsid {
_Z13JS_IdArrayGetP9JSContextP9JSIdArrayj(cx, ida, index)
}
#[inline]
pub unsafe extern "C" fn JS_DestroyIdArray(cx: *mut JSContext,
ida: *mut JSIdArray) {
_Z17JS_DestroyIdArrayP9JSContextP9JSIdArray(cx, ida)
}
#[inline]
pub unsafe extern "C" fn JS_ValueToId(cx: *mut JSContext, v: HandleValue,
idp: MutableHandleId) -> bool {
_Z12JS_ValueToIdP9JSContextN2JS6HandleINS1_5ValueEEENS1_13MutableHandleI4jsidEE(cx,
v,
idp)
}
#[inline]
pub unsafe extern "C" fn JS_StringToId(cx: *mut JSContext, s: HandleString,
idp: MutableHandleId) -> bool {
_Z13JS_StringToIdP9JSContextN2JS6HandleIP8JSStringEENS1_13MutableHandleI4jsidEE(cx,
s,
idp)
}
#[inline]
pub unsafe extern "C" fn JS_IdToValue(cx: *mut JSContext, id: jsid,
vp: MutableHandle<Value>) -> bool {
_Z12JS_IdToValueP9JSContext4jsidN2JS13MutableHandleINS2_5ValueEEE(cx, id,
vp)
}
#[inline]
pub unsafe extern "C" fn JS_DefaultValue(cx: *mut JSContext,
obj: Handle<*mut JSObject>,
hint: JSType,
vp: MutableHandle<Value>) -> bool {
_Z15JS_DefaultValueP9JSContextN2JS6HandleIP8JSObjectEE6JSTypeNS1_13MutableHandleINS1_5ValueEEE(cx,
obj,
hint,
vp)
}
#[inline]
pub unsafe extern "C" fn JS_PropertyStub(cx: *mut JSContext,
obj: HandleObject, id: HandleId,
vp: MutableHandleValue) -> bool {
_Z15JS_PropertyStubP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEENS1_13MutableHandleINS1_5ValueEEE(cx,
obj,
id,
vp)
}
#[inline]
pub unsafe extern "C" fn JS_StrictPropertyStub(cx: *mut JSContext,
obj: HandleObject,
id: HandleId,
vp: MutableHandleValue,
result: &mut ObjectOpResult)
-> bool {
_Z21JS_StrictPropertyStubP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEENS1_13MutableHandleINS1_5ValueEEERNS1_14ObjectOpResultE(cx,
obj,
id,
vp,
result)
}
#[inline]
pub unsafe extern "C" fn CheckIsNative(native: JSNative) -> i32 {
_ZN2JS6detail13CheckIsNativeEPFbP9JSContextjPNS_5ValueEE(native)
}
#[inline]
pub unsafe extern "C" fn CheckIsGetterOp(op: JSGetterOp) -> i32 {
_ZN2JS6detail15CheckIsGetterOpEPFbP9JSContextNS_6HandleIP8JSObjectEENS3_I4jsidEENS_13MutableHandleINS_5ValueEEEE(op)
}
#[inline]
pub unsafe extern "C" fn CheckIsSetterOp(op: JSSetterOp) -> i32 {
_ZN2JS6detail15CheckIsSetterOpEPFbP9JSContextNS_6HandleIP8JSObjectEENS3_I4jsidEENS_13MutableHandleINS_5ValueEEERNS_14ObjectOpResultEE(op)
}
#[inline]
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)
}
#[inline]
pub unsafe extern "C" fn JS_LinkConstructorAndPrototype(cx: *mut JSContext,
ctor:
Handle<*mut JSObject>,
proto:
Handle<*mut JSObject>)
-> bool {
_Z30JS_LinkConstructorAndPrototypeP9JSContextN2JS6HandleIP8JSObjectEES5_(cx,
ctor,
proto)
}
#[inline]
pub unsafe extern "C" fn JS_GetClass(obj: *mut JSObject) -> *const JSClass {
_Z11JS_GetClassP8JSObject(obj)
}
#[inline]
pub unsafe extern "C" fn JS_InstanceOf(cx: *mut JSContext,
obj: Handle<*mut JSObject>,
clasp: *const JSClass,
args: *mut CallArgs) -> bool {
_Z13JS_InstanceOfP9JSContextN2JS6HandleIP8JSObjectEEPK7JSClassPNS1_8CallArgsE(cx,
obj,
clasp,
args)
}
#[inline]
pub unsafe extern "C" fn JS_HasInstance(cx: *mut JSContext,
obj: Handle<*mut JSObject>,
v: Handle<Value>, bp: *mut bool)
-> bool {
_Z14JS_HasInstanceP9JSContextN2JS6HandleIP8JSObjectEENS2_INS1_5ValueEEEPb(cx,
obj,
v,
bp)
}
#[inline]
pub unsafe extern "C" fn JS_GetPrivate(obj: *mut JSObject)
-> *mut ::libc::c_void {
_Z13JS_GetPrivateP8JSObject(obj)
}
#[inline]
pub unsafe extern "C" fn JS_SetPrivate(obj: *mut JSObject,
data: *mut ::libc::c_void) {
_Z13JS_SetPrivateP8JSObjectPv(obj, data)
}
#[inline]
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)
}
#[inline]
pub unsafe extern "C" fn JS_GetPrototype(cx: *mut JSContext,
obj: HandleObject,
protop: MutableHandleObject)
-> bool {
_Z15JS_GetPrototypeP9JSContextN2JS6HandleIP8JSObjectEENS1_13MutableHandleIS4_EE(cx,
obj,
protop)
}
#[inline]
pub unsafe extern "C" fn JS_SetPrototype(cx: *mut JSContext,
obj: HandleObject,
proto: HandleObject) -> bool {
_Z15JS_SetPrototypeP9JSContextN2JS6HandleIP8JSObjectEES5_(cx, obj, proto)
}
#[inline]
pub unsafe extern "C" fn JS_GetConstructor(cx: *mut JSContext,
proto: Handle<*mut JSObject>)
-> *mut JSObject {
_Z17JS_GetConstructorP9JSContextN2JS6HandleIP8JSObjectEE(cx, proto)
}
#[inline]
pub unsafe extern "C" fn CompartmentOptionsRef(compartment:
*mut JSCompartment)
-> *mut CompartmentOptions {
_ZN2JS21CompartmentOptionsRefEP13JSCompartment(compartment)
}
#[inline]
pub unsafe extern "C" fn CompartmentOptionsRef1(obj: *mut JSObject)
-> *mut CompartmentOptions {
_ZN2JS21CompartmentOptionsRefEP8JSObject(obj)
}
#[inline]
pub unsafe extern "C" fn CompartmentOptionsRef2(cx: *mut JSContext)
-> *mut CompartmentOptions {
_ZN2JS21CompartmentOptionsRefEP9JSContext(cx)
}
#[inline]
pub unsafe extern "C" fn JS_NewGlobalObject(cx: *mut JSContext,
clasp: *const JSClass,
principals: *mut JSPrincipals,
hookOption: OnNewGlobalHookOption,
options: &CompartmentOptions)
-> *mut JSObject {
_Z18JS_NewGlobalObjectP9JSContextPK7JSClassP12JSPrincipalsN2JS21OnNewGlobalHookOptionERKNS6_18CompartmentOptionsE(cx,
clasp,
principals,
hookOption,
options)
}
#[inline]
pub unsafe extern "C" fn JS_GlobalObjectTraceHook(trc: *mut JSTracer,
global: *mut JSObject) {
_Z24JS_GlobalObjectTraceHookP8JSTracerP8JSObject(trc, global)
}
#[inline]
pub unsafe extern "C" fn JS_FireOnNewGlobalObject(cx: *mut JSContext,
global: HandleObject) {
_Z24JS_FireOnNewGlobalObjectP9JSContextN2JS6HandleIP8JSObjectEE(cx,
global)
}
#[inline]
pub unsafe extern "C" fn JS_NewObject(cx: *mut JSContext,
clasp: *const JSClass)
-> *mut JSObject {
_Z12JS_NewObjectP9JSContextPK7JSClass(cx, clasp)
}
#[inline]
pub unsafe extern "C" fn JS_IsExtensible(cx: *mut JSContext,
obj: HandleObject,
extensible: *mut bool) -> bool {
_Z15JS_IsExtensibleP9JSContextN2JS6HandleIP8JSObjectEEPb(cx, obj,
extensible)
}
#[inline]
pub unsafe extern "C" fn JS_IsNative(obj: *mut JSObject) -> bool {
_Z11JS_IsNativeP8JSObject(obj)
}
#[inline]
pub unsafe extern "C" fn JS_GetObjectRuntime(obj: *mut JSObject)
-> *mut JSRuntime {
_Z19JS_GetObjectRuntimeP8JSObject(obj)
}
#[inline]
pub unsafe extern "C" fn JS_NewObjectWithGivenProto(cx: *mut JSContext,
clasp: *const JSClass,
proto:
Handle<*mut JSObject>)
-> *mut JSObject {
_Z26JS_NewObjectWithGivenProtoP9JSContextPK7JSClassN2JS6HandleIP8JSObjectEE(cx,
clasp,
proto)
}
#[inline]
pub unsafe extern "C" fn JS_NewPlainObject(cx: *mut JSContext)
-> *mut JSObject {
_Z17JS_NewPlainObjectP9JSContext(cx)
}
#[inline]
pub unsafe extern "C" fn JS_DeepFreezeObject(cx: *mut JSContext,
obj: Handle<*mut JSObject>)
-> bool {
_Z19JS_DeepFreezeObjectP9JSContextN2JS6HandleIP8JSObjectEE(cx, obj)
}
#[inline]
pub unsafe extern "C" fn JS_FreezeObject(cx: *mut JSContext,
obj: Handle<*mut JSObject>) -> bool {
_Z15JS_FreezeObjectP9JSContextN2JS6HandleIP8JSObjectEE(cx, obj)
}
#[inline]
pub unsafe extern "C" fn JS_PreventExtensions(cx: *mut JSContext,
obj: HandleObject,
result: &mut ObjectOpResult)
-> bool {
_Z20JS_PreventExtensionsP9JSContextN2JS6HandleIP8JSObjectEERNS1_14ObjectOpResultE(cx,
obj,
result)
}
#[inline]
pub unsafe extern "C" fn JS_New(cx: *mut JSContext, ctor: HandleObject,
args: &HandleValueArray) -> *mut JSObject {
_Z6JS_NewP9JSContextN2JS6HandleIP8JSObjectEERKNS1_16HandleValueArrayE(cx,
ctor,
args)
}
#[inline]
pub unsafe extern "C" fn ObjectToCompletePropertyDescriptor(cx:
*mut JSContext,
obj: HandleObject,
descriptor:
HandleValue,
desc:
MutableHandle<JSPropertyDescriptor>)
-> bool {
_ZN2JS34ObjectToCompletePropertyDescriptorEP9JSContextNS_6HandleIP8JSObjectEENS2_INS_5ValueEEENS_13MutableHandleI20JSPropertyDescriptorEE(cx,
obj,
descriptor,
desc)
}
/*** [[DefineOwnProperty]] and variations ********************************************************/
#[inline]
pub unsafe extern "C" fn JS_DefineProperty(cx: *mut JSContext,
obj: HandleObject,
name: *const ::libc::c_char,
value: HandleValue, attrs: u32,
getter: JSNative, setter: JSNative)
-> bool {
_Z17JS_DefinePropertyP9JSContextN2JS6HandleIP8JSObjectEEPKcNS2_INS1_5ValueEEEjPFbS0_jPS8_ESC_(cx,
obj,
name,
value,
attrs,
getter,
setter)
}
#[inline]
pub unsafe extern "C" fn JS_DefineProperty1(cx: *mut JSContext,
obj: HandleObject,
name: *const ::libc::c_char,
value: HandleObject, attrs: u32,
getter: JSNative,
setter: JSNative) -> bool {
_Z17JS_DefinePropertyP9JSContextN2JS6HandleIP8JSObjectEEPKcS5_jPFbS0_jPNS1_5ValueEESB_(cx,
obj,
name,
value,
attrs,
getter,
setter)
}
#[inline]
pub unsafe extern "C" fn JS_DefineProperty2(cx: *mut JSContext,
obj: HandleObject,
name: *const ::libc::c_char,
value: HandleString, attrs: u32,
getter: JSNative,
setter: JSNative) -> bool {
_Z17JS_DefinePropertyP9JSContextN2JS6HandleIP8JSObjectEEPKcNS2_IP8JSStringEEjPFbS0_jPNS1_5ValueEESE_(cx,
obj,
name,
value,
attrs,
getter,
setter)
}
#[inline]
pub unsafe extern "C" fn JS_DefineProperty3(cx: *mut JSContext,
obj: HandleObject,
name: *const ::libc::c_char,
value: i32, attrs: u32,
getter: JSNative,
setter: JSNative) -> bool {
_Z17JS_DefinePropertyP9JSContextN2JS6HandleIP8JSObjectEEPKcijPFbS0_jPNS1_5ValueEESB_(cx,
obj,
name,
value,
attrs,
getter,
setter)
}
#[inline]
pub unsafe extern "C" fn JS_DefineProperty4(cx: *mut JSContext,
obj: HandleObject,
name: *const ::libc::c_char,
value: u32, attrs: u32,
getter: JSNative,
setter: JSNative) -> bool {
_Z17JS_DefinePropertyP9JSContextN2JS6HandleIP8JSObjectEEPKcjjPFbS0_jPNS1_5ValueEESB_(cx,
obj,
name,
value,
attrs,
getter,
setter)
}
#[inline]
pub unsafe extern "C" fn JS_DefineProperty5(cx: *mut JSContext,
obj: HandleObject,
name: *const ::libc::c_char,
value: f64, attrs: u32,
getter: JSNative,
setter: JSNative) -> bool {
_Z17JS_DefinePropertyP9JSContextN2JS6HandleIP8JSObjectEEPKcdjPFbS0_jPNS1_5ValueEESB_(cx,
obj,
name,
value,
attrs,
getter,
setter)
}
#[inline]
pub unsafe extern "C" fn JS_DefinePropertyById(cx: *mut JSContext,
obj: HandleObject,
id: HandleId,
value: HandleValue, attrs: u32,
getter: JSNative,
setter: JSNative) -> bool {
_Z21JS_DefinePropertyByIdP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEENS2_INS1_5ValueEEEjPFbS0_jPS8_ESC_(cx,
obj,
id,
value,
attrs,
getter,
setter)
}
#[inline]
pub unsafe extern "C" fn JS_DefinePropertyById1(cx: *mut JSContext,
obj: HandleObject,
id: HandleId,
value: HandleObject,
attrs: u32, getter: JSNative,
setter: JSNative) -> bool {
_Z21JS_DefinePropertyByIdP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEES5_jPFbS0_jPNS1_5ValueEESB_(cx,
obj,
id,
value,
attrs,
getter,
setter)
}
#[inline]
pub unsafe extern "C" fn JS_DefinePropertyById2(cx: *mut JSContext,
obj: HandleObject,
id: HandleId,
value: HandleString,
attrs: u32, getter: JSNative,
setter: JSNative) -> bool {
_Z21JS_DefinePropertyByIdP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEENS2_IP8JSStringEEjPFbS0_jPNS1_5ValueEESE_(cx,
obj,
id,
value,
attrs,
getter,
setter)
}
#[inline]
pub unsafe extern "C" fn JS_DefinePropertyById3(cx: *mut JSContext,
obj: HandleObject,
id: HandleId, value: i32,
attrs: u32, getter: JSNative,
setter: JSNative) -> bool {
_Z21JS_DefinePropertyByIdP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEEijPFbS0_jPNS1_5ValueEESB_(cx,
obj,
id,
value,
attrs,
getter,
setter)
}
#[inline]
pub unsafe extern "C" fn JS_DefinePropertyById4(cx: *mut JSContext,
obj: HandleObject,
id: HandleId, value: u32,
attrs: u32, getter: JSNative,
setter: JSNative) -> bool {
_Z21JS_DefinePropertyByIdP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEEjjPFbS0_jPNS1_5ValueEESB_(cx,
obj,
id,
value,
attrs,
getter,
setter)
}
#[inline]
pub unsafe extern "C" fn JS_DefinePropertyById5(cx: *mut JSContext,
obj: HandleObject,
id: HandleId, value: f64,
attrs: u32, getter: JSNative,
setter: JSNative) -> bool {
_Z21JS_DefinePropertyByIdP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEEdjPFbS0_jPNS1_5ValueEESB_(cx,
obj,
id,
value,
attrs,
getter,
setter)
}
#[inline]
pub unsafe extern "C" fn JS_DefinePropertyById6(cx: *mut JSContext,
obj: HandleObject,
id: HandleId,
desc:
Handle<JSPropertyDescriptor>,
result: &mut ObjectOpResult)
-> bool {
_Z21JS_DefinePropertyByIdP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEENS2_I20JSPropertyDescriptorEERNS1_14ObjectOpResultE(cx,
obj,
id,
desc,
result)
}
#[inline]
pub unsafe extern "C" fn JS_DefinePropertyById7(cx: *mut JSContext,
obj: HandleObject,
id: HandleId,
desc:
Handle<JSPropertyDescriptor>)
-> bool {
_Z21JS_DefinePropertyByIdP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEENS2_I20JSPropertyDescriptorEE(cx,
obj,
id,
desc)
}
#[inline]
pub unsafe extern "C" fn JS_DefineObject(cx: *mut JSContext,
obj: HandleObject,
name: *const ::libc::c_char,
clasp: *const JSClass, attrs: u32)
-> *mut JSObject {
_Z15JS_DefineObjectP9JSContextN2JS6HandleIP8JSObjectEEPKcPK7JSClassj(cx,
obj,
name,
clasp,
attrs)
}
#[inline]
pub unsafe extern "C" fn JS_DefineConstDoubles(cx: *mut JSContext,
obj: HandleObject,
cds: *const JSConstDoubleSpec)
-> bool {
_Z21JS_DefineConstDoublesP9JSContextN2JS6HandleIP8JSObjectEEPK17JSConstScalarSpecIdE(cx,
obj,
cds)
}
#[inline]
pub unsafe extern "C" fn JS_DefineConstIntegers(cx: *mut JSContext,
obj: HandleObject,
cis:
*const JSConstIntegerSpec)
-> bool {
_Z22JS_DefineConstIntegersP9JSContextN2JS6HandleIP8JSObjectEEPK17JSConstScalarSpecIiE(cx,
obj,
cis)
}
#[inline]
pub unsafe extern "C" fn JS_DefineProperties(cx: *mut JSContext,
obj: HandleObject,
ps: *const JSPropertySpec)
-> bool {
_Z19JS_DefinePropertiesP9JSContextN2JS6HandleIP8JSObjectEEPK14JSPropertySpec(cx,
obj,
ps)
}
#[inline]
pub unsafe extern "C" fn JS_AlreadyHasOwnProperty(cx: *mut JSContext,
obj: HandleObject,
name: *const ::libc::c_char,
foundp: *mut bool) -> bool {
_Z24JS_AlreadyHasOwnPropertyP9JSContextN2JS6HandleIP8JSObjectEEPKcPb(cx,
obj,
name,
foundp)
}
#[inline]
pub unsafe extern "C" fn JS_AlreadyHasOwnPropertyById(cx: *mut JSContext,
obj: HandleObject,
id: HandleId,
foundp: *mut bool)
-> bool {
_Z28JS_AlreadyHasOwnPropertyByIdP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEEPb(cx,
obj,
id,
foundp)
}
#[inline]
pub unsafe extern "C" fn JS_HasProperty(cx: *mut JSContext, obj: HandleObject,
name: *const ::libc::c_char,
foundp: *mut bool) -> bool {
_Z14JS_HasPropertyP9JSContextN2JS6HandleIP8JSObjectEEPKcPb(cx, obj, name,
foundp)
}
#[inline]
pub unsafe extern "C" fn JS_HasPropertyById(cx: *mut JSContext,
obj: HandleObject, id: HandleId,
foundp: *mut bool) -> bool {
_Z18JS_HasPropertyByIdP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEEPb(cx,
obj,
id,
foundp)
}
#[inline]
pub unsafe extern "C" fn JS_GetOwnPropertyDescriptorById(cx: *mut JSContext,
obj: HandleObject,
id: HandleId,
desc:
MutableHandle<JSPropertyDescriptor>)
-> bool {
_Z31JS_GetOwnPropertyDescriptorByIdP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEENS1_13MutableHandleI20JSPropertyDescriptorEE(cx,
obj,
id,
desc)
}
#[inline]
pub unsafe extern "C" fn JS_GetOwnPropertyDescriptor(cx: *mut JSContext,
obj: HandleObject,
name:
*const ::libc::c_char,
desc:
MutableHandle<JSPropertyDescriptor>)
-> bool {
_Z27JS_GetOwnPropertyDescriptorP9JSContextN2JS6HandleIP8JSObjectEEPKcNS1_13MutableHandleI20JSPropertyDescriptorEE(cx,
obj,
name,
desc)
}
#[inline]
pub unsafe extern "C" fn JS_GetOwnUCPropertyDescriptor(cx: *mut JSContext,
obj: HandleObject,
name: *const u16,
desc:
MutableHandle<JSPropertyDescriptor>)
-> bool {
_Z29JS_GetOwnUCPropertyDescriptorP9JSContextN2JS6HandleIP8JSObjectEEPKDsNS1_13MutableHandleI20JSPropertyDescriptorEE(cx,
obj,
name,
desc)
}
#[inline]
pub unsafe extern "C" fn JS_HasOwnPropertyById(cx: *mut JSContext,
obj: HandleObject,
id: HandleId,
foundp: *mut bool) -> bool {
_Z21JS_HasOwnPropertyByIdP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEEPb(cx,
obj,
id,
foundp)
}
#[inline]
pub unsafe extern "C" fn JS_HasOwnProperty(cx: *mut JSContext,
obj: HandleObject,
name: *const ::libc::c_char,
foundp: *mut bool) -> bool {
_Z17JS_HasOwnPropertyP9JSContextN2JS6HandleIP8JSObjectEEPKcPb(cx, obj,
name,
foundp)
}
#[inline]
pub unsafe extern "C" fn JS_GetPropertyDescriptorById(cx: *mut JSContext,
obj: HandleObject,
id: HandleId,
desc:
MutableHandle<JSPropertyDescriptor>)
-> bool {
_Z28JS_GetPropertyDescriptorByIdP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEENS1_13MutableHandleI20JSPropertyDescriptorEE(cx,
obj,
id,
desc)
}
#[inline]
pub unsafe extern "C" fn JS_GetPropertyDescriptor(cx: *mut JSContext,
obj: HandleObject,
name: *const ::libc::c_char,
desc:
MutableHandle<JSPropertyDescriptor>)
-> bool {
_Z24JS_GetPropertyDescriptorP9JSContextN2JS6HandleIP8JSObjectEEPKcNS1_13MutableHandleI20JSPropertyDescriptorEE(cx,
obj,
name,
desc)
}
#[inline]
pub unsafe extern "C" fn JS_GetProperty(cx: *mut JSContext, obj: HandleObject,
name: *const ::libc::c_char,
vp: MutableHandleValue) -> bool {
_Z14JS_GetPropertyP9JSContextN2JS6HandleIP8JSObjectEEPKcNS1_13MutableHandleINS1_5ValueEEE(cx,
obj,
name,
vp)
}
#[inline]
pub unsafe extern "C" fn JS_GetPropertyById(cx: *mut JSContext,
obj: HandleObject, id: HandleId,
vp: MutableHandleValue) -> bool {
_Z18JS_GetPropertyByIdP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEENS1_13MutableHandleINS1_5ValueEEE(cx,
obj,
id,
vp)
}
#[inline]
pub unsafe extern "C" fn JS_ForwardGetPropertyTo(cx: *mut JSContext,
obj: HandleObject,
id: HandleId,
onBehalfOf: HandleObject,
vp: MutableHandleValue)
-> bool {
_Z23JS_ForwardGetPropertyToP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEES5_NS1_13MutableHandleINS1_5ValueEEE(cx,
obj,
id,
onBehalfOf,
vp)
}
#[inline]
pub unsafe extern "C" fn JS_SetProperty(cx: *mut JSContext, obj: HandleObject,
name: *const ::libc::c_char,
v: HandleValue) -> bool {
_Z14JS_SetPropertyP9JSContextN2JS6HandleIP8JSObjectEEPKcNS2_INS1_5ValueEEE(cx,
obj,
name,
v)
}
#[inline]
pub unsafe extern "C" fn JS_SetPropertyById(cx: *mut JSContext,
obj: HandleObject, id: HandleId,
v: HandleValue) -> bool {
_Z18JS_SetPropertyByIdP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEENS2_INS1_5ValueEEE(cx,
obj,
id,
v)
}
#[inline]
pub unsafe extern "C" fn JS_ForwardSetPropertyTo(cx: *mut JSContext,
obj: HandleObject,
id: HandleId, v: HandleValue,
receiver: HandleValue,
result: &mut ObjectOpResult)
-> bool {
_Z23JS_ForwardSetPropertyToP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEENS2_INS1_5ValueEEES9_RNS1_14ObjectOpResultE(cx,
obj,
id,
v,
receiver,
result)
}
#[inline]
pub unsafe extern "C" fn JS_DeleteProperty(cx: *mut JSContext,
obj: HandleObject,
name: *const ::libc::c_char)
-> bool {
_Z17JS_DeletePropertyP9JSContextN2JS6HandleIP8JSObjectEEPKc(cx, obj, name)
}
#[inline]
pub unsafe extern "C" fn JS_DeleteProperty1(cx: *mut JSContext,
obj: HandleObject,
name: *const ::libc::c_char,
result: &mut ObjectOpResult)
-> bool {
_Z17JS_DeletePropertyP9JSContextN2JS6HandleIP8JSObjectEEPKcRNS1_14ObjectOpResultE(cx,
obj,
name,
result)
}
#[inline]
pub unsafe extern "C" fn JS_DeletePropertyById(cx: *mut JSContext,
obj: HandleObject, id: jsid)
-> bool {
_Z21JS_DeletePropertyByIdP9JSContextN2JS6HandleIP8JSObjectEE4jsid(cx, obj,
id)
}
#[inline]
pub unsafe extern "C" fn JS_DeletePropertyById1(cx: *mut JSContext,
obj: HandleObject,
id: HandleId,
result: &mut ObjectOpResult)
-> bool {
_Z21JS_DeletePropertyByIdP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEERNS1_14ObjectOpResultE(cx,
obj,
id,
result)
}
#[inline]
pub unsafe extern "C" fn JS_DefineUCProperty(cx: *mut JSContext,
obj: HandleObject,
name: *const u16,
namelen: size_t,
value: HandleValue, attrs: u32,
getter: JSNative,
setter: JSNative) -> bool {
_Z19JS_DefineUCPropertyP9JSContextN2JS6HandleIP8JSObjectEEPKDsjNS2_INS1_5ValueEEEjPFbS0_jPS8_ESC_(cx,
obj,
name,
namelen,
value,
attrs,
getter,
setter)
}
#[inline]
pub unsafe extern "C" fn JS_DefineUCProperty1(cx: *mut JSContext,
obj: HandleObject,
name: *const u16,
namelen: size_t,
value: HandleObject, attrs: u32,
getter: JSNative,
setter: JSNative) -> bool {
_Z19JS_DefineUCPropertyP9JSContextN2JS6HandleIP8JSObjectEEPKDsjS5_jPFbS0_jPNS1_5ValueEESB_(cx,
obj,
name,
namelen,
value,
attrs,
getter,
setter)
}
#[inline]
pub unsafe extern "C" fn JS_DefineUCProperty2(cx: *mut JSContext,
obj: HandleObject,
name: *const u16,
namelen: size_t,
value: HandleString, attrs: u32,
getter: JSNative,
setter: JSNative) -> bool {
_Z19JS_DefineUCPropertyP9JSContextN2JS6HandleIP8JSObjectEEPKDsjNS2_IP8JSStringEEjPFbS0_jPNS1_5ValueEESE_(cx,
obj,
name,
namelen,
value,
attrs,
getter,
setter)
}
#[inline]
pub unsafe extern "C" fn JS_DefineUCProperty3(cx: *mut JSContext,
obj: HandleObject,
name: *const u16,
namelen: size_t, value: i32,
attrs: u32, getter: JSNative,
setter: JSNative) -> bool {
_Z19JS_DefineUCPropertyP9JSContextN2JS6HandleIP8JSObjectEEPKDsjijPFbS0_jPNS1_5ValueEESB_(cx,
obj,
name,
namelen,
value,
attrs,
getter,
setter)
}
#[inline]
pub unsafe extern "C" fn JS_DefineUCProperty4(cx: *mut JSContext,
obj: HandleObject,
name: *const u16,
namelen: size_t, value: u32,
attrs: u32, getter: JSNative,
setter: JSNative) -> bool {
_Z19JS_DefineUCPropertyP9JSContextN2JS6HandleIP8JSObjectEEPKDsjjjPFbS0_jPNS1_5ValueEESB_(cx,
obj,
name,
namelen,
value,
attrs,
getter,
setter)
}
#[inline]
pub unsafe extern "C" fn JS_DefineUCProperty5(cx: *mut JSContext,
obj: HandleObject,
name: *const u16,
namelen: size_t, value: f64,
attrs: u32, getter: JSNative,
setter: JSNative) -> bool {
_Z19JS_DefineUCPropertyP9JSContextN2JS6HandleIP8JSObjectEEPKDsjdjPFbS0_jPNS1_5ValueEESB_(cx,
obj,
name,
namelen,
value,
attrs,
getter,
setter)
}
#[inline]
pub unsafe extern "C" fn JS_DefineUCProperty6(cx: *mut JSContext,
obj: HandleObject,
name: *const u16,
namelen: size_t,
desc:
Handle<JSPropertyDescriptor>,
result: &mut ObjectOpResult)
-> bool {
_Z19JS_DefineUCPropertyP9JSContextN2JS6HandleIP8JSObjectEEPKDsjNS2_I20JSPropertyDescriptorEERNS1_14ObjectOpResultE(cx,
obj,
name,
namelen,
desc,
result)
}
#[inline]
pub unsafe extern "C" fn JS_DefineUCProperty7(cx: *mut JSContext,
obj: HandleObject,
name: *const u16,
namelen: size_t,
desc:
Handle<JSPropertyDescriptor>)
-> bool {
_Z19JS_DefineUCPropertyP9JSContextN2JS6HandleIP8JSObjectEEPKDsjNS2_I20JSPropertyDescriptorEE(cx,
obj,
name,
namelen,
desc)
}
#[inline]
pub unsafe extern "C" fn JS_AlreadyHasOwnUCProperty(cx: *mut JSContext,
obj: HandleObject,
name: *const u16,
namelen: size_t,
foundp: *mut bool)
-> bool {
_Z26JS_AlreadyHasOwnUCPropertyP9JSContextN2JS6HandleIP8JSObjectEEPKDsjPb(cx,
obj,
name,
namelen,
foundp)
}
#[inline]
pub unsafe extern "C" fn JS_HasUCProperty(cx: *mut JSContext,
obj: HandleObject, name: *const u16,
namelen: size_t, vp: *mut bool)
-> bool {
_Z16JS_HasUCPropertyP9JSContextN2JS6HandleIP8JSObjectEEPKDsjPb(cx, obj,
name,
namelen,
vp)
}
#[inline]
pub unsafe extern "C" fn JS_GetUCProperty(cx: *mut JSContext,
obj: HandleObject, name: *const u16,
namelen: size_t,
vp: MutableHandleValue) -> bool {
_Z16JS_GetUCPropertyP9JSContextN2JS6HandleIP8JSObjectEEPKDsjNS1_13MutableHandleINS1_5ValueEEE(cx,
obj,
name,
namelen,
vp)
}
#[inline]
pub unsafe extern "C" fn JS_SetUCProperty(cx: *mut JSContext,
obj: HandleObject, name: *const u16,
namelen: size_t, v: HandleValue)
-> bool {
_Z16JS_SetUCPropertyP9JSContextN2JS6HandleIP8JSObjectEEPKDsjNS2_INS1_5ValueEEE(cx,
obj,
name,
namelen,
v)
}
#[inline]
pub unsafe extern "C" fn JS_DeleteUCProperty(cx: *mut JSContext,
obj: HandleObject,
name: *const u16,
namelen: size_t,
result: &mut ObjectOpResult)
-> bool {
_Z19JS_DeleteUCPropertyP9JSContextN2JS6HandleIP8JSObjectEEPKDsjRNS1_14ObjectOpResultE(cx,
obj,
name,
namelen,
result)
}
#[inline]
pub unsafe extern "C" fn JS_NewArrayObject(cx: *mut JSContext,
contents: &HandleValueArray)
-> *mut JSObject {
_Z17JS_NewArrayObjectP9JSContextRKN2JS16HandleValueArrayE(cx, contents)
}
#[inline]
pub unsafe extern "C" fn JS_NewArrayObject1(cx: *mut JSContext,
length: size_t) -> *mut JSObject {
_Z17JS_NewArrayObjectP9JSContextj(cx, length)
}
#[inline]
pub unsafe extern "C" fn JS_IsArrayObject(cx: *mut JSContext,
value: HandleValue) -> bool {
_Z16JS_IsArrayObjectP9JSContextN2JS6HandleINS1_5ValueEEE(cx, value)
}
#[inline]
pub unsafe extern "C" fn JS_IsArrayObject1(cx: *mut JSContext,
obj: HandleObject) -> bool {
_Z16JS_IsArrayObjectP9JSContextN2JS6HandleIP8JSObjectEE(cx, obj)
}
#[inline]
pub unsafe extern "C" fn JS_GetArrayLength(cx: *mut JSContext,
obj: Handle<*mut JSObject>,
lengthp: *mut u32) -> bool {
_Z17JS_GetArrayLengthP9JSContextN2JS6HandleIP8JSObjectEEPj(cx, obj,
lengthp)
}
#[inline]
pub unsafe extern "C" fn JS_SetArrayLength(cx: *mut JSContext,
obj: Handle<*mut JSObject>,
length: u32) -> bool {
_Z17JS_SetArrayLengthP9JSContextN2JS6HandleIP8JSObjectEEj(cx, obj, length)
}
#[inline]
pub unsafe extern "C" fn JS_DefineElement(cx: *mut JSContext,
obj: HandleObject, index: u32,
value: HandleValue, attrs: u32,
getter: JSNative, setter: JSNative)
-> bool {
_Z16JS_DefineElementP9JSContextN2JS6HandleIP8JSObjectEEjNS2_INS1_5ValueEEEjPFbS0_jPS6_ESA_(cx,
obj,
index,
value,
attrs,
getter,
setter)
}
#[inline]
pub unsafe extern "C" fn JS_DefineElement1(cx: *mut JSContext,
obj: HandleObject, index: u32,
value: HandleObject, attrs: u32,
getter: JSNative, setter: JSNative)
-> bool {
_Z16JS_DefineElementP9JSContextN2JS6HandleIP8JSObjectEEjS5_jPFbS0_jPNS1_5ValueEES9_(cx,
obj,
index,
value,
attrs,
getter,
setter)
}
#[inline]
pub unsafe extern "C" fn JS_DefineElement2(cx: *mut JSContext,
obj: HandleObject, index: u32,
value: HandleString, attrs: u32,
getter: JSNative, setter: JSNative)
-> bool {
_Z16JS_DefineElementP9JSContextN2JS6HandleIP8JSObjectEEjNS2_IP8JSStringEEjPFbS0_jPNS1_5ValueEESC_(cx,
obj,
index,
value,
attrs,
getter,
setter)
}
#[inline]
pub unsafe extern "C" fn JS_DefineElement3(cx: *mut JSContext,
obj: HandleObject, index: u32,
value: i32, attrs: u32,
getter: JSNative, setter: JSNative)
-> bool {
_Z16JS_DefineElementP9JSContextN2JS6HandleIP8JSObjectEEjijPFbS0_jPNS1_5ValueEES9_(cx,
obj,
index,
value,
attrs,
getter,
setter)
}
#[inline]
pub unsafe extern "C" fn JS_DefineElement4(cx: *mut JSContext,
obj: HandleObject, index: u32,
value: u32, attrs: u32,
getter: JSNative, setter: JSNative)
-> bool {
_Z16JS_DefineElementP9JSContextN2JS6HandleIP8JSObjectEEjjjPFbS0_jPNS1_5ValueEES9_(cx,
obj,
index,
value,
attrs,
getter,
setter)
}
#[inline]
pub unsafe extern "C" fn JS_DefineElement5(cx: *mut JSContext,
obj: HandleObject, index: u32,
value: f64, attrs: u32,
getter: JSNative, setter: JSNative)
-> bool {
_Z16JS_DefineElementP9JSContextN2JS6HandleIP8JSObjectEEjdjPFbS0_jPNS1_5ValueEES9_(cx,
obj,
index,
value,
attrs,
getter,
setter)
}
#[inline]
pub unsafe extern "C" fn JS_AlreadyHasOwnElement(cx: *mut JSContext,
obj: HandleObject,
index: u32,
foundp: *mut bool) -> bool {
_Z23JS_AlreadyHasOwnElementP9JSContextN2JS6HandleIP8JSObjectEEjPb(cx, obj,
index,
foundp)
}
#[inline]
pub unsafe extern "C" fn JS_HasElement(cx: *mut JSContext, obj: HandleObject,
index: u32, foundp: *mut bool)
-> bool {
_Z13JS_HasElementP9JSContextN2JS6HandleIP8JSObjectEEjPb(cx, obj, index,
foundp)
}
#[inline]
pub unsafe extern "C" fn JS_GetElement(cx: *mut JSContext, obj: HandleObject,
index: u32, vp: MutableHandleValue)
-> bool {
_Z13JS_GetElementP9JSContextN2JS6HandleIP8JSObjectEEjNS1_13MutableHandleINS1_5ValueEEE(cx,
obj,
index,
vp)
}
#[inline]
pub unsafe extern "C" fn JS_ForwardGetElementTo(cx: *mut JSContext,
obj: HandleObject, index: u32,
onBehalfOf: HandleObject,
vp: MutableHandleValue)
-> bool {
_Z22JS_ForwardGetElementToP9JSContextN2JS6HandleIP8JSObjectEEjS5_NS1_13MutableHandleINS1_5ValueEEE(cx,
obj,
index,
onBehalfOf,
vp)
}
#[inline]
pub unsafe extern "C" fn JS_SetElement(cx: *mut JSContext, obj: HandleObject,
index: u32, v: HandleValue) -> bool {
_Z13JS_SetElementP9JSContextN2JS6HandleIP8JSObjectEEjNS2_INS1_5ValueEEE(cx,
obj,
index,
v)
}
#[inline]
pub unsafe extern "C" fn JS_SetElement1(cx: *mut JSContext, obj: HandleObject,
index: u32, v: HandleObject) -> bool {
_Z13JS_SetElementP9JSContextN2JS6HandleIP8JSObjectEEjS5_(cx, obj, index,
v)
}
#[inline]
pub unsafe extern "C" fn JS_SetElement2(cx: *mut JSContext, obj: HandleObject,
index: u32, v: HandleString) -> bool {
_Z13JS_SetElementP9JSContextN2JS6HandleIP8JSObjectEEjNS2_IP8JSStringEE(cx,
obj,
index,
v)
}
#[inline]
pub unsafe extern "C" fn JS_SetElement3(cx: *mut JSContext, obj: HandleObject,
index: u32, v: i32) -> bool {
_Z13JS_SetElementP9JSContextN2JS6HandleIP8JSObjectEEji(cx, obj, index, v)
}
#[inline]
pub unsafe extern "C" fn JS_SetElement4(cx: *mut JSContext, obj: HandleObject,
index: u32, v: u32) -> bool {
_Z13JS_SetElementP9JSContextN2JS6HandleIP8JSObjectEEjj(cx, obj, index, v)
}
#[inline]
pub unsafe extern "C" fn JS_SetElement5(cx: *mut JSContext, obj: HandleObject,
index: u32, v: f64) -> bool {
_Z13JS_SetElementP9JSContextN2JS6HandleIP8JSObjectEEjd(cx, obj, index, v)
}
#[inline]
pub unsafe extern "C" fn JS_DeleteElement(cx: *mut JSContext,
obj: HandleObject, index: u32)
-> bool {
_Z16JS_DeleteElementP9JSContextN2JS6HandleIP8JSObjectEEj(cx, obj, index)
}
#[inline]
pub unsafe extern "C" fn JS_DeleteElement1(cx: *mut JSContext,
obj: HandleObject, index: u32,
result: &mut ObjectOpResult)
-> bool {
_Z16JS_DeleteElementP9JSContextN2JS6HandleIP8JSObjectEEjRNS1_14ObjectOpResultE(cx,
obj,
index,
result)
}
#[inline]
pub unsafe extern "C" fn JS_SetAllNonReservedSlotsToUndefined(cx:
*mut JSContext,
objArg:
*mut JSObject) {
_Z36JS_SetAllNonReservedSlotsToUndefinedP9JSContextP8JSObject(cx, objArg)
}
#[inline]
pub unsafe extern "C" fn JS_NewArrayBufferWithContents(cx: *mut JSContext,
nbytes: size_t,
contents:
*mut ::libc::c_void)
-> *mut JSObject {
_Z29JS_NewArrayBufferWithContentsP9JSContextjPv(cx, nbytes, contents)
}
#[inline]
pub unsafe extern "C" fn JS_StealArrayBufferContents(cx: *mut JSContext,
obj: HandleObject)
-> *mut ::libc::c_void {
_Z27JS_StealArrayBufferContentsP9JSContextN2JS6HandleIP8JSObjectEE(cx,
obj)
}
#[inline]
pub unsafe extern "C" fn JS_NewMappedArrayBufferWithContents(cx:
*mut JSContext,
nbytes: size_t,
contents:
*mut ::libc::c_void)
-> *mut JSObject {
_Z35JS_NewMappedArrayBufferWithContentsP9JSContextjPv(cx, nbytes,
contents)
}
#[inline]
pub unsafe extern "C" fn JS_CreateMappedArrayBufferContents(fd: i32,
offset: size_t,
length: size_t)
-> *mut ::libc::c_void {
_Z34JS_CreateMappedArrayBufferContentsijj(fd, offset, length)
}
#[inline]
pub unsafe extern "C" fn JS_ReleaseMappedArrayBufferContents(contents:
*mut ::libc::c_void,
length: size_t) {
_Z35JS_ReleaseMappedArrayBufferContentsPvj(contents, length)
}
#[inline]
pub unsafe extern "C" fn JS_Enumerate(cx: *mut JSContext, obj: HandleObject)
-> *mut JSIdArray {
_Z12JS_EnumerateP9JSContextN2JS6HandleIP8JSObjectEE(cx, obj)
}
#[inline]
pub unsafe extern "C" fn JS_GetReservedSlot(obj: *mut JSObject, index: u32)
-> Value {
_Z18JS_GetReservedSlotP8JSObjectj(obj, index)
}
#[inline]
pub unsafe extern "C" fn JS_SetReservedSlot(obj: *mut JSObject, index: u32,
v: Value) {
_Z18JS_SetReservedSlotP8JSObjectjN2JS5ValueE(obj, index, v)
}
/************************************************************************/
#[inline]
pub unsafe extern "C" fn JS_NewFunction(cx: *mut JSContext, call: JSNative,
nargs: u32, flags: u32,
name: *const ::libc::c_char)
-> *mut JSFunction {
_Z14JS_NewFunctionP9JSContextPFbS0_jPN2JS5ValueEEjjPKc(cx, call, nargs,
flags, name)
}
#[inline]
pub unsafe extern "C" fn JS_NewFunctionById(cx: *mut JSContext,
call: JSNative, nargs: u32,
flags: u32, id: Handle<jsid>)
-> *mut JSFunction {
_Z18JS_NewFunctionByIdP9JSContextPFbS0_jPN2JS5ValueEEjjNS1_6HandleI4jsidEE(cx,
call,
nargs,
flags,
id)
}
#[inline]
pub unsafe extern "C" fn GetSelfHostedFunction(cx: *mut JSContext,
selfHostedName:
*const ::libc::c_char,
id: Handle<jsid>, nargs: u32)
-> *mut JSFunction {
_ZN2JS21GetSelfHostedFunctionEP9JSContextPKcNS_6HandleI4jsidEEj(cx,
selfHostedName,
id, nargs)
}
#[inline]
pub unsafe extern "C" fn JS_GetFunctionObject(fun: *mut JSFunction)
-> *mut JSObject {
_Z20JS_GetFunctionObjectP10JSFunction(fun)
}
#[inline]
pub unsafe extern "C" fn JS_GetFunctionId(fun: *mut JSFunction)
-> *mut JSString {
_Z16JS_GetFunctionIdP10JSFunction(fun)
}
#[inline]
pub unsafe extern "C" fn JS_GetFunctionDisplayId(fun: *mut JSFunction)
-> *mut JSString {
_Z23JS_GetFunctionDisplayIdP10JSFunction(fun)
}
#[inline]
pub unsafe extern "C" fn JS_GetFunctionArity(fun: *mut JSFunction) -> u16 {
_Z19JS_GetFunctionArityP10JSFunction(fun)
}
#[inline]
pub unsafe extern "C" fn IsCallable(obj: *mut JSObject) -> bool {
_ZN2JS10IsCallableEP8JSObject(obj)
}
#[inline]
pub unsafe extern "C" fn IsConstructor(obj: *mut JSObject) -> bool {
_ZN2JS13IsConstructorEP8JSObject(obj)
}
#[inline]
pub unsafe extern "C" fn JS_ObjectIsFunction(cx: *mut JSContext,
obj: *mut JSObject) -> bool {
_Z19JS_ObjectIsFunctionP9JSContextP8JSObject(cx, obj)
}
#[inline]
pub unsafe extern "C" fn JS_IsNativeFunction(funobj: *mut JSObject,
call: JSNative) -> bool {
_Z19JS_IsNativeFunctionP8JSObjectPFbP9JSContextjPN2JS5ValueEE(funobj,
call)
}
#[inline]
pub unsafe extern "C" fn JS_IsConstructor(fun: *mut JSFunction) -> bool {
_Z16JS_IsConstructorP10JSFunction(fun)
}
#[inline]
pub unsafe extern "C" fn JS_DefineFunctions(cx: *mut JSContext,
obj: Handle<*mut JSObject>,
fs: *const JSFunctionSpec,
behavior:
PropertyDefinitionBehavior)
-> bool {
_Z18JS_DefineFunctionsP9JSContextN2JS6HandleIP8JSObjectEEPK14JSFunctionSpec26PropertyDefinitionBehavior(cx,
obj,
fs,
behavior)
}
#[inline]
pub unsafe extern "C" fn JS_DefineFunction(cx: *mut JSContext,
obj: Handle<*mut JSObject>,
name: *const ::libc::c_char,
call: JSNative, nargs: u32,
attrs: u32) -> *mut JSFunction {
_Z17JS_DefineFunctionP9JSContextN2JS6HandleIP8JSObjectEEPKcPFbS0_jPNS1_5ValueEEjj(cx,
obj,
name,
call,
nargs,
attrs)
}
#[inline]
pub unsafe extern "C" fn JS_DefineUCFunction(cx: *mut JSContext,
obj: Handle<*mut JSObject>,
name: *const u16,
namelen: size_t, call: JSNative,
nargs: u32, attrs: u32)
-> *mut JSFunction {
_Z19JS_DefineUCFunctionP9JSContextN2JS6HandleIP8JSObjectEEPKDsjPFbS0_jPNS1_5ValueEEjj(cx,
obj,
name,
namelen,
call,
nargs,
attrs)
}
#[inline]
pub unsafe extern "C" fn JS_DefineFunctionById(cx: *mut JSContext,
obj: Handle<*mut JSObject>,
id: Handle<jsid>,
call: JSNative, nargs: u32,
attrs: u32)
-> *mut JSFunction {
_Z21JS_DefineFunctionByIdP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEEPFbS0_jPNS1_5ValueEEjj(cx,
obj,
id,
call,
nargs,
attrs)
}
#[inline]
pub unsafe extern "C" fn CloneFunctionObject(cx: *mut JSContext,
funobj: HandleObject)
-> *mut JSObject {
_ZN2JS19CloneFunctionObjectEP9JSContextNS_6HandleIP8JSObjectEE(cx, funobj)
}
#[inline]
pub unsafe extern "C" fn CloneFunctionObject1(cx: *mut JSContext,
funobj: HandleObject,
scopeChain:
&mut AutoObjectVector)
-> *mut JSObject {
_ZN2JS19CloneFunctionObjectEP9JSContextNS_6HandleIP8JSObjectEERNS_16AutoVectorRooterIS4_EE(cx,
funobj,
scopeChain)
}
#[inline]
pub unsafe extern "C" fn JS_BufferIsCompilableUnit(cx: *mut JSContext,
obj: Handle<*mut JSObject>,
utf8:
*const ::libc::c_char,
length: size_t) -> bool {
_Z25JS_BufferIsCompilableUnitP9JSContextN2JS6HandleIP8JSObjectEEPKcj(cx,
obj,
utf8,
length)
}
#[inline]
pub unsafe extern "C" fn JS_CompileScript(cx: *mut JSContext,
ascii: *const ::libc::c_char,
length: size_t,
options: &CompileOptions,
script: MutableHandleScript)
-> bool {
_Z16JS_CompileScriptP9JSContextPKcjRKN2JS14CompileOptionsENS3_13MutableHandleIP8JSScriptEE(cx,
ascii,
length,
options,
script)
}
#[inline]
pub unsafe extern "C" fn JS_CompileUCScript(cx: *mut JSContext,
chars: *const u16, length: size_t,
options: &CompileOptions,
script: MutableHandleScript)
-> bool {
_Z18JS_CompileUCScriptP9JSContextPKDsjRKN2JS14CompileOptionsENS3_13MutableHandleIP8JSScriptEE(cx,
chars,
length,
options,
script)
}
#[inline]
pub unsafe extern "C" fn JS_GetGlobalFromScript(script: *mut JSScript)
-> *mut JSObject {
_Z22JS_GetGlobalFromScriptP8JSScript(script)
}
#[inline]
pub unsafe extern "C" fn JS_GetScriptFilename(script: *mut JSScript)
-> *const ::libc::c_char {
_Z20JS_GetScriptFilenameP8JSScript(script)
}
#[inline]
pub unsafe extern "C" fn JS_GetScriptBaseLineNumber(cx: *mut JSContext,
script: *mut JSScript)
-> u32 {
_Z26JS_GetScriptBaseLineNumberP9JSContextP8JSScript(cx, script)
}
#[inline]
pub unsafe extern "C" fn JS_GetFunctionScript(cx: *mut JSContext,
fun: HandleFunction)
-> *mut JSScript {
_Z20JS_GetFunctionScriptP9JSContextN2JS6HandleIP10JSFunctionEE(cx, fun)
}
#[inline]
pub unsafe extern "C" fn Compile(cx: *mut JSContext,
options: &ReadOnlyCompileOptions,
srcBuf: &mut SourceBufferHolder,
script: MutableHandleScript) -> bool {
_ZN2JS7CompileEP9JSContextRKNS_22ReadOnlyCompileOptionsERNS_18SourceBufferHolderENS_13MutableHandleIP8JSScriptEE(cx,
options,
srcBuf,
script)
}
#[inline]
pub unsafe extern "C" fn Compile1(cx: *mut JSContext,
options: &ReadOnlyCompileOptions,
bytes: *const ::libc::c_char,
length: size_t, script: MutableHandleScript)
-> bool {
_ZN2JS7CompileEP9JSContextRKNS_22ReadOnlyCompileOptionsEPKcjNS_13MutableHandleIP8JSScriptEE(cx,
options,
bytes,
length,
script)
}
#[inline]
pub unsafe extern "C" fn Compile2(cx: *mut JSContext,
options: &ReadOnlyCompileOptions,
chars: *const u16, length: size_t,
script: MutableHandleScript) -> bool {
_ZN2JS7CompileEP9JSContextRKNS_22ReadOnlyCompileOptionsEPKDsjNS_13MutableHandleIP8JSScriptEE(cx,
options,
chars,
length,
script)
}
#[inline]
pub unsafe extern "C" fn Compile3(cx: *mut JSContext,
options: &ReadOnlyCompileOptions,
file: *mut FILE,
script: MutableHandleScript) -> bool {
_ZN2JS7CompileEP9JSContextRKNS_22ReadOnlyCompileOptionsEP8_IO_FILENS_13MutableHandleIP8JSScriptEE(cx,
options,
file,
script)
}
#[inline]
pub unsafe extern "C" fn Compile4(cx: *mut JSContext,
options: &ReadOnlyCompileOptions,
filename: *const ::libc::c_char,
script: MutableHandleScript) -> bool {
_ZN2JS7CompileEP9JSContextRKNS_22ReadOnlyCompileOptionsEPKcNS_13MutableHandleIP8JSScriptEE(cx,
options,
filename,
script)
}
#[inline]
pub unsafe extern "C" fn CompileForNonSyntacticScope(cx: *mut JSContext,
options:
&ReadOnlyCompileOptions,
srcBuf:
&mut SourceBufferHolder,
script:
MutableHandleScript)
-> bool {
_ZN2JS27CompileForNonSyntacticScopeEP9JSContextRKNS_22ReadOnlyCompileOptionsERNS_18SourceBufferHolderENS_13MutableHandleIP8JSScriptEE(cx,
options,
srcBuf,
script)
}
#[inline]
pub unsafe extern "C" fn CompileForNonSyntacticScope1(cx: *mut JSContext,
options:
&ReadOnlyCompileOptions,
bytes:
*const ::libc::c_char,
length: size_t,
script:
MutableHandleScript)
-> bool {
_ZN2JS27CompileForNonSyntacticScopeEP9JSContextRKNS_22ReadOnlyCompileOptionsEPKcjNS_13MutableHandleIP8JSScriptEE(cx,
options,
bytes,
length,
script)
}
#[inline]
pub unsafe extern "C" fn CompileForNonSyntacticScope2(cx: *mut JSContext,
options:
&ReadOnlyCompileOptions,
chars: *const u16,
length: size_t,
script:
MutableHandleScript)
-> bool {
_ZN2JS27CompileForNonSyntacticScopeEP9JSContextRKNS_22ReadOnlyCompileOptionsEPKDsjNS_13MutableHandleIP8JSScriptEE(cx,
options,
chars,
length,
script)
}
#[inline]
pub unsafe extern "C" fn CompileForNonSyntacticScope3(cx: *mut JSContext,
options:
&ReadOnlyCompileOptions,
file: *mut FILE,
script:
MutableHandleScript)
-> bool {
_ZN2JS27CompileForNonSyntacticScopeEP9JSContextRKNS_22ReadOnlyCompileOptionsEP8_IO_FILENS_13MutableHandleIP8JSScriptEE(cx,
options,
file,
script)
}
#[inline]
pub unsafe extern "C" fn CompileForNonSyntacticScope4(cx: *mut JSContext,
options:
&ReadOnlyCompileOptions,
filename:
*const ::libc::c_char,
script:
MutableHandleScript)
-> bool {
_ZN2JS27CompileForNonSyntacticScopeEP9JSContextRKNS_22ReadOnlyCompileOptionsEPKcNS_13MutableHandleIP8JSScriptEE(cx,
options,
filename,
script)
}
#[inline]
pub unsafe extern "C" fn CanCompileOffThread(cx: *mut JSContext,
options: &ReadOnlyCompileOptions,
length: size_t) -> bool {
_ZN2JS19CanCompileOffThreadEP9JSContextRKNS_22ReadOnlyCompileOptionsEj(cx,
options,
length)
}
#[inline]
pub unsafe extern "C" fn CompileOffThread(cx: *mut JSContext,
options: &ReadOnlyCompileOptions,
chars: *const u16, length: size_t,
callback: OffThreadCompileCallback,
callbackData: *mut ::libc::c_void)
-> bool {
_ZN2JS16CompileOffThreadEP9JSContextRKNS_22ReadOnlyCompileOptionsEPKDsjPFvPvS7_ES7_(cx,
options,
chars,
length,
callback,
callbackData)
}
#[inline]
pub unsafe extern "C" fn FinishOffThreadScript(maybecx: *mut JSContext,
rt: *mut JSRuntime,
token: *mut ::libc::c_void)
-> *mut JSScript {
_ZN2JS21FinishOffThreadScriptEP9JSContextP9JSRuntimePv(maybecx, rt, token)
}
/**
* Compile a function with scopeChain plus the global as its scope chain.
* scopeChain must contain objects in the current compartment of cx. The actual
* scope chain used for the function will consist of With wrappers for those
* objects, followed by the current global of the compartment cx is in. This
* global must not be explicitly included in the scope chain.
*/
#[inline]
pub unsafe extern "C" fn CompileFunction(cx: *mut JSContext,
scopeChain: &mut AutoObjectVector,
options: &ReadOnlyCompileOptions,
name: *const ::libc::c_char,
nargs: u32,
argnames:
*const *const ::libc::c_char,
chars: *const u16, length: size_t,
fun: MutableHandleFunction) -> bool {
_ZN2JS15CompileFunctionEP9JSContextRNS_16AutoVectorRooterIP8JSObjectEERKNS_22ReadOnlyCompileOptionsEPKcjPKSB_PKDsjNS_13MutableHandleIP10JSFunctionEE(cx,
scopeChain,
options,
name,
nargs,
argnames,
chars,
length,
fun)
}
/**
* Same as above, but taking a SourceBufferHolder for the function body.
*/
#[inline]
pub unsafe extern "C" fn CompileFunction1(cx: *mut JSContext,
scopeChain: &mut AutoObjectVector,
options: &ReadOnlyCompileOptions,
name: *const ::libc::c_char,
nargs: u32,
argnames:
*const *const ::libc::c_char,
srcBuf: &mut SourceBufferHolder,
fun: MutableHandleFunction)
-> bool {
_ZN2JS15CompileFunctionEP9JSContextRNS_16AutoVectorRooterIP8JSObjectEERKNS_22ReadOnlyCompileOptionsEPKcjPKSB_RNS_18SourceBufferHolderENS_13MutableHandleIP10JSFunctionEE(cx,
scopeChain,
options,
name,
nargs,
argnames,
srcBuf,
fun)
}
/**
* Same as above, but taking a const char * for the function body.
*/
#[inline]
pub unsafe extern "C" fn CompileFunction2(cx: *mut JSContext,
scopeChain: &mut AutoObjectVector,
options: &ReadOnlyCompileOptions,
name: *const ::libc::c_char,
nargs: u32,
argnames:
*const *const ::libc::c_char,
bytes: *const ::libc::c_char,
length: size_t,
fun: MutableHandleFunction)
-> bool {
_ZN2JS15CompileFunctionEP9JSContextRNS_16AutoVectorRooterIP8JSObjectEERKNS_22ReadOnlyCompileOptionsEPKcjPKSB_SB_jNS_13MutableHandleIP10JSFunctionEE(cx,
scopeChain,
options,
name,
nargs,
argnames,
bytes,
length,
fun)
}
#[inline]
pub unsafe extern "C" fn JS_DecompileScript(cx: *mut JSContext,
script: Handle<*mut JSScript>,
name: *const ::libc::c_char,
indent: u32) -> *mut JSString {
_Z18JS_DecompileScriptP9JSContextN2JS6HandleIP8JSScriptEEPKcj(cx, script,
name,
indent)
}
#[inline]
pub unsafe extern "C" fn JS_DecompileFunction(cx: *mut JSContext,
fun: Handle<*mut JSFunction>,
indent: u32) -> *mut JSString {
_Z20JS_DecompileFunctionP9JSContextN2JS6HandleIP10JSFunctionEEj(cx, fun,
indent)
}
#[inline]
pub unsafe extern "C" fn JS_DecompileFunctionBody(cx: *mut JSContext,
fun:
Handle<*mut JSFunction>,
indent: u32)
-> *mut JSString {
_Z24JS_DecompileFunctionBodyP9JSContextN2JS6HandleIP10JSFunctionEEj(cx,
fun,
indent)
}
#[inline]
pub unsafe extern "C" fn JS_ExecuteScript(cx: *mut JSContext,
script: HandleScript,
rval: MutableHandleValue) -> bool {
_Z16JS_ExecuteScriptP9JSContextN2JS6HandleIP8JSScriptEENS1_13MutableHandleINS1_5ValueEEE(cx,
script,
rval)
}
#[inline]
pub unsafe extern "C" fn JS_ExecuteScript1(cx: *mut JSContext,
script: HandleScript) -> bool {
_Z16JS_ExecuteScriptP9JSContextN2JS6HandleIP8JSScriptEE(cx, script)
}
#[inline]
pub unsafe extern "C" fn JS_ExecuteScript2(cx: *mut JSContext,
scopeChain: &mut AutoObjectVector,
script: HandleScript,
rval: MutableHandleValue) -> bool {
_Z16JS_ExecuteScriptP9JSContextRN2JS16AutoVectorRooterIP8JSObjectEENS1_6HandleIP8JSScriptEENS1_13MutableHandleINS1_5ValueEEE(cx,
scopeChain,
script,
rval)
}
#[inline]
pub unsafe extern "C" fn JS_ExecuteScript3(cx: *mut JSContext,
scopeChain: &mut AutoObjectVector,
script: HandleScript) -> bool {
_Z16JS_ExecuteScriptP9JSContextRN2JS16AutoVectorRooterIP8JSObjectEENS1_6HandleIP8JSScriptEE(cx,
scopeChain,
script)
}
#[inline]
pub unsafe extern "C" fn CloneAndExecuteScript(cx: *mut JSContext,
script: Handle<*mut JSScript>)
-> bool {
_ZN2JS21CloneAndExecuteScriptEP9JSContextNS_6HandleIP8JSScriptEE(cx,
script)
}
#[inline]
pub unsafe extern "C" fn Evaluate(cx: *mut JSContext,
options: &ReadOnlyCompileOptions,
srcBuf: &mut SourceBufferHolder,
rval: MutableHandleValue) -> bool {
_ZN2JS8EvaluateEP9JSContextRKNS_22ReadOnlyCompileOptionsERNS_18SourceBufferHolderENS_13MutableHandleINS_5ValueEEE(cx,
options,
srcBuf,
rval)
}
#[inline]
pub unsafe extern "C" fn Evaluate1(cx: *mut JSContext,
scopeChain: &mut AutoObjectVector,
options: &ReadOnlyCompileOptions,
srcBuf: &mut SourceBufferHolder,
rval: MutableHandleValue) -> bool {
_ZN2JS8EvaluateEP9JSContextRNS_16AutoVectorRooterIP8JSObjectEERKNS_22ReadOnlyCompileOptionsERNS_18SourceBufferHolderENS_13MutableHandleINS_5ValueEEE(cx,
scopeChain,
options,
srcBuf,
rval)
}
#[inline]
pub unsafe extern "C" fn Evaluate2(cx: *mut JSContext,
options: &ReadOnlyCompileOptions,
chars: *const u16, length: size_t,
rval: MutableHandleValue) -> bool {
_ZN2JS8EvaluateEP9JSContextRKNS_22ReadOnlyCompileOptionsEPKDsjNS_13MutableHandleINS_5ValueEEE(cx,
options,
chars,
length,
rval)
}
#[inline]
pub unsafe extern "C" fn Evaluate3(cx: *mut JSContext,
scopeChain: &mut AutoObjectVector,
options: &ReadOnlyCompileOptions,
chars: *const u16, length: size_t,
rval: MutableHandleValue) -> bool {
_ZN2JS8EvaluateEP9JSContextRNS_16AutoVectorRooterIP8JSObjectEERKNS_22ReadOnlyCompileOptionsEPKDsjNS_13MutableHandleINS_5ValueEEE(cx,
scopeChain,
options,
chars,
length,
rval)
}
#[inline]
pub unsafe extern "C" fn Evaluate4(cx: *mut JSContext,
options: &ReadOnlyCompileOptions,
bytes: *const ::libc::c_char,
length: size_t, rval: MutableHandleValue)
-> bool {
_ZN2JS8EvaluateEP9JSContextRKNS_22ReadOnlyCompileOptionsEPKcjNS_13MutableHandleINS_5ValueEEE(cx,
options,
bytes,
length,
rval)
}
#[inline]
pub unsafe extern "C" fn Evaluate5(cx: *mut JSContext,
options: &ReadOnlyCompileOptions,
filename: *const ::libc::c_char,
rval: MutableHandleValue) -> bool {
_ZN2JS8EvaluateEP9JSContextRKNS_22ReadOnlyCompileOptionsEPKcNS_13MutableHandleINS_5ValueEEE(cx,
options,
filename,
rval)
}
#[inline]
pub unsafe extern "C" fn JS_CallFunction(cx: *mut JSContext,
obj: HandleObject,
fun: HandleFunction,
args: &HandleValueArray,
rval: MutableHandleValue) -> bool {
_Z15JS_CallFunctionP9JSContextN2JS6HandleIP8JSObjectEENS2_IP10JSFunctionEERKNS1_16HandleValueArrayENS1_13MutableHandleINS1_5ValueEEE(cx,
obj,
fun,
args,
rval)
}
#[inline]
pub unsafe extern "C" fn JS_CallFunctionName(cx: *mut JSContext,
obj: HandleObject,
name: *const ::libc::c_char,
args: &HandleValueArray,
rval: MutableHandleValue)
-> bool {
_Z19JS_CallFunctionNameP9JSContextN2JS6HandleIP8JSObjectEEPKcRKNS1_16HandleValueArrayENS1_13MutableHandleINS1_5ValueEEE(cx,
obj,
name,
args,
rval)
}
#[inline]
pub unsafe extern "C" fn JS_CallFunctionValue(cx: *mut JSContext,
obj: HandleObject,
fval: HandleValue,
args: &HandleValueArray,
rval: MutableHandleValue)
-> bool {
_Z20JS_CallFunctionValueP9JSContextN2JS6HandleIP8JSObjectEENS2_INS1_5ValueEEERKNS1_16HandleValueArrayENS1_13MutableHandleIS6_EE(cx,
obj,
fval,
args,
rval)
}
#[inline]
pub unsafe extern "C" fn Call(cx: *mut JSContext, thisv: HandleValue,
fun: HandleValue, args: &HandleValueArray,
rval: MutableHandleValue) -> bool {
_ZN2JS4CallEP9JSContextNS_6HandleINS_5ValueEEES4_RKNS_16HandleValueArrayENS_13MutableHandleIS3_EE(cx,
thisv,
fun,
args,
rval)
}
#[inline]
pub unsafe extern "C" fn Construct(cx: *mut JSContext, fun: HandleValue,
args: &HandleValueArray,
rval: MutableHandleValue) -> bool {
_ZN2JS9ConstructEP9JSContextNS_6HandleINS_5ValueEEERKNS_16HandleValueArrayENS_13MutableHandleIS3_EE(cx,
fun,
args,
rval)
}
#[inline]
pub unsafe extern "C" fn Construct1(cx: *mut JSContext, fun: HandleValue,
newTarget: HandleObject,
args: &HandleValueArray,
rval: MutableHandleValue) -> bool {
_ZN2JS9ConstructEP9JSContextNS_6HandleINS_5ValueEEENS2_IP8JSObjectEERKNS_16HandleValueArrayENS_13MutableHandleIS3_EE(cx,
fun,
newTarget,
args,
rval)
}
#[inline]
pub unsafe extern "C" fn JS_CheckForInterrupt(cx: *mut JSContext) -> bool {
_Z20JS_CheckForInterruptP9JSContext(cx)
}
#[inline]
pub unsafe extern "C" fn JS_SetInterruptCallback(rt: *mut JSRuntime,
callback:
JSInterruptCallback)
-> JSInterruptCallback {
_Z23JS_SetInterruptCallbackP9JSRuntimePFbP9JSContextE(rt, callback)
}
#[inline]
pub unsafe extern "C" fn JS_GetInterruptCallback(rt: *mut JSRuntime)
-> JSInterruptCallback {
_Z23JS_GetInterruptCallbackP9JSRuntime(rt)
}
#[inline]
pub unsafe extern "C" fn JS_RequestInterruptCallback(rt: *mut JSRuntime) {
_Z27JS_RequestInterruptCallbackP9JSRuntime(rt)
}
#[inline]
pub unsafe extern "C" fn JS_IsRunning(cx: *mut JSContext) -> bool {
_Z12JS_IsRunningP9JSContext(cx)
}
#[inline]
pub unsafe extern "C" fn JS_SaveFrameChain(cx: *mut JSContext) -> bool {
_Z17JS_SaveFrameChainP9JSContext(cx)
}
#[inline]
pub unsafe extern "C" fn JS_RestoreFrameChain(cx: *mut JSContext) {
_Z20JS_RestoreFrameChainP9JSContext(cx)
}
#[inline]
pub unsafe extern "C" fn JS_NewStringCopyN(cx: *mut JSContext,
s: *const ::libc::c_char,
n: size_t) -> *mut JSString {
_Z17JS_NewStringCopyNP9JSContextPKcj(cx, s, n)
}
#[inline]
pub unsafe extern "C" fn JS_NewStringCopyZ(cx: *mut JSContext,
s: *const ::libc::c_char)
-> *mut JSString {
_Z17JS_NewStringCopyZP9JSContextPKc(cx, s)
}
#[inline]
pub unsafe extern "C" fn JS_AtomizeAndPinJSString(cx: *mut JSContext,
str: HandleString)
-> *mut JSString {
_Z24JS_AtomizeAndPinJSStringP9JSContextN2JS6HandleIP8JSStringEE(cx, str)
}
#[inline]
pub unsafe extern "C" fn JS_AtomizeAndPinStringN(cx: *mut JSContext,
s: *const ::libc::c_char,
length: size_t)
-> *mut JSString {
_Z23JS_AtomizeAndPinStringNP9JSContextPKcj(cx, s, length)
}
#[inline]
pub unsafe extern "C" fn JS_AtomizeAndPinString(cx: *mut JSContext,
s: *const ::libc::c_char)
-> *mut JSString {
_Z22JS_AtomizeAndPinStringP9JSContextPKc(cx, s)
}
#[inline]
pub unsafe extern "C" fn JS_NewUCString(cx: *mut JSContext, chars: *mut u16,
length: size_t) -> *mut JSString {
_Z14JS_NewUCStringP9JSContextPDsj(cx, chars, length)
}
#[inline]
pub unsafe extern "C" fn JS_NewUCStringCopyN(cx: *mut JSContext,
s: *const u16, n: size_t)
-> *mut JSString {
_Z19JS_NewUCStringCopyNP9JSContextPKDsj(cx, s, n)
}
#[inline]
pub unsafe extern "C" fn JS_NewUCStringCopyZ(cx: *mut JSContext,
s: *const u16) -> *mut JSString {
_Z19JS_NewUCStringCopyZP9JSContextPKDs(cx, s)
}
#[inline]
pub unsafe extern "C" fn JS_AtomizeAndPinUCStringN(cx: *mut JSContext,
s: *const u16,
length: size_t)
-> *mut JSString {
_Z25JS_AtomizeAndPinUCStringNP9JSContextPKDsj(cx, s, length)
}
#[inline]
pub unsafe extern "C" fn JS_AtomizeAndPinUCString(cx: *mut JSContext,
s: *const u16)
-> *mut JSString {
_Z24JS_AtomizeAndPinUCStringP9JSContextPKDs(cx, s)
}
#[inline]
pub unsafe extern "C" fn JS_CompareStrings(cx: *mut JSContext,
str1: *mut JSString,
str2: *mut JSString,
result: *mut i32) -> bool {
_Z17JS_CompareStringsP9JSContextP8JSStringS2_Pi(cx, str1, str2, result)
}
#[inline]
pub unsafe extern "C" fn JS_StringEqualsAscii(cx: *mut JSContext,
str: *mut JSString,
asciiBytes:
*const ::libc::c_char,
_match: *mut bool) -> bool {
_Z20JS_StringEqualsAsciiP9JSContextP8JSStringPKcPb(cx, str, asciiBytes,
_match)
}
#[inline]
pub unsafe extern "C" fn JS_PutEscapedString(cx: *mut JSContext,
buffer: *mut ::libc::c_char,
size: size_t, str: *mut JSString,
quote: ::libc::c_char)
-> size_t {
_Z19JS_PutEscapedStringP9JSContextPcjP8JSStringc(cx, buffer, size, str,
quote)
}
#[inline]
pub unsafe extern "C" fn JS_FileEscapedString(fp: *mut FILE,
str: *mut JSString,
quote: ::libc::c_char) -> bool {
_Z20JS_FileEscapedStringP8_IO_FILEP8JSStringc(fp, str, quote)
}
#[inline]
pub unsafe extern "C" fn JS_GetStringLength(str: *mut JSString) -> size_t {
_Z18JS_GetStringLengthP8JSString(str)
}
#[inline]
pub unsafe extern "C" fn JS_StringIsFlat(str: *mut JSString) -> bool {
_Z15JS_StringIsFlatP8JSString(str)
}
#[inline]
pub unsafe extern "C" fn JS_StringHasLatin1Chars(str: *mut JSString) -> bool {
_Z23JS_StringHasLatin1CharsP8JSString(str)
}
#[inline]
pub unsafe extern "C" fn JS_GetLatin1StringCharsAndLength(cx: *mut JSContext,
nogc:
&AutoCheckCannotGC,
str: *mut JSString,
length: *mut size_t)
-> *const Latin1Char {
_Z32JS_GetLatin1StringCharsAndLengthP9JSContextRKN2JS17AutoCheckCannotGCEP8JSStringPj(cx,
nogc,
str,
length)
}
#[inline]
pub unsafe extern "C" fn JS_GetTwoByteStringCharsAndLength(cx: *mut JSContext,
nogc:
&AutoCheckCannotGC,
str: *mut JSString,
length:
*mut size_t)
-> *const u16 {
_Z33JS_GetTwoByteStringCharsAndLengthP9JSContextRKN2JS17AutoCheckCannotGCEP8JSStringPj(cx,
nogc,
str,
length)
}
#[inline]
pub unsafe extern "C" fn JS_GetStringCharAt(cx: *mut JSContext,
str: *mut JSString, index: size_t,
res: *mut u16) -> bool {
_Z18JS_GetStringCharAtP9JSContextP8JSStringjPDs(cx, str, index, res)
}
#[inline]
pub unsafe extern "C" fn JS_GetFlatStringCharAt(str: *mut JSFlatString,
index: size_t) -> u16 {
_Z22JS_GetFlatStringCharAtP12JSFlatStringj(str, index)
}
#[inline]
pub unsafe extern "C" fn JS_GetTwoByteExternalStringChars(str: *mut JSString)
-> *const u16 {
_Z32JS_GetTwoByteExternalStringCharsP8JSString(str)
}
#[inline]
pub unsafe extern "C" fn JS_CopyStringChars(cx: *mut JSContext,
dest: Range<u16>,
str: *mut JSString) -> bool {
_Z18JS_CopyStringCharsP9JSContextN7mozilla5RangeIDsEEP8JSString(cx, dest,
str)
}
#[inline]
pub unsafe extern "C" fn JS_FlattenString(cx: *mut JSContext,
str: *mut JSString)
-> *mut JSFlatString {
_Z16JS_FlattenStringP9JSContextP8JSString(cx, str)
}
#[inline]
pub unsafe extern "C" fn JS_GetLatin1FlatStringChars(nogc: &AutoCheckCannotGC,
str: *mut JSFlatString)
-> *const Latin1Char {
_Z27JS_GetLatin1FlatStringCharsRKN2JS17AutoCheckCannotGCEP12JSFlatString(nogc,
str)
}
#[inline]
pub unsafe extern "C" fn JS_GetTwoByteFlatStringChars(nogc:
&AutoCheckCannotGC,
str: *mut JSFlatString)
-> *const u16 {
_Z28JS_GetTwoByteFlatStringCharsRKN2JS17AutoCheckCannotGCEP12JSFlatString(nogc,
str)
}
#[inline]
pub unsafe extern "C" fn JS_FlatStringEqualsAscii(str: *mut JSFlatString,
asciiBytes:
*const ::libc::c_char)
-> bool {
_Z24JS_FlatStringEqualsAsciiP12JSFlatStringPKc(str, asciiBytes)
}
#[inline]
pub unsafe extern "C" fn JS_PutEscapedFlatString(buffer: *mut ::libc::c_char,
size: size_t,
str: *mut JSFlatString,
quote: ::libc::c_char)
-> size_t {
_Z23JS_PutEscapedFlatStringPcjP12JSFlatStringc(buffer, size, str, quote)
}
#[inline]
pub unsafe extern "C" fn JS_NewDependentString(cx: *mut JSContext,
str: HandleString,
start: size_t, length: size_t)
-> *mut JSString {
_Z21JS_NewDependentStringP9JSContextN2JS6HandleIP8JSStringEEjj(cx, str,
start,
length)
}
#[inline]
pub unsafe extern "C" fn JS_ConcatStrings(cx: *mut JSContext,
left: HandleString,
right: HandleString)
-> *mut JSString {
_Z16JS_ConcatStringsP9JSContextN2JS6HandleIP8JSStringEES5_(cx, left,
right)
}
#[inline]
pub unsafe extern "C" fn JS_DecodeBytes(cx: *mut JSContext,
src: *const ::libc::c_char,
srclen: size_t, dst: *mut u16,
dstlenp: *mut size_t) -> bool {
_Z14JS_DecodeBytesP9JSContextPKcjPDsPj(cx, src, srclen, dst, dstlenp)
}
#[inline]
pub unsafe extern "C" fn JS_EncodeString(cx: *mut JSContext,
str: *mut JSString)
-> *mut ::libc::c_char {
_Z15JS_EncodeStringP9JSContextP8JSString(cx, str)
}
#[inline]
pub unsafe extern "C" fn JS_EncodeStringToUTF8(cx: *mut JSContext,
str: HandleString)
-> *mut ::libc::c_char {
_Z21JS_EncodeStringToUTF8P9JSContextN2JS6HandleIP8JSStringEE(cx, str)
}
#[inline]
pub unsafe extern "C" fn JS_GetStringEncodingLength(cx: *mut JSContext,
str: *mut JSString)
-> size_t {
_Z26JS_GetStringEncodingLengthP9JSContextP8JSString(cx, str)
}
#[inline]
pub unsafe extern "C" fn JS_EncodeStringToBuffer(cx: *mut JSContext,
str: *mut JSString,
buffer: *mut ::libc::c_char,
length: size_t) -> size_t {
_Z23JS_EncodeStringToBufferP9JSContextP8JSStringPcj(cx, str, buffer,
length)
}
#[inline]
pub unsafe extern "C" fn NewAddonId(cx: *mut JSContext, str: HandleString)
-> *mut JSAddonId {
_ZN2JS10NewAddonIdEP9JSContextNS_6HandleIP8JSStringEE(cx, str)
}
#[inline]
pub unsafe extern "C" fn StringOfAddonId(id: *mut JSAddonId)
-> *mut JSString {
_ZN2JS15StringOfAddonIdEP9JSAddonId(id)
}
#[inline]
pub unsafe extern "C" fn AddonIdOfObject(obj: *mut JSObject)
-> *mut JSAddonId {
_ZN2JS15AddonIdOfObjectEP8JSObject(obj)
}
#[inline]
pub unsafe extern "C" fn NewSymbol(cx: *mut JSContext,
description: HandleString) -> *mut Symbol {
_ZN2JS9NewSymbolEP9JSContextNS_6HandleIP8JSStringEE(cx, description)
}
#[inline]
pub unsafe extern "C" fn GetSymbolFor(cx: *mut JSContext, key: HandleString)
-> *mut Symbol {
_ZN2JS12GetSymbolForEP9JSContextNS_6HandleIP8JSStringEE(cx, key)
}
#[inline]
pub unsafe extern "C" fn GetSymbolDescription(symbol: HandleSymbol)
-> *mut JSString {
_ZN2JS20GetSymbolDescriptionENS_6HandleIPNS_6SymbolEEE(symbol)
}
#[inline]
pub unsafe extern "C" fn GetSymbolCode(symbol: Handle<*mut Symbol>)
-> SymbolCode {
_ZN2JS13GetSymbolCodeENS_6HandleIPNS_6SymbolEEE(symbol)
}
#[inline]
pub unsafe extern "C" fn GetWellKnownSymbol(cx: *mut JSContext,
which: SymbolCode)
-> *mut Symbol {
_ZN2JS18GetWellKnownSymbolEP9JSContextNS_10SymbolCodeE(cx, which)
}
#[inline]
pub unsafe extern "C" fn PropertySpecNameIsSymbol(name: *const ::libc::c_char)
-> bool {
_ZN2JS24PropertySpecNameIsSymbolEPKc(name)
}
#[inline]
pub unsafe extern "C" fn PropertySpecNameEqualsId(name: *const ::libc::c_char,
id: HandleId) -> bool {
_ZN2JS24PropertySpecNameEqualsIdEPKcNS_6HandleI4jsidEE(name, id)
}
#[inline]
pub unsafe extern "C" fn PropertySpecNameToPermanentId(cx: *mut JSContext,
name:
*const ::libc::c_char,
idp: *mut jsid)
-> bool {
_ZN2JS29PropertySpecNameToPermanentIdEP9JSContextPKcP4jsid(cx, name, idp)
}
#[inline]
pub unsafe extern "C" fn JS_Stringify(cx: *mut JSContext,
value: MutableHandleValue,
replacer: HandleObject,
space: HandleValue,
callback: JSONWriteCallback,
data: *mut ::libc::c_void) -> bool {
_Z12JS_StringifyP9JSContextN2JS13MutableHandleINS1_5ValueEEENS1_6HandleIP8JSObjectEENS5_IS3_EEPFbPKDsjPvESC_(cx,
value,
replacer,
space,
callback,
data)
}
#[inline]
pub unsafe extern "C" fn JS_ParseJSON(cx: *mut JSContext, chars: *const u16,
len: u32, vp: MutableHandleValue)
-> bool {
_Z12JS_ParseJSONP9JSContextPKDsjN2JS13MutableHandleINS3_5ValueEEE(cx,
chars,
len, vp)
}
#[inline]
pub unsafe extern "C" fn JS_ParseJSON1(cx: *mut JSContext, str: HandleString,
vp: MutableHandleValue) -> bool {
_Z12JS_ParseJSONP9JSContextN2JS6HandleIP8JSStringEENS1_13MutableHandleINS1_5ValueEEE(cx,
str,
vp)
}
#[inline]
pub unsafe extern "C" fn JS_ParseJSONWithReviver(cx: *mut JSContext,
chars: *const u16, len: u32,
reviver: HandleValue,
vp: MutableHandleValue)
-> bool {
_Z23JS_ParseJSONWithReviverP9JSContextPKDsjN2JS6HandleINS3_5ValueEEENS3_13MutableHandleIS5_EE(cx,
chars,
len,
reviver,
vp)
}
#[inline]
pub unsafe extern "C" fn JS_ParseJSONWithReviver1(cx: *mut JSContext,
str: HandleString,
reviver: HandleValue,
vp: MutableHandleValue)
-> bool {
_Z23JS_ParseJSONWithReviverP9JSContextN2JS6HandleIP8JSStringEENS2_INS1_5ValueEEENS1_13MutableHandleIS6_EE(cx,
str,
reviver,
vp)
}
/************************************************************************/
#[inline]
pub unsafe extern "C" fn JS_SetDefaultLocale(rt: *mut JSRuntime,
locale: *const ::libc::c_char)
-> bool {
_Z19JS_SetDefaultLocaleP9JSRuntimePKc(rt, locale)
}
#[inline]
pub unsafe extern "C" fn JS_ResetDefaultLocale(rt: *mut JSRuntime) {
_Z21JS_ResetDefaultLocaleP9JSRuntime(rt)
}
#[inline]
pub unsafe extern "C" fn JS_SetLocaleCallbacks(rt: *mut JSRuntime,
callbacks:
*const JSLocaleCallbacks) {
_Z21JS_SetLocaleCallbacksP9JSRuntimePK17JSLocaleCallbacks(rt, callbacks)
}
#[inline]
pub unsafe extern "C" fn JS_GetLocaleCallbacks(rt: *mut JSRuntime)
-> *const JSLocaleCallbacks {
_Z21JS_GetLocaleCallbacksP9JSRuntime(rt)
}
/************************************************************************/
#[inline]
pub unsafe extern "C" fn JS_ReportError(cx: *mut JSContext,
format: *const ::libc::c_char) {
_Z14JS_ReportErrorP9JSContextPKcz(cx, format)
}
#[inline]
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)
}
#[inline]
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)
}
#[inline]
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)
}
#[inline]
pub unsafe extern "C" fn JS_ReportErrorNumberUCArray(cx: *mut JSContext,
errorCallback:
JSErrorCallback,
userRef:
*mut ::libc::c_void,
errorNumber: u32,
args: *mut *const u16) {
_Z27JS_ReportErrorNumberUCArrayP9JSContextPFPK19JSErrorFormatStringPvjES4_jPPKDs(cx,
errorCallback,
userRef,
errorNumber,
args)
}
#[inline]
pub unsafe extern "C" fn JS_ReportWarning(cx: *mut JSContext,
format: *const ::libc::c_char)
-> bool {
_Z16JS_ReportWarningP9JSContextPKcz(cx, format)
}
#[inline]
pub unsafe extern "C" fn JS_ReportErrorFlagsAndNumber(cx: *mut JSContext,
flags: u32,
errorCallback:
JSErrorCallback,
userRef:
*mut ::libc::c_void,
errorNumber: u32)
-> bool {
_Z28JS_ReportErrorFlagsAndNumberP9JSContextjPFPK19JSErrorFormatStringPvjES4_jz(cx,
flags,
errorCallback,
userRef,
errorNumber)
}
#[inline]
pub unsafe extern "C" fn JS_ReportErrorFlagsAndNumberUC(cx: *mut JSContext,
flags: u32,
errorCallback:
JSErrorCallback,
userRef:
*mut ::libc::c_void,
errorNumber: u32)
-> bool {
_Z30JS_ReportErrorFlagsAndNumberUCP9JSContextjPFPK19JSErrorFormatStringPvjES4_jz(cx,
flags,
errorCallback,
userRef,
errorNumber)
}
#[inline]
pub unsafe extern "C" fn JS_ReportOutOfMemory(cx: *mut JSContext) {
_Z20JS_ReportOutOfMemoryP9JSContext(cx)
}
#[inline]
pub unsafe extern "C" fn JS_ReportAllocationOverflow(cx: *mut JSContext) {
_Z27JS_ReportAllocationOverflowP9JSContext(cx)
}
#[inline]
pub unsafe extern "C" fn JS_GetErrorReporter(rt: *mut JSRuntime)
-> JSErrorReporter {
_Z19JS_GetErrorReporterP9JSRuntime(rt)
}
#[inline]
pub unsafe extern "C" fn JS_SetErrorReporter(rt: *mut JSRuntime,
er: JSErrorReporter)
-> JSErrorReporter {
_Z19JS_SetErrorReporterP9JSRuntimePFvP9JSContextPKcP13JSErrorReportE(rt,
er)
}
#[inline]
pub unsafe extern "C" fn CreateError(cx: *mut JSContext, _type: JSExnType,
stack: HandleObject,
fileName: HandleString, lineNumber: u32,
columnNumber: u32,
report: *mut JSErrorReport,
message: HandleString,
rval: MutableHandleValue) -> bool {
_ZN2JS11CreateErrorEP9JSContext9JSExnTypeNS_6HandleIP8JSObjectEENS3_IP8JSStringEEjjP13JSErrorReportS9_NS_13MutableHandleINS_5ValueEEE(cx,
_type,
stack,
fileName,
lineNumber,
columnNumber,
report,
message,
rval)
}
/************************************************************************/
#[inline]
pub unsafe extern "C" fn NewWeakMapObject(cx: *mut JSContext)
-> *mut JSObject {
_ZN2JS16NewWeakMapObjectEP9JSContext(cx)
}
#[inline]
pub unsafe extern "C" fn IsWeakMapObject(obj: *mut JSObject) -> bool {
_ZN2JS15IsWeakMapObjectEP8JSObject(obj)
}
#[inline]
pub unsafe extern "C" fn GetWeakMapEntry(cx: *mut JSContext,
mapObj: HandleObject,
key: HandleObject,
val: MutableHandleValue) -> bool {
_ZN2JS15GetWeakMapEntryEP9JSContextNS_6HandleIP8JSObjectEES5_NS_13MutableHandleINS_5ValueEEE(cx,
mapObj,
key,
val)
}
#[inline]
pub unsafe extern "C" fn SetWeakMapEntry(cx: *mut JSContext,
mapObj: HandleObject,
key: HandleObject, val: HandleValue)
-> bool {
_ZN2JS15SetWeakMapEntryEP9JSContextNS_6HandleIP8JSObjectEES5_NS2_INS_5ValueEEE(cx,
mapObj,
key,
val)
}
#[inline]
pub unsafe extern "C" fn NewMapObject(cx: *mut JSContext) -> *mut JSObject {
_ZN2JS12NewMapObjectEP9JSContext(cx)
}
#[inline]
pub unsafe extern "C" fn MapSize(cx: *mut JSContext, obj: HandleObject)
-> u32 {
_ZN2JS7MapSizeEP9JSContextNS_6HandleIP8JSObjectEE(cx, obj)
}
#[inline]
pub unsafe extern "C" fn MapGet(cx: *mut JSContext, obj: HandleObject,
key: HandleValue, rval: MutableHandleValue)
-> bool {
_ZN2JS6MapGetEP9JSContextNS_6HandleIP8JSObjectEENS2_INS_5ValueEEENS_13MutableHandleIS6_EE(cx,
obj,
key,
rval)
}
#[inline]
pub unsafe extern "C" fn MapHas(cx: *mut JSContext, obj: HandleObject,
key: HandleValue, rval: *mut bool) -> bool {
_ZN2JS6MapHasEP9JSContextNS_6HandleIP8JSObjectEENS2_INS_5ValueEEEPb(cx,
obj,
key,
rval)
}
#[inline]
pub unsafe extern "C" fn MapSet(cx: *mut JSContext, obj: HandleObject,
key: HandleValue, val: HandleValue) -> bool {
_ZN2JS6MapSetEP9JSContextNS_6HandleIP8JSObjectEENS2_INS_5ValueEEES7_(cx,
obj,
key,
val)
}
#[inline]
pub unsafe extern "C" fn MapDelete(cx: *mut JSContext, obj: HandleObject,
key: HandleValue, rval: *mut bool)
-> bool {
_ZN2JS9MapDeleteEP9JSContextNS_6HandleIP8JSObjectEENS2_INS_5ValueEEEPb(cx,
obj,
key,
rval)
}
#[inline]
pub unsafe extern "C" fn MapClear(cx: *mut JSContext, obj: HandleObject)
-> bool {
_ZN2JS8MapClearEP9JSContextNS_6HandleIP8JSObjectEE(cx, obj)
}
#[inline]
pub unsafe extern "C" fn MapKeys(cx: *mut JSContext, obj: HandleObject,
rval: MutableHandleValue) -> bool {
_ZN2JS7MapKeysEP9JSContextNS_6HandleIP8JSObjectEENS_13MutableHandleINS_5ValueEEE(cx,
obj,
rval)
}
#[inline]
pub unsafe extern "C" fn MapValues(cx: *mut JSContext, obj: HandleObject,
rval: MutableHandleValue) -> bool {
_ZN2JS9MapValuesEP9JSContextNS_6HandleIP8JSObjectEENS_13MutableHandleINS_5ValueEEE(cx,
obj,
rval)
}
#[inline]
pub unsafe extern "C" fn MapEntries(cx: *mut JSContext, obj: HandleObject,
rval: MutableHandleValue) -> bool {
_ZN2JS10MapEntriesEP9JSContextNS_6HandleIP8JSObjectEENS_13MutableHandleINS_5ValueEEE(cx,
obj,
rval)
}
#[inline]
pub unsafe extern "C" fn MapForEach(cx: *mut JSContext, obj: HandleObject,
callbackFn: HandleValue,
thisVal: HandleValue) -> bool {
_ZN2JS10MapForEachEP9JSContextNS_6HandleIP8JSObjectEENS2_INS_5ValueEEES7_(cx,
obj,
callbackFn,
thisVal)
}
#[inline]
pub unsafe extern "C" fn NewSetObject(cx: *mut JSContext) -> *mut JSObject {
_ZN2JS12NewSetObjectEP9JSContext(cx)
}
#[inline]
pub unsafe extern "C" fn SetSize(cx: *mut JSContext, obj: HandleObject)
-> u32 {
_ZN2JS7SetSizeEP9JSContextNS_6HandleIP8JSObjectEE(cx, obj)
}
#[inline]
pub unsafe extern "C" fn SetHas(cx: *mut JSContext, obj: HandleObject,
key: HandleValue, rval: *mut bool) -> bool {
_ZN2JS6SetHasEP9JSContextNS_6HandleIP8JSObjectEENS2_INS_5ValueEEEPb(cx,
obj,
key,
rval)
}
#[inline]
pub unsafe extern "C" fn SetDelete(cx: *mut JSContext, obj: HandleObject,
key: HandleValue, rval: *mut bool)
-> bool {
_ZN2JS9SetDeleteEP9JSContextNS_6HandleIP8JSObjectEENS2_INS_5ValueEEEPb(cx,
obj,
key,
rval)
}
#[inline]
pub unsafe extern "C" fn SetAdd(cx: *mut JSContext, obj: HandleObject,
key: HandleValue) -> bool {
_ZN2JS6SetAddEP9JSContextNS_6HandleIP8JSObjectEENS2_INS_5ValueEEE(cx, obj,
key)
}
#[inline]
pub unsafe extern "C" fn SetClear(cx: *mut JSContext, obj: HandleObject)
-> bool {
_ZN2JS8SetClearEP9JSContextNS_6HandleIP8JSObjectEE(cx, obj)
}
#[inline]
pub unsafe extern "C" fn SetKeys(cx: *mut JSContext, obj: HandleObject,
rval: MutableHandleValue) -> bool {
_ZN2JS7SetKeysEP9JSContextNS_6HandleIP8JSObjectEENS_13MutableHandleINS_5ValueEEE(cx,
obj,
rval)
}
#[inline]
pub unsafe extern "C" fn SetValues(cx: *mut JSContext, obj: HandleObject,
rval: MutableHandleValue) -> bool {
_ZN2JS9SetValuesEP9JSContextNS_6HandleIP8JSObjectEENS_13MutableHandleINS_5ValueEEE(cx,
obj,
rval)
}
#[inline]
pub unsafe extern "C" fn SetEntries(cx: *mut JSContext, obj: HandleObject,
rval: MutableHandleValue) -> bool {
_ZN2JS10SetEntriesEP9JSContextNS_6HandleIP8JSObjectEENS_13MutableHandleINS_5ValueEEE(cx,
obj,
rval)
}
#[inline]
pub unsafe extern "C" fn SetForEach(cx: *mut JSContext, obj: HandleObject,
callbackFn: HandleValue,
thisVal: HandleValue) -> bool {
_ZN2JS10SetForEachEP9JSContextNS_6HandleIP8JSObjectEENS2_INS_5ValueEEES7_(cx,
obj,
callbackFn,
thisVal)
}
#[inline]
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)
}
#[inline]
pub unsafe extern "C" fn JS_NewDateObjectMsec(cx: *mut JSContext, msec: f64)
-> *mut JSObject {
_Z20JS_NewDateObjectMsecP9JSContextd(cx, msec)
}
#[inline]
pub unsafe extern "C" fn JS_ObjectIsDate(cx: *mut JSContext,
obj: HandleObject) -> bool {
_Z15JS_ObjectIsDateP9JSContextN2JS6HandleIP8JSObjectEE(cx, obj)
}
#[inline]
pub unsafe extern "C" fn JS_ClearDateCaches(cx: *mut JSContext) {
_Z18JS_ClearDateCachesP9JSContext(cx)
}
#[inline]
pub unsafe extern "C" fn JS_NewRegExpObject(cx: *mut JSContext,
obj: HandleObject,
bytes: *const ::libc::c_char,
length: size_t, flags: u32)
-> *mut JSObject {
_Z18JS_NewRegExpObjectP9JSContextN2JS6HandleIP8JSObjectEEPKcjj(cx, obj,
bytes,
length,
flags)
}
#[inline]
pub unsafe extern "C" fn JS_NewUCRegExpObject(cx: *mut JSContext,
obj: HandleObject,
chars: *const u16,
length: size_t, flags: u32)
-> *mut JSObject {
_Z20JS_NewUCRegExpObjectP9JSContextN2JS6HandleIP8JSObjectEEPKDsjj(cx, obj,
chars,
length,
flags)
}
#[inline]
pub unsafe extern "C" fn JS_SetRegExpInput(cx: *mut JSContext,
obj: HandleObject,
input: HandleString,
multiline: bool) -> bool {
_Z17JS_SetRegExpInputP9JSContextN2JS6HandleIP8JSObjectEENS2_IP8JSStringEEb(cx,
obj,
input,
multiline)
}
#[inline]
pub unsafe extern "C" fn JS_ClearRegExpStatics(cx: *mut JSContext,
obj: HandleObject) -> bool {
_Z21JS_ClearRegExpStaticsP9JSContextN2JS6HandleIP8JSObjectEE(cx, obj)
}
#[inline]
pub unsafe extern "C" fn JS_ExecuteRegExp(cx: *mut JSContext,
obj: HandleObject,
reobj: HandleObject,
chars: *mut u16, length: size_t,
indexp: *mut size_t, test: bool,
rval: MutableHandleValue) -> bool {
_Z16JS_ExecuteRegExpP9JSContextN2JS6HandleIP8JSObjectEES5_PDsjPjbNS1_13MutableHandleINS1_5ValueEEE(cx,
obj,
reobj,
chars,
length,
indexp,
test,
rval)
}
#[inline]
pub unsafe extern "C" fn JS_NewRegExpObjectNoStatics(cx: *mut JSContext,
bytes:
*mut ::libc::c_char,
length: size_t,
flags: u32)
-> *mut JSObject {
_Z27JS_NewRegExpObjectNoStaticsP9JSContextPcjj(cx, bytes, length, flags)
}
#[inline]
pub unsafe extern "C" fn JS_NewUCRegExpObjectNoStatics(cx: *mut JSContext,
chars: *mut u16,
length: size_t,
flags: u32)
-> *mut JSObject {
_Z29JS_NewUCRegExpObjectNoStaticsP9JSContextPDsjj(cx, chars, length,
flags)
}
#[inline]
pub unsafe extern "C" fn JS_ExecuteRegExpNoStatics(cx: *mut JSContext,
reobj: HandleObject,
chars: *mut u16,
length: size_t,
indexp: *mut size_t,
test: bool,
rval: MutableHandleValue)
-> bool {
_Z25JS_ExecuteRegExpNoStaticsP9JSContextN2JS6HandleIP8JSObjectEEPDsjPjbNS1_13MutableHandleINS1_5ValueEEE(cx,
reobj,
chars,
length,
indexp,
test,
rval)
}
#[inline]
pub unsafe extern "C" fn JS_ObjectIsRegExp(cx: *mut JSContext,
obj: HandleObject) -> bool {
_Z17JS_ObjectIsRegExpP9JSContextN2JS6HandleIP8JSObjectEE(cx, obj)
}
#[inline]
pub unsafe extern "C" fn JS_GetRegExpFlags(cx: *mut JSContext,
obj: HandleObject) -> u32 {
_Z17JS_GetRegExpFlagsP9JSContextN2JS6HandleIP8JSObjectEE(cx, obj)
}
#[inline]
pub unsafe extern "C" fn JS_GetRegExpSource(cx: *mut JSContext,
obj: HandleObject)
-> *mut JSString {
_Z18JS_GetRegExpSourceP9JSContextN2JS6HandleIP8JSObjectEE(cx, obj)
}
/************************************************************************/
#[inline]
pub unsafe extern "C" fn JS_IsExceptionPending(cx: *mut JSContext) -> bool {
_Z21JS_IsExceptionPendingP9JSContext(cx)
}
#[inline]
pub unsafe extern "C" fn JS_GetPendingException(cx: *mut JSContext,
vp: MutableHandleValue)
-> bool {
_Z22JS_GetPendingExceptionP9JSContextN2JS13MutableHandleINS1_5ValueEEE(cx,
vp)
}
#[inline]
pub unsafe extern "C" fn JS_SetPendingException(cx: *mut JSContext,
v: HandleValue) {
_Z22JS_SetPendingExceptionP9JSContextN2JS6HandleINS1_5ValueEEE(cx, v)
}
#[inline]
pub unsafe extern "C" fn JS_ClearPendingException(cx: *mut JSContext) {
_Z24JS_ClearPendingExceptionP9JSContext(cx)
}
#[inline]
pub unsafe extern "C" fn JS_ReportPendingException(cx: *mut JSContext)
-> bool {
_Z25JS_ReportPendingExceptionP9JSContext(cx)
}
#[inline]
pub unsafe extern "C" fn JS_SaveExceptionState(cx: *mut JSContext)
-> *mut JSExceptionState {
_Z21JS_SaveExceptionStateP9JSContext(cx)
}
#[inline]
pub unsafe extern "C" fn JS_RestoreExceptionState(cx: *mut JSContext,
state:
*mut JSExceptionState) {
_Z24JS_RestoreExceptionStateP9JSContextP16JSExceptionState(cx, state)
}
#[inline]
pub unsafe extern "C" fn JS_DropExceptionState(cx: *mut JSContext,
state: *mut JSExceptionState) {
_Z21JS_DropExceptionStateP9JSContextP16JSExceptionState(cx, state)
}
#[inline]
pub unsafe extern "C" fn JS_ErrorFromException(cx: *mut JSContext,
obj: HandleObject)
-> *mut JSErrorReport {
_Z21JS_ErrorFromExceptionP9JSContextN2JS6HandleIP8JSObjectEE(cx, obj)
}
#[inline]
pub unsafe extern "C" fn ExceptionStackOrNull(cx: *mut JSContext,
obj: HandleObject)
-> *mut JSObject {
_Z20ExceptionStackOrNullP9JSContextN2JS6HandleIP8JSObjectEE(cx, obj)
}
#[inline]
pub unsafe extern "C" fn JS_ThrowStopIteration(cx: *mut JSContext) -> bool {
_Z21JS_ThrowStopIterationP9JSContext(cx)
}
#[inline]
pub unsafe extern "C" fn JS_IsStopIteration(v: Value) -> bool {
_Z18JS_IsStopIterationN2JS5ValueE(v)
}
#[inline]
pub unsafe extern "C" fn JS_GetCurrentThread() -> intptr_t {
_Z19JS_GetCurrentThreadv()
}
#[inline]
pub unsafe extern "C" fn JS_AbortIfWrongThread(rt: *mut JSRuntime) {
_Z21JS_AbortIfWrongThreadP9JSRuntime(rt)
}
/************************************************************************/
#[inline]
pub unsafe extern "C" fn JS_NewObjectForConstructor(cx: *mut JSContext,
clasp: *const JSClass,
args: &CallArgs)
-> *mut JSObject {
_Z26JS_NewObjectForConstructorP9JSContextPK7JSClassRKN2JS8CallArgsE(cx,
clasp,
args)
}
#[inline]
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)
}
#[inline]
pub unsafe extern "C" fn JS_SetGCZeal(cx: *mut JSContext, zeal: u8,
frequency: u32) {
_Z12JS_SetGCZealP9JSContexthj(cx, zeal, frequency)
}
#[inline]
pub unsafe extern "C" fn JS_ScheduleGC(cx: *mut JSContext, count: u32) {
_Z13JS_ScheduleGCP9JSContextj(cx, count)
}
#[inline]
pub unsafe extern "C" fn JS_SetParallelParsingEnabled(rt: *mut JSRuntime,
enabled: bool) {
_Z28JS_SetParallelParsingEnabledP9JSRuntimeb(rt, enabled)
}
#[inline]
pub unsafe extern "C" fn JS_SetOffthreadIonCompilationEnabled(rt:
*mut JSRuntime,
enabled: bool) {
_Z36JS_SetOffthreadIonCompilationEnabledP9JSRuntimeb(rt, enabled)
}
#[inline]
pub unsafe extern "C" fn JS_SetGlobalJitCompilerOption(rt: *mut JSRuntime,
opt:
JSJitCompilerOption,
value: u32) {
_Z29JS_SetGlobalJitCompilerOptionP9JSRuntime19JSJitCompilerOptionj(rt,
opt,
value)
}
#[inline]
pub unsafe extern "C" fn JS_GetGlobalJitCompilerOption(rt: *mut JSRuntime,
opt:
JSJitCompilerOption)
-> i32 {
_Z29JS_GetGlobalJitCompilerOptionP9JSRuntime19JSJitCompilerOption(rt, opt)
}
#[inline]
pub unsafe extern "C" fn JS_IndexToId(cx: *mut JSContext, index: u32,
arg1: MutableHandleId) -> bool {
_Z12JS_IndexToIdP9JSContextjN2JS13MutableHandleI4jsidEE(cx, index, arg1)
}
#[inline]
pub unsafe extern "C" fn JS_CharsToId(cx: *mut JSContext, chars: TwoByteChars,
arg1: MutableHandleId) -> bool {
_Z12JS_CharsToIdP9JSContextN2JS12TwoByteCharsENS1_13MutableHandleI4jsidEE(cx,
chars,
arg1)
}
#[inline]
pub unsafe extern "C" fn JS_IsIdentifier(cx: *mut JSContext,
str: HandleString,
isIdentifier: *mut bool) -> bool {
_Z15JS_IsIdentifierP9JSContextN2JS6HandleIP8JSStringEEPb(cx, str,
isIdentifier)
}
#[inline]
pub unsafe extern "C" fn JS_IsIdentifier1(chars: *const u16, length: size_t)
-> bool {
_Z15JS_IsIdentifierPKDsj(chars, length)
}
#[inline]
pub unsafe extern "C" fn DescribeScriptedCaller(cx: *mut JSContext,
filename: *mut AutoFilename,
lineno: *mut u32) -> bool {
_ZN2JS22DescribeScriptedCallerEP9JSContextPNS_12AutoFilenameEPj(cx,
filename,
lineno)
}
#[inline]
pub unsafe extern "C" fn GetScriptedCallerGlobal(cx: *mut JSContext)
-> *mut JSObject {
_ZN2JS23GetScriptedCallerGlobalEP9JSContext(cx)
}
#[inline]
pub unsafe extern "C" fn HideScriptedCaller(cx: *mut JSContext) {
_ZN2JS18HideScriptedCallerEP9JSContext(cx)
}
#[inline]
pub unsafe extern "C" fn UnhideScriptedCaller(cx: *mut JSContext) {
_ZN2JS20UnhideScriptedCallerEP9JSContext(cx)
}
#[inline]
pub unsafe extern "C" fn JS_EncodeScript(cx: *mut JSContext,
script: HandleScript,
lengthp: *mut u32)
-> *mut ::libc::c_void {
_Z15JS_EncodeScriptP9JSContextN2JS6HandleIP8JSScriptEEPj(cx, script,
lengthp)
}
#[inline]
pub unsafe extern "C" fn JS_EncodeInterpretedFunction(cx: *mut JSContext,
funobj: HandleObject,
lengthp: *mut u32)
-> *mut ::libc::c_void {
_Z28JS_EncodeInterpretedFunctionP9JSContextN2JS6HandleIP8JSObjectEEPj(cx,
funobj,
lengthp)
}
#[inline]
pub unsafe extern "C" fn JS_DecodeScript(cx: *mut JSContext,
data: *const ::libc::c_void,
length: u32) -> *mut JSScript {
_Z15JS_DecodeScriptP9JSContextPKvj(cx, data, length)
}
#[inline]
pub unsafe extern "C" fn JS_DecodeInterpretedFunction(cx: *mut JSContext,
data:
*const ::libc::c_void,
length: u32)
-> *mut JSObject {
_Z28JS_DecodeInterpretedFunctionP9JSContextPKvj(cx, data, length)
}
#[inline]
pub unsafe extern "C" fn SetAsmJSCacheOps(rt: *mut JSRuntime,
callbacks: *const AsmJSCacheOps) {
_ZN2JS16SetAsmJSCacheOpsEP9JSRuntimePKNS_13AsmJSCacheOpsE(rt, callbacks)
}
#[inline]
pub unsafe extern "C" fn SetLargeAllocationFailureCallback(rt: *mut JSRuntime,
afc:
LargeAllocationFailureCallback,
data:
*mut ::libc::c_void) {
_ZN2JS33SetLargeAllocationFailureCallbackEP9JSRuntimePFvPvES2_(rt, afc,
data)
}
#[inline]
pub unsafe extern "C" fn SetOutOfMemoryCallback(rt: *mut JSRuntime,
cb: OutOfMemoryCallback,
data: *mut ::libc::c_void) {
_ZN2JS22SetOutOfMemoryCallbackEP9JSRuntimePFvP9JSContextPvES4_(rt, cb,
data)
}
#[inline]
pub unsafe extern "C" fn CaptureCurrentStack(cx: *mut JSContext,
stackp: MutableHandleObject,
maxFrameCount: u32) -> bool {
_ZN2JS19CaptureCurrentStackEP9JSContextNS_13MutableHandleIP8JSObjectEEj(cx,
stackp,
maxFrameCount)
}
#[inline]
pub unsafe extern "C" fn GetSavedFrameSource(cx: *mut JSContext,
savedFrame: HandleObject,
sourcep: MutableHandleString)
-> SavedFrameResult {
_ZN2JS19GetSavedFrameSourceEP9JSContextNS_6HandleIP8JSObjectEENS_13MutableHandleIP8JSStringEE(cx,
savedFrame,
sourcep)
}
#[inline]
pub unsafe extern "C" fn GetSavedFrameLine(cx: *mut JSContext,
savedFrame: HandleObject,
linep: *mut u32)
-> SavedFrameResult {
_ZN2JS17GetSavedFrameLineEP9JSContextNS_6HandleIP8JSObjectEEPj(cx,
savedFrame,
linep)
}
#[inline]
pub unsafe extern "C" fn GetSavedFrameColumn(cx: *mut JSContext,
savedFrame: HandleObject,
columnp: *mut u32)
-> SavedFrameResult {
_ZN2JS19GetSavedFrameColumnEP9JSContextNS_6HandleIP8JSObjectEEPj(cx,
savedFrame,
columnp)
}
#[inline]
pub unsafe extern "C" fn GetSavedFrameFunctionDisplayName(cx: *mut JSContext,
savedFrame:
HandleObject,
namep:
MutableHandleString)
-> SavedFrameResult {
_ZN2JS32GetSavedFrameFunctionDisplayNameEP9JSContextNS_6HandleIP8JSObjectEENS_13MutableHandleIP8JSStringEE(cx,
savedFrame,
namep)
}
#[inline]
pub unsafe extern "C" fn GetSavedFrameAsyncCause(cx: *mut JSContext,
savedFrame: HandleObject,
asyncCausep:
MutableHandleString)
-> SavedFrameResult {
_ZN2JS23GetSavedFrameAsyncCauseEP9JSContextNS_6HandleIP8JSObjectEENS_13MutableHandleIP8JSStringEE(cx,
savedFrame,
asyncCausep)
}
#[inline]
pub unsafe extern "C" fn GetSavedFrameAsyncParent(cx: *mut JSContext,
savedFrame: HandleObject,
asyncParentp:
MutableHandleObject)
-> SavedFrameResult {
_ZN2JS24GetSavedFrameAsyncParentEP9JSContextNS_6HandleIP8JSObjectEENS_13MutableHandleIS4_EE(cx,
savedFrame,
asyncParentp)
}
#[inline]
pub unsafe extern "C" fn GetSavedFrameParent(cx: *mut JSContext,
savedFrame: HandleObject,
parentp: MutableHandleObject)
-> SavedFrameResult {
_ZN2JS19GetSavedFrameParentEP9JSContextNS_6HandleIP8JSObjectEENS_13MutableHandleIS4_EE(cx,
savedFrame,
parentp)
}
#[inline]
pub unsafe extern "C" fn BuildStackString(cx: *mut JSContext,
stack: HandleObject,
stringp: MutableHandleString)
-> bool {
_ZN2JS16BuildStackStringEP9JSContextNS_6HandleIP8JSObjectEENS_13MutableHandleIP8JSStringEE(cx,
stack,
stringp)
}
/**
* Reset any stopwatch currently measuring.
*
* This function is designed to be called when we process a new event.
*/
#[inline]
pub unsafe extern "C" fn ResetStopwatches(arg1: *mut JSRuntime) {
_ZN2js16ResetStopwatchesEP9JSRuntime(arg1)
}
/**
* Turn on/off stopwatch-based CPU monitoring.
*
* `SetStopwatchIsMonitoringCPOW` or `SetStopwatchIsMonitoringJank`
* may return `false` if monitoring could not be activated, which may
* happen if we are out of memory.
*/
#[inline]
pub unsafe extern "C" fn SetStopwatchIsMonitoringCPOW(arg1: *mut JSRuntime,
arg2: bool) -> bool {
_ZN2js28SetStopwatchIsMonitoringCPOWEP9JSRuntimeb(arg1, arg2)
}
#[inline]
pub unsafe extern "C" fn GetStopwatchIsMonitoringCPOW(arg1: *mut JSRuntime)
-> bool {
_ZN2js28GetStopwatchIsMonitoringCPOWEP9JSRuntime(arg1)
}
#[inline]
pub unsafe extern "C" fn SetStopwatchIsMonitoringJank(arg1: *mut JSRuntime,
arg2: bool) -> bool {
_ZN2js28SetStopwatchIsMonitoringJankEP9JSRuntimeb(arg1, arg2)
}
#[inline]
pub unsafe extern "C" fn GetStopwatchIsMonitoringJank(arg1: *mut JSRuntime)
-> bool {
_ZN2js28GetStopwatchIsMonitoringJankEP9JSRuntime(arg1)
}
#[inline]
pub unsafe extern "C" fn IsStopwatchActive(arg1: *mut JSRuntime) -> bool {
_ZN2js17IsStopwatchActiveEP9JSRuntime(arg1)
}
/**
* Access the performance information stored in a compartment.
*/
#[inline]
pub unsafe extern "C" fn GetPerformanceData(arg1: *mut JSRuntime)
-> *mut PerformanceData {
_ZN2js18GetPerformanceDataEP9JSRuntime(arg1)
}
/**
* Extract the performance statistics.
*
* Note that before calling `walker`, we enter the corresponding context.
*/
#[inline]
pub unsafe extern "C" fn IterPerformanceStats(cx: *mut JSContext,
walker:
*mut PerformanceStatsWalker,
process: *mut PerformanceData,
closure: *mut ::libc::c_void)
-> bool {
_ZN2js20IterPerformanceStatsEP9JSContextPFbS1_RKNS_15PerformanceDataEyPvEPS2_S5_(cx,
walker,
process,
closure)
}
/**
* Callback used to ask the embedding to determine in which
* Performance Group a compartment belongs. Typically, this is used to
* regroup JSCompartments from several iframes from the same page or
* from several compartments of the same addon into a single
* Performance Group.
*
* Returns an opaque key.
*/
#[inline]
pub unsafe extern "C" fn JS_SetCurrentPerfGroupCallback(rt: *mut JSRuntime,
cb:
JSCurrentPerfGroupCallback) {
_Z30JS_SetCurrentPerfGroupCallbackP9JSRuntimePFPvP9JSContextE(rt, cb)
}
#[inline]
pub unsafe extern "C" fn CallMethodIfWrapped(cx: *mut JSContext,
test: IsAcceptableThis,
_impl: NativeImpl,
args: CallArgs) -> bool {
_ZN2JS6detail19CallMethodIfWrappedEP9JSContextPFbNS_6HandleINS_5ValueEEEEPFbS2_NS_8CallArgsEES8_(cx,
test,
_impl,
args)
}
#[inline]
pub unsafe extern "C" fn CallNonGenericMethod(cx: *mut JSContext,
Test: IsAcceptableThis,
Impl: NativeImpl,
args: CallArgs) -> bool {
_ZN2JS20CallNonGenericMethodEP9JSContextPFbNS_6HandleINS_5ValueEEEEPFbS1_NS_8CallArgsEES7_(cx,
Test,
Impl,
args)
}
#[inline]
pub unsafe extern "C" fn JS_SetGrayGCRootsTracer(rt: *mut JSRuntime,
traceOp: JSTraceDataOp,
data: *mut ::libc::c_void) {
_Z23JS_SetGrayGCRootsTracerP9JSRuntimePFvP8JSTracerPvES3_(rt, traceOp,
data)
}
#[inline]
pub unsafe extern "C" fn JS_FindCompilationScope(cx: *mut JSContext,
obj: HandleObject)
-> *mut JSObject {
_Z23JS_FindCompilationScopeP9JSContextN2JS6HandleIP8JSObjectEE(cx, obj)
}
#[inline]
pub unsafe extern "C" fn JS_GetObjectFunction(obj: *mut JSObject)
-> *mut JSFunction {
_Z20JS_GetObjectFunctionP8JSObject(obj)
}
#[inline]
pub unsafe extern "C" fn JS_SplicePrototype(cx: *mut JSContext,
obj: HandleObject,
proto: HandleObject) -> bool {
_Z18JS_SplicePrototypeP9JSContextN2JS6HandleIP8JSObjectEES5_(cx, obj,
proto)
}
#[inline]
pub unsafe extern "C" fn JS_NewObjectWithUniqueType(cx: *mut JSContext,
clasp: *const JSClass,
proto: HandleObject)
-> *mut JSObject {
_Z26JS_NewObjectWithUniqueTypeP9JSContextPK7JSClassN2JS6HandleIP8JSObjectEE(cx,
clasp,
proto)
}
#[inline]
pub unsafe extern "C" fn JS_NewObjectWithoutMetadata(cx: *mut JSContext,
clasp: *const JSClass,
proto:
Handle<*mut JSObject>)
-> *mut JSObject {
_Z27JS_NewObjectWithoutMetadataP9JSContextPK7JSClassN2JS6HandleIP8JSObjectEE(cx,
clasp,
proto)
}
#[inline]
pub unsafe extern "C" fn JS_ObjectCountDynamicSlots(obj: HandleObject)
-> u32 {
_Z26JS_ObjectCountDynamicSlotsN2JS6HandleIP8JSObjectEE(obj)
}
#[inline]
pub unsafe extern "C" fn JS_SetProtoCalled(cx: *mut JSContext) -> size_t {
_Z17JS_SetProtoCalledP9JSContext(cx)
}
#[inline]
pub unsafe extern "C" fn JS_GetCustomIteratorCount(cx: *mut JSContext)
-> size_t {
_Z25JS_GetCustomIteratorCountP9JSContext(cx)
}
#[inline]
pub unsafe extern "C" fn JS_NondeterministicGetWeakMapKeys(cx: *mut JSContext,
obj: HandleObject,
ret:
MutableHandleObject)
-> bool {
_Z33JS_NondeterministicGetWeakMapKeysP9JSContextN2JS6HandleIP8JSObjectEENS1_13MutableHandleIS4_EE(cx,
obj,
ret)
}
#[inline]
pub unsafe extern "C" fn JS_PCToLineNumber(script: *mut JSScript,
pc: *mut jsbytecode,
columnp: *mut u32) -> u32 {
_Z17JS_PCToLineNumberP8JSScriptPhPj(script, pc, columnp)
}
#[inline]
pub unsafe extern "C" fn JS_IsDeadWrapper(obj: *mut JSObject) -> bool {
_Z16JS_IsDeadWrapperP8JSObject(obj)
}
#[inline]
pub unsafe extern "C" fn JS_TraceShapeCycleCollectorChildren(trc:
*mut CallbackTracer,
shape:
GCCellPtr) {
_Z35JS_TraceShapeCycleCollectorChildrenPN2JS14CallbackTracerENS_9GCCellPtrE(trc,
shape)
}
#[inline]
pub unsafe extern "C" fn JS_TraceObjectGroupCycleCollectorChildren(trc:
*mut CallbackTracer,
group:
GCCellPtr) {
_Z41JS_TraceObjectGroupCycleCollectorChildrenPN2JS14CallbackTracerENS_9GCCellPtrE(trc,
group)
}
#[inline]
pub unsafe extern "C" fn JS_SetAccumulateTelemetryCallback(rt: *mut JSRuntime,
callback:
JSAccumulateTelemetryDataCallback) {
_Z33JS_SetAccumulateTelemetryCallbackP9JSRuntimePFvijPKcE(rt, callback)
}
#[inline]
pub unsafe extern "C" fn JS_GetCompartmentPrincipals(compartment:
*mut JSCompartment)
-> *mut JSPrincipals {
_Z27JS_GetCompartmentPrincipalsP13JSCompartment(compartment)
}
#[inline]
pub unsafe extern "C" fn JS_SetCompartmentPrincipals(compartment:
*mut JSCompartment,
principals:
*mut JSPrincipals) {
_Z27JS_SetCompartmentPrincipalsP13JSCompartmentP12JSPrincipals(compartment,
principals)
}
#[inline]
pub unsafe extern "C" fn JS_GetScriptPrincipals(script: *mut JSScript)
-> *mut JSPrincipals {
_Z22JS_GetScriptPrincipalsP8JSScript(script)
}
#[inline]
pub unsafe extern "C" fn JS_ScriptHasMutedErrors(script: *mut JSScript)
-> bool {
_Z23JS_ScriptHasMutedErrorsP8JSScript(script)
}
#[inline]
pub unsafe extern "C" fn JS_ObjectToInnerObject(cx: *mut JSContext,
obj: HandleObject)
-> *mut JSObject {
_Z22JS_ObjectToInnerObjectP9JSContextN2JS6HandleIP8JSObjectEE(cx, obj)
}
#[inline]
pub unsafe extern "C" fn JS_ObjectToOuterObject(cx: *mut JSContext,
obj: HandleObject)
-> *mut JSObject {
_Z22JS_ObjectToOuterObjectP9JSContextN2JS6HandleIP8JSObjectEE(cx, obj)
}
#[inline]
pub unsafe extern "C" fn JS_CloneObject(cx: *mut JSContext, obj: HandleObject,
proto: HandleObject)
-> *mut JSObject {
_Z14JS_CloneObjectP9JSContextN2JS6HandleIP8JSObjectEES5_(cx, obj, proto)
}
#[inline]
pub unsafe extern "C" fn JS_InitializePropertiesFromCompatibleNativeObject(cx:
*mut JSContext,
dst:
HandleObject,
src:
HandleObject)
-> bool {
_Z49JS_InitializePropertiesFromCompatibleNativeObjectP9JSContextN2JS6HandleIP8JSObjectEES5_(cx,
dst,
src)
}
#[inline]
pub unsafe extern "C" fn JS_BasicObjectToString(cx: *mut JSContext,
obj: HandleObject)
-> *mut JSString {
_Z22JS_BasicObjectToStringP9JSContextN2JS6HandleIP8JSObjectEE(cx, obj)
}
#[inline]
pub unsafe extern "C" fn ObjectClassIs1(cx: *mut JSContext, obj: HandleObject,
classValue: ESClassValue) -> bool {
_ZN2js13ObjectClassIsEP9JSContextN2JS6HandleIP8JSObjectEENS_12ESClassValueE(cx,
obj,
classValue)
}
#[inline]
pub unsafe extern "C" fn ObjectClassName(cx: *mut JSContext,
obj: HandleObject)
-> *const ::libc::c_char {
_ZN2js15ObjectClassNameEP9JSContextN2JS6HandleIP8JSObjectEE(cx, obj)
}
#[inline]
pub unsafe extern "C" fn ReportOverRecursed(maybecx: *mut JSContext) {
_ZN2js18ReportOverRecursedEP9JSContext(maybecx)
}
#[inline]
pub unsafe extern "C" fn AddRawValueRoot(cx: *mut JSContext, vp: *mut Value,
name: *const ::libc::c_char)
-> bool {
_ZN2js15AddRawValueRootEP9JSContextPN2JS5ValueEPKc(cx, vp, name)
}
#[inline]
pub unsafe extern "C" fn RemoveRawValueRoot(cx: *mut JSContext,
vp: *mut Value) {
_ZN2js18RemoveRawValueRootEP9JSContextPN2JS5ValueE(cx, vp)
}
#[inline]
pub unsafe extern "C" fn GetPropertyNameFromPC(script: *mut JSScript,
pc: *mut jsbytecode)
-> *mut JSAtom {
_ZN2js21GetPropertyNameFromPCEP8JSScriptPh(script, pc)
}
#[inline]
pub unsafe extern "C" fn DumpBacktrace(cx: *mut JSContext) {
_ZN2js13DumpBacktraceEP9JSContext(cx)
}
#[inline]
pub unsafe extern "C" fn FormatStackDump(cx: *mut JSContext,
buf: *mut ::libc::c_char,
showArgs: bool, showLocals: bool,
showThisProps: bool)
-> *mut ::libc::c_char {
_ZN2JS15FormatStackDumpEP9JSContextPcbbb(cx, buf, showArgs, showLocals,
showThisProps)
}
#[inline]
pub unsafe extern "C" fn JS_CopyPropertiesFrom(cx: *mut JSContext,
target: HandleObject,
obj: HandleObject) -> bool {
_Z21JS_CopyPropertiesFromP9JSContextN2JS6HandleIP8JSObjectEES5_(cx,
target,
obj)
}
#[inline]
pub unsafe extern "C" fn JS_CopyPropertyFrom(cx: *mut JSContext, id: HandleId,
target: HandleObject,
obj: HandleObject,
copyBehavior:
PropertyCopyBehavior)
-> bool {
_Z19JS_CopyPropertyFromP9JSContextN2JS6HandleI4jsidEENS2_IP8JSObjectEES7_20PropertyCopyBehavior(cx,
id,
target,
obj,
copyBehavior)
}
#[inline]
pub unsafe extern "C" fn JS_WrapPropertyDescriptor(cx: *mut JSContext,
desc:
MutableHandle<JSPropertyDescriptor>)
-> bool {
_Z25JS_WrapPropertyDescriptorP9JSContextN2JS13MutableHandleI20JSPropertyDescriptorEE(cx,
desc)
}
#[inline]
pub unsafe extern "C" fn JS_DefineFunctionsWithHelp(cx: *mut JSContext,
obj: HandleObject,
fs:
*const JSFunctionSpecWithHelp)
-> bool {
_Z26JS_DefineFunctionsWithHelpP9JSContextN2JS6HandleIP8JSObjectEEPK22JSFunctionSpecWithHelp(cx,
obj,
fs)
}
#[inline]
pub unsafe extern "C" fn proxy_LookupProperty(cx: *mut JSContext,
obj: HandleObject, id: HandleId,
objp: MutableHandleObject,
propp:
MutableHandle<*mut Shape>)
-> bool {
_ZN2js20proxy_LookupPropertyEP9JSContextN2JS6HandleIP8JSObjectEENS3_I4jsidEENS2_13MutableHandleIS5_EENS9_IPNS_5ShapeEEE(cx,
obj,
id,
objp,
propp)
}
#[inline]
pub unsafe extern "C" fn proxy_DefineProperty(cx: *mut JSContext,
obj: HandleObject, id: HandleId,
desc:
Handle<JSPropertyDescriptor>,
result: &mut ObjectOpResult)
-> bool {
_ZN2js20proxy_DefinePropertyEP9JSContextN2JS6HandleIP8JSObjectEENS3_I4jsidEENS3_I20JSPropertyDescriptorEERNS2_14ObjectOpResultE(cx,
obj,
id,
desc,
result)
}
#[inline]
pub unsafe extern "C" fn proxy_HasProperty(cx: *mut JSContext,
obj: HandleObject, id: HandleId,
foundp: *mut bool) -> bool {
_ZN2js17proxy_HasPropertyEP9JSContextN2JS6HandleIP8JSObjectEENS3_I4jsidEEPb(cx,
obj,
id,
foundp)
}
#[inline]
pub unsafe extern "C" fn proxy_GetProperty(cx: *mut JSContext,
obj: HandleObject,
receiver: HandleObject,
id: HandleId,
vp: MutableHandleValue) -> bool {
_ZN2js17proxy_GetPropertyEP9JSContextN2JS6HandleIP8JSObjectEES6_NS3_I4jsidEENS2_13MutableHandleINS2_5ValueEEE(cx,
obj,
receiver,
id,
vp)
}
#[inline]
pub unsafe extern "C" fn proxy_SetProperty(cx: *mut JSContext,
obj: HandleObject, id: HandleId,
bp: HandleValue,
receiver: HandleValue,
result: &mut ObjectOpResult)
-> bool {
_ZN2js17proxy_SetPropertyEP9JSContextN2JS6HandleIP8JSObjectEENS3_I4jsidEENS3_INS2_5ValueEEESA_RNS2_14ObjectOpResultE(cx,
obj,
id,
bp,
receiver,
result)
}
#[inline]
pub unsafe extern "C" fn proxy_GetOwnPropertyDescriptor(cx: *mut JSContext,
obj: HandleObject,
id: HandleId,
desc:
MutableHandle<JSPropertyDescriptor>)
-> bool {
_ZN2js30proxy_GetOwnPropertyDescriptorEP9JSContextN2JS6HandleIP8JSObjectEENS3_I4jsidEENS2_13MutableHandleI20JSPropertyDescriptorEE(cx,
obj,
id,
desc)
}
#[inline]
pub unsafe extern "C" fn proxy_DeleteProperty(cx: *mut JSContext,
obj: HandleObject, id: HandleId,
result: &mut ObjectOpResult)
-> bool {
_ZN2js20proxy_DeletePropertyEP9JSContextN2JS6HandleIP8JSObjectEENS3_I4jsidEERNS2_14ObjectOpResultE(cx,
obj,
id,
result)
}
#[inline]
pub unsafe extern "C" fn proxy_Trace(trc: *mut JSTracer, obj: *mut JSObject) {
_ZN2js11proxy_TraceEP8JSTracerP8JSObject(trc, obj)
}
#[inline]
pub unsafe extern "C" fn proxy_WeakmapKeyDelegate(obj: *mut JSObject)
-> *mut JSObject {
_ZN2js24proxy_WeakmapKeyDelegateEP8JSObject(obj)
}
#[inline]
pub unsafe extern "C" fn proxy_Convert(cx: *mut JSContext,
proxy: HandleObject, hint: JSType,
vp: MutableHandleValue) -> bool {
_ZN2js13proxy_ConvertEP9JSContextN2JS6HandleIP8JSObjectEE6JSTypeNS2_13MutableHandleINS2_5ValueEEE(cx,
proxy,
hint,
vp)
}
#[inline]
pub unsafe extern "C" fn proxy_Finalize(fop: *mut FreeOp,
obj: *mut JSObject) {
_ZN2js14proxy_FinalizeEPNS_6FreeOpEP8JSObject(fop, obj)
}
#[inline]
pub unsafe extern "C" fn proxy_ObjectMoved(obj: *mut JSObject,
old: *const JSObject) {
_ZN2js17proxy_ObjectMovedEP8JSObjectPKS0_(obj, old)
}
#[inline]
pub unsafe extern "C" fn proxy_HasInstance(cx: *mut JSContext,
proxy: HandleObject,
v: MutableHandleValue,
bp: *mut bool) -> bool {
_ZN2js17proxy_HasInstanceEP9JSContextN2JS6HandleIP8JSObjectEENS2_13MutableHandleINS2_5ValueEEEPb(cx,
proxy,
v,
bp)
}
#[inline]
pub unsafe extern "C" fn proxy_Call(cx: *mut JSContext, argc: u32,
vp: *mut Value) -> bool {
_ZN2js10proxy_CallEP9JSContextjPN2JS5ValueE(cx, argc, vp)
}
#[inline]
pub unsafe extern "C" fn proxy_Construct(cx: *mut JSContext, argc: u32,
vp: *mut Value) -> bool {
_ZN2js15proxy_ConstructEP9JSContextjPN2JS5ValueE(cx, argc, vp)
}
#[inline]
pub unsafe extern "C" fn proxy_innerObject(obj: *mut JSObject)
-> *mut JSObject {
_ZN2js17proxy_innerObjectEP8JSObject(obj)
}
#[inline]
pub unsafe extern "C" fn proxy_Watch(cx: *mut JSContext, obj: HandleObject,
id: HandleId, callable: HandleObject)
-> bool {
_ZN2js11proxy_WatchEP9JSContextN2JS6HandleIP8JSObjectEENS3_I4jsidEES6_(cx,
obj,
id,
callable)
}
#[inline]
pub unsafe extern "C" fn proxy_Unwatch(cx: *mut JSContext, obj: HandleObject,
id: HandleId) -> bool {
_ZN2js13proxy_UnwatchEP9JSContextN2JS6HandleIP8JSObjectEENS3_I4jsidEE(cx,
obj,
id)
}
#[inline]
pub unsafe extern "C" fn proxy_GetElements(cx: *mut JSContext,
proxy: HandleObject, begin: u32,
end: u32, adder: *mut ElementAdder)
-> bool {
_ZN2js17proxy_GetElementsEP9JSContextN2JS6HandleIP8JSObjectEEjjPNS_12ElementAdderE(cx,
proxy,
begin,
end,
adder)
}
#[inline]
pub unsafe extern "C" fn SetSourceHook(rt: *mut JSRuntime,
hook:
UniquePtr<SourceHook,
DefaultDelete<SourceHook>>) {
_ZN2js13SetSourceHookEP9JSRuntimeN7mozilla9UniquePtrINS_10SourceHookENS2_13DefaultDeleteIS4_EEEE(rt,
hook)
}
#[inline]
pub unsafe extern "C" fn ForgetSourceHook(rt: *mut JSRuntime)
-> UniquePtr<SourceHook, DefaultDelete<SourceHook>> {
_ZN2js16ForgetSourceHookEP9JSRuntime(rt)
}
#[inline]
pub unsafe extern "C" fn GetCompartmentZone(comp: *mut JSCompartment)
-> *mut Zone {
_ZN2js18GetCompartmentZoneEP13JSCompartment(comp)
}
#[inline]
pub unsafe extern "C" fn DumpHeap(rt: *mut JSRuntime, fp: *mut FILE,
nurseryBehaviour:
DumpHeapNurseryBehaviour) {
_ZN2js8DumpHeapEP9JSRuntimeP8_IO_FILENS_24DumpHeapNurseryBehaviourE(rt,
fp,
nurseryBehaviour)
}
#[inline]
pub unsafe extern "C" fn obj_defineGetter(cx: *mut JSContext, argc: u32,
vp: *mut Value) -> bool {
_ZN2js16obj_defineGetterEP9JSContextjPN2JS5ValueE(cx, argc, vp)
}
#[inline]
pub unsafe extern "C" fn obj_defineSetter(cx: *mut JSContext, argc: u32,
vp: *mut Value) -> bool {
_ZN2js16obj_defineSetterEP9JSContextjPN2JS5ValueE(cx, argc, vp)
}
#[inline]
pub unsafe extern "C" fn IsSystemCompartment(comp: *mut JSCompartment)
-> bool {
_ZN2js19IsSystemCompartmentEP13JSCompartment(comp)
}
#[inline]
pub unsafe extern "C" fn IsSystemZone(zone: *mut Zone) -> bool {
_ZN2js12IsSystemZoneEPN2JS4ZoneE(zone)
}
#[inline]
pub unsafe extern "C" fn IsAtomsCompartment(comp: *mut JSCompartment)
-> bool {
_ZN2js18IsAtomsCompartmentEP13JSCompartment(comp)
}
#[inline]
pub unsafe extern "C" fn IsAtomsZone(zone: *mut Zone) -> bool {
_ZN2js11IsAtomsZoneEPN2JS4ZoneE(zone)
}
#[inline]
pub unsafe extern "C" fn TraceWeakMaps(trc: *mut WeakMapTracer) {
_ZN2js13TraceWeakMapsEPNS_13WeakMapTracerE(trc)
}
#[inline]
pub unsafe extern "C" fn AreGCGrayBitsValid(rt: *mut JSRuntime) -> bool {
_ZN2js18AreGCGrayBitsValidEP9JSRuntime(rt)
}
#[inline]
pub unsafe extern "C" fn ZoneGlobalsAreAllGray(zone: *mut Zone) -> bool {
_ZN2js21ZoneGlobalsAreAllGrayEPN2JS4ZoneE(zone)
}
#[inline]
pub unsafe extern "C" fn VisitGrayWrapperTargets(zone: *mut Zone,
callback: GCThingCallback,
closure:
*mut ::libc::c_void) {
_ZN2js23VisitGrayWrapperTargetsEPN2JS4ZoneEPFvPvNS0_9GCCellPtrEES3_(zone,
callback,
closure)
}
#[inline]
pub unsafe extern "C" fn GetWeakmapKeyDelegate(key: *mut JSObject)
-> *mut JSObject {
_ZN2js21GetWeakmapKeyDelegateEP8JSObject(key)
}
#[inline]
pub unsafe extern "C" fn GCThingTraceKind(thing: *mut ::libc::c_void)
-> TraceKind {
_ZN2js16GCThingTraceKindEPv(thing)
}
#[inline]
pub unsafe extern "C" fn IterateGrayObjects(zone: *mut Zone,
cellCallback: GCThingCallback,
data: *mut ::libc::c_void) {
_ZN2js18IterateGrayObjectsEPN2JS4ZoneEPFvPvNS0_9GCCellPtrEES3_(zone,
cellCallback,
data)
}
#[inline]
pub unsafe extern "C" fn SizeOfDataIfCDataObject(mallocSizeOf: MallocSizeOf,
obj: *mut JSObject)
-> size_t {
_ZN2js23SizeOfDataIfCDataObjectEPFjPKvEP8JSObject(mallocSizeOf, obj)
}
#[inline]
pub unsafe extern "C" fn GetAnyCompartmentInZone(zone: *mut Zone)
-> *mut JSCompartment {
_ZN2js23GetAnyCompartmentInZoneEPN2JS4ZoneE(zone)
}
#[inline]
pub unsafe extern "C" fn GetObjectClass(obj: *const JSObject)
-> *const Class {
_ZN2js14GetObjectClassEPK8JSObject(obj)
}
#[inline]
pub unsafe extern "C" fn GetObjectJSClass(obj: *mut JSObject)
-> *const JSClass {
_ZN2js16GetObjectJSClassEP8JSObject(obj)
}
#[inline]
pub unsafe extern "C" fn ProtoKeyToClass(key: JSProtoKey) -> *const Class {
_ZN2js15ProtoKeyToClassE10JSProtoKey(key)
}
#[inline]
pub unsafe extern "C" fn StandardClassIsDependent(key: JSProtoKey) -> bool {
_ZN2js24StandardClassIsDependentE10JSProtoKey(key)
}
#[inline]
pub unsafe extern "C" fn ParentKeyForStandardClass(key: JSProtoKey)
-> JSProtoKey {
_ZN2js25ParentKeyForStandardClassE10JSProtoKey(key)
}
#[inline]
pub unsafe extern "C" fn IsInnerObject(
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment