The Tor Browser / file revision

 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-

  * vim: set ts=8 sts=4 et sw=4 tw=99:

  * This Source Code Form is subject to the terms of the Mozilla Public

  * License, v. 2.0. If a copy of the MPL was not distributed with this

  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

 /* JavaScript API. */

 #ifndef jsapi_h

 #define jsapi_h

 #include "mozilla/FloatingPoint.h"

 #include "mozilla/MemoryReporting.h"

 #include "mozilla/RangedPtr.h"

 #include <stdarg.h>

 #include <stddef.h>

 #include <stdint.h>

 #include <stdio.h>

 #include "jsalloc.h"

 #include "jspubtd.h"

 #include "js/CallArgs.h"

 #include "js/Class.h"

 #include "js/HashTable.h"

 #include "js/Id.h"

 #include "js/Principals.h"

 #include "js/RootingAPI.h"

 #include "js/TracingAPI.h"

 #include "js/Utility.h"

 #include "js/Value.h"

 #include "js/Vector.h"

 /************************************************************************/

 namespace JS {

 class Latin1CharsZ;

 class TwoByteChars;

 #if defined JS_THREADSAFE && defined JS_DEBUG

 class JS_PUBLIC_API(AutoCheckRequestDepth)

 {

     JSContext *cx;

   public:

     AutoCheckRequestDepth(JSContext *cx);

     AutoCheckRequestDepth(js::ContextFriendFields *cx);

     ~AutoCheckRequestDepth();

 };

 # define CHECK_REQUEST(cx) \

     JS::AutoCheckRequestDepth _autoCheckRequestDepth(cx)

 #else

 # define CHECK_REQUEST(cx) \

     ((void) 0)

 #endif /* JS_THREADSAFE && JS_DEBUG */

 #ifdef JS_DEBUG

 /*

  * Assert that we're not doing GC on cx, that we're in a request as

  * needed, and that the compartments for cx and v are correct.

  * Also check that GC would be safe at this point.

  */

 JS_PUBLIC_API(void)

 AssertArgumentsAreSane(JSContext *cx, JS::HandleValue v);

 #else

 inline void AssertArgumentsAreSane(JSContext *cx, JS::HandleValue v) {

     /* Do nothing */

 }

 #endif /* JS_DEBUG */

 class JS_PUBLIC_API(AutoGCRooter) {

   public:

     AutoGCRooter(JSContext *cx, ptrdiff_t tag);

     AutoGCRooter(js::ContextFriendFields *cx, ptrdiff_t tag);

     ~AutoGCRooter() {

         JS_ASSERT(this == *stackTop);

         *stackTop = down;

     }

     /* Implemented in gc/RootMarking.cpp. */

     inline void trace(JSTracer *trc);

     static void traceAll(JSTracer *trc);

     static void traceAllWrappers(JSTracer *trc);

   protected:

     AutoGCRooter * const down;

     /*

      * Discriminates actual subclass of this being used.  If non-negative, the

      * subclass roots an array of values of the length stored in this field.

      * If negative, meaning is indicated by the corresponding value in the enum

      * below.  Any other negative value indicates some deeper problem such as

      * memory corruption.

      */

     ptrdiff_t tag_;

     enum {

         VALARRAY =     -2, /* js::AutoValueArray */

         PARSER =       -3, /* js::frontend::Parser */

         SHAPEVECTOR =  -4, /* js::AutoShapeVector */

         IDARRAY =      -6, /* js::AutoIdArray */

         DESCRIPTORS =  -7, /* js::AutoPropDescArrayRooter */

         ID =           -9, /* js::AutoIdRooter */

         VALVECTOR =   -10, /* js::AutoValueVector */

         IDVECTOR =    -13, /* js::AutoIdVector */

         OBJVECTOR =   -14, /* js::AutoObjectVector */

         STRINGVECTOR =-15, /* js::AutoStringVector */

         SCRIPTVECTOR =-16, /* js::AutoScriptVector */

         NAMEVECTOR =  -17, /* js::AutoNameVector */

         HASHABLEVALUE=-18, /* js::HashableValue */

         IONMASM =     -19, /* js::jit::MacroAssembler */

         IONALLOC =    -20, /* js::jit::AutoTempAllocatorRooter */

         WRAPVECTOR =  -21, /* js::AutoWrapperVector */

         WRAPPER =     -22, /* js::AutoWrapperRooter */

         OBJOBJHASHMAP=-23, /* js::AutoObjectObjectHashMap */

         OBJU32HASHMAP=-24, /* js::AutoObjectUnsigned32HashMap */

         OBJHASHSET =  -25, /* js::AutoObjectHashSet */

         JSONPARSER =  -26, /* js::JSONParser */

         CUSTOM =      -27, /* js::CustomAutoRooter */

         FUNVECTOR =   -28  /* js::AutoFunctionVector */

     };

   private:

     AutoGCRooter ** const stackTop;

     /* No copy or assignment semantics. */

     AutoGCRooter(AutoGCRooter &ida) MOZ_DELETE;

     void operator=(AutoGCRooter &ida) MOZ_DELETE;

 };

 /* AutoValueArray roots an internal fixed-size array of Values. */

 template <size_t N>

 class AutoValueArray : public AutoGCRooter

 {

     const size_t length_;

     Value elements_[N];

   public:

     AutoValueArray(JSContext *cx

                    MOZ_GUARD_OBJECT_NOTIFIER_PARAM)

       : AutoGCRooter(cx, VALARRAY), length_(N)

     {

         /* Always initialize in case we GC before assignment. */

         mozilla::PodArrayZero(elements_);

         MOZ_GUARD_OBJECT_NOTIFIER_INIT;

     }

     unsigned length() const { return length_; }

     const Value *begin() const { return elements_; }

     Value *begin() { return elements_; }

     HandleValue operator[](unsigned i) const {

         JS_ASSERT(i < N);

         return HandleValue::fromMarkedLocation(&elements_[i]);

     }

     MutableHandleValue operator[](unsigned i) {

         JS_ASSERT(i < N);

         return MutableHandleValue::fromMarkedLocation(&elements_[i]);

     }

     MOZ_DECL_USE_GUARD_OBJECT_NOTIFIER

 };

 template<class T>

 class AutoVectorRooter : protected AutoGCRooter

 {

     typedef js::Vector<T, 8> VectorImpl;

     VectorImpl vector;

   public:

     explicit AutoVectorRooter(JSContext *cx, ptrdiff_t tag

                               MOZ_GUARD_OBJECT_NOTIFIER_PARAM)

       : AutoGCRooter(cx, tag), vector(cx)

     {

         MOZ_GUARD_OBJECT_NOTIFIER_INIT;

     }

     explicit AutoVectorRooter(js::ContextFriendFields *cx, ptrdiff_t tag

                               MOZ_GUARD_OBJECT_NOTIFIER_PARAM)

       : AutoGCRooter(cx, tag), vector(cx)

     {

         MOZ_GUARD_OBJECT_NOTIFIER_INIT;

     }

     typedef T ElementType;

     typedef typename VectorImpl::Range Range;

     size_t length() const { return vector.length(); }

     bool empty() const { return vector.empty(); }

     bool append(const T &v) { return vector.append(v); }

     bool append(const T *ptr, size_t len) { return vector.append(ptr, len); }

     bool appendAll(const AutoVectorRooter<T> &other) {

         return vector.appendAll(other.vector);

     }

     bool insert(T *p, const T &val) { return vector.insert(p, val); }

     /* For use when space has already been reserved. */

     void infallibleAppend(const T &v) { vector.infallibleAppend(v); }

     void popBack() { vector.popBack(); }

     T popCopy() { return vector.popCopy(); }

     bool growBy(size_t inc) {

         size_t oldLength = vector.length();

         if (!vector.growByUninitialized(inc))

             return false;

         makeRangeGCSafe(oldLength);

         return true;

     }

     bool resize(size_t newLength) {

         size_t oldLength = vector.length();

         if (newLength <= oldLength) {

             vector.shrinkBy(oldLength - newLength);

             return true;

         }

         if (!vector.growByUninitialized(newLength - oldLength))

             return false;

         makeRangeGCSafe(oldLength);

         return true;

     }

     void clear() { vector.clear(); }

     bool reserve(size_t newLength) {

         return vector.reserve(newLength);

     }

     T &operator[](size_t i) { return vector[i]; }

     const T &operator[](size_t i) const { return vector[i]; }

     JS::MutableHandle<T> handleAt(size_t i) {

         return JS::MutableHandle<T>::fromMarkedLocation(&vector[i]);

     }

     JS::Handle<T> handleAt(size_t i) const {

         return JS::Handle<T>::fromMarkedLocation(&vector[i]);

     }

     const T *begin() const { return vector.begin(); }

     T *begin() { return vector.begin(); }

     const T *end() const { return vector.end(); }

     T *end() { return vector.end(); }

     Range all() { return vector.all(); }

     const T &back() const { return vector.back(); }

     friend void AutoGCRooter::trace(JSTracer *trc);

   private:

     void makeRangeGCSafe(size_t oldLength) {

         T *t = vector.begin() + oldLength;

         for (size_t i = oldLength; i < vector.length(); ++i, ++t)

             memset(t, 0, sizeof(T));

     }

     MOZ_DECL_USE_GUARD_OBJECT_NOTIFIER

 };

 template<class Key, class Value>

 class AutoHashMapRooter : protected AutoGCRooter

 {

   private:

     typedef js::HashMap<Key, Value> HashMapImpl;

   public:

     explicit AutoHashMapRooter(JSContext *cx, ptrdiff_t tag

                                MOZ_GUARD_OBJECT_NOTIFIER_PARAM)

       : AutoGCRooter(cx, tag), map(cx)

     {

         MOZ_GUARD_OBJECT_NOTIFIER_INIT;

     }

     typedef Key KeyType;

     typedef Value ValueType;

     typedef typename HashMapImpl::Entry Entry;

     typedef typename HashMapImpl::Lookup Lookup;

     typedef typename HashMapImpl::Ptr Ptr;

     typedef typename HashMapImpl::AddPtr AddPtr;

     bool init(uint32_t len = 16) {

         return map.init(len);

     }

     bool initialized() const {

         return map.initialized();

     }

     Ptr lookup(const Lookup &l) const {

         return map.lookup(l);

     }

     void remove(Ptr p) {

         map.remove(p);

     }

     AddPtr lookupForAdd(const Lookup &l) const {

         return map.lookupForAdd(l);

     }

     template<typename KeyInput, typename ValueInput>

     bool add(AddPtr &p, const KeyInput &k, const ValueInput &v) {

         return map.add(p, k, v);

     }

     bool add(AddPtr &p, const Key &k) {

         return map.add(p, k);

     }

     template<typename KeyInput, typename ValueInput>

     bool relookupOrAdd(AddPtr &p, const KeyInput &k, const ValueInput &v) {

         return map.relookupOrAdd(p, k, v);

     }

     typedef typename HashMapImpl::Range Range;

     Range all() const {

         return map.all();

     }

     typedef typename HashMapImpl::Enum Enum;

     void clear() {

         map.clear();

     }

     void finish() {

         map.finish();

     }

     bool empty() const {

         return map.empty();

     }

     uint32_t count() const {

         return map.count();

     }

     size_t capacity() const {

         return map.capacity();

     }

     size_t sizeOfExcludingThis(mozilla::MallocSizeOf mallocSizeOf) const {

         return map.sizeOfExcludingThis(mallocSizeOf);

     }

     size_t sizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf) const {

         return map.sizeOfIncludingThis(mallocSizeOf);

     }

     unsigned generation() const {

         return map.generation();

     }

     /************************************************** Shorthand operations */

     bool has(const Lookup &l) const {

         return map.has(l);

     }

     template<typename KeyInput, typename ValueInput>

     bool put(const KeyInput &k, const ValueInput &v) {

         return map.put(k, v);

     }

     template<typename KeyInput, typename ValueInput>

     bool putNew(const KeyInput &k, const ValueInput &v) {

         return map.putNew(k, v);

     }

     Ptr lookupWithDefault(const Key &k, const Value &defaultValue) {

         return map.lookupWithDefault(k, defaultValue);

     }

     void remove(const Lookup &l) {

         map.remove(l);

     }

     friend void AutoGCRooter::trace(JSTracer *trc);

   private:

     AutoHashMapRooter(const AutoHashMapRooter &hmr) MOZ_DELETE;

     AutoHashMapRooter &operator=(const AutoHashMapRooter &hmr) MOZ_DELETE;

     HashMapImpl map;

     MOZ_DECL_USE_GUARD_OBJECT_NOTIFIER

 };

 template<class T>

 class AutoHashSetRooter : protected AutoGCRooter

 {

   private:

     typedef js::HashSet<T> HashSetImpl;

   public:

     explicit AutoHashSetRooter(JSContext *cx, ptrdiff_t tag

                                MOZ_GUARD_OBJECT_NOTIFIER_PARAM)

       : AutoGCRooter(cx, tag), set(cx)

     {

         MOZ_GUARD_OBJECT_NOTIFIER_INIT;

     }

     typedef typename HashSetImpl::Lookup Lookup;

     typedef typename HashSetImpl::Ptr Ptr;

     typedef typename HashSetImpl::AddPtr AddPtr;

     bool init(uint32_t len = 16) {

         return set.init(len);

     }

     bool initialized() const {

         return set.initialized();

     }

     Ptr lookup(const Lookup &l) const {

         return set.lookup(l);

     }

     void remove(Ptr p) {

         set.remove(p);

     }

     AddPtr lookupForAdd(const Lookup &l) const {

         return set.lookupForAdd(l);

     }

     bool add(AddPtr &p, const T &t) {

         return set.add(p, t);

     }

     bool relookupOrAdd(AddPtr &p, const Lookup &l, const T &t) {

         return set.relookupOrAdd(p, l, t);

     }

     typedef typename HashSetImpl::Range Range;

     Range all() const {

         return set.all();

     }

     typedef typename HashSetImpl::Enum Enum;

     void clear() {

         set.clear();

     }

     void finish() {

         set.finish();

     }

     bool empty() const {

         return set.empty();

     }

     uint32_t count() const {

         return set.count();

     }

     size_t capacity() const {

         return set.capacity();

     }

     size_t sizeOfExcludingThis(mozilla::MallocSizeOf mallocSizeOf) const {

         return set.sizeOfExcludingThis(mallocSizeOf);

     }

     size_t sizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf) const {

         return set.sizeOfIncludingThis(mallocSizeOf);

     }

     unsigned generation() const {

         return set.generation();

     }

     /************************************************** Shorthand operations */

     bool has(const Lookup &l) const {

         return set.has(l);

     }

     bool put(const T &t) {

         return set.put(t);

     }

     bool putNew(const T &t) {

         return set.putNew(t);

     }

     void remove(const Lookup &l) {

         set.remove(l);

     }

     friend void AutoGCRooter::trace(JSTracer *trc);

   private:

     AutoHashSetRooter(const AutoHashSetRooter &hmr) MOZ_DELETE;

     AutoHashSetRooter &operator=(const AutoHashSetRooter &hmr) MOZ_DELETE;

     HashSetImpl set;

     MOZ_DECL_USE_GUARD_OBJECT_NOTIFIER

 };

 class MOZ_STACK_CLASS AutoValueVector : public AutoVectorRooter<Value>

 {

   public:

     explicit AutoValueVector(JSContext *cx

                              MOZ_GUARD_OBJECT_NOTIFIER_PARAM)

         : AutoVectorRooter<Value>(cx, VALVECTOR)

     {

         MOZ_GUARD_OBJECT_NOTIFIER_INIT;

     }

     MOZ_DECL_USE_GUARD_OBJECT_NOTIFIER

 };

 class AutoIdVector : public AutoVectorRooter<jsid>

 {

   public:

     explicit AutoIdVector(JSContext *cx

                           MOZ_GUARD_OBJECT_NOTIFIER_PARAM)

         : AutoVectorRooter<jsid>(cx, IDVECTOR)

     {

         MOZ_GUARD_OBJECT_NOTIFIER_INIT;

     }

     MOZ_DECL_USE_GUARD_OBJECT_NOTIFIER

 };

 class AutoObjectVector : public AutoVectorRooter<JSObject *>

 {

   public:

     explicit AutoObjectVector(JSContext *cx

                               MOZ_GUARD_OBJECT_NOTIFIER_PARAM)

         : AutoVectorRooter<JSObject *>(cx, OBJVECTOR)

     {

         MOZ_GUARD_OBJECT_NOTIFIER_INIT;

     }

     MOZ_DECL_USE_GUARD_OBJECT_NOTIFIER

 };

 class AutoFunctionVector : public AutoVectorRooter<JSFunction *>

 {

   public:

     explicit AutoFunctionVector(JSContext *cx

                                 MOZ_GUARD_OBJECT_NOTIFIER_PARAM)

         : AutoVectorRooter<JSFunction *>(cx, FUNVECTOR)

     {

         MOZ_GUARD_OBJECT_NOTIFIER_INIT;

     }

     explicit AutoFunctionVector(js::ContextFriendFields *cx

                                 MOZ_GUARD_OBJECT_NOTIFIER_PARAM)

         : AutoVectorRooter<JSFunction *>(cx, FUNVECTOR)

     {

         MOZ_GUARD_OBJECT_NOTIFIER_INIT;

     }

     MOZ_DECL_USE_GUARD_OBJECT_NOTIFIER

 };

 class AutoScriptVector : public AutoVectorRooter<JSScript *>

 {

   public:

     explicit AutoScriptVector(JSContext *cx

                               MOZ_GUARD_OBJECT_NOTIFIER_PARAM)

         : AutoVectorRooter<JSScript *>(cx, SCRIPTVECTOR)

     {

         MOZ_GUARD_OBJECT_NOTIFIER_INIT;

     }

     MOZ_DECL_USE_GUARD_OBJECT_NOTIFIER

 };

 /*

  * Cutsom rooting behavior for internal and external clients.

  */

 class JS_PUBLIC_API(CustomAutoRooter) : private AutoGCRooter

 {

   public:

     template <typename CX>

     explicit CustomAutoRooter(CX *cx MOZ_GUARD_OBJECT_NOTIFIER_PARAM)

       : AutoGCRooter(cx, CUSTOM)

     {

         MOZ_GUARD_OBJECT_NOTIFIER_INIT;

     }

     friend void AutoGCRooter::trace(JSTracer *trc);

   protected:

     /* Supplied by derived class to trace roots. */

     virtual void trace(JSTracer *trc) = 0;

   private:

     MOZ_DECL_USE_GUARD_OBJECT_NOTIFIER

 };

 /* A handle to an array of rooted values. */

 class HandleValueArray

 {

     const size_t length_;

     const Value * const elements_;

     HandleValueArray(size_t len, const Value *elements) : length_(len), elements_(elements) {}

   public:

     HandleValueArray(const RootedValue& value) : length_(1), elements_(value.address()) {}

     HandleValueArray(const AutoValueVector& values)

       : length_(values.length()), elements_(values.begin()) {}

     template <size_t N>

     HandleValueArray(const AutoValueArray<N>& values) : length_(N), elements_(values.begin()) {}

     /* CallArgs must already be rooted somewhere up the stack. */

     HandleValueArray(const JS::CallArgs& args) : length_(args.length()), elements_(args.array()) {}

     /* Use with care! Only call this if the data is guaranteed to be marked. */

     static HandleValueArray fromMarkedLocation(size_t len, const Value *elements) {

         return HandleValueArray(len, elements);

     }

     static HandleValueArray subarray(const HandleValueArray& values, size_t startIndex, size_t len) {

         JS_ASSERT(startIndex + len <= values.length());

         return HandleValueArray(len, values.begin() + startIndex);

     }

     static HandleValueArray empty() {

         return HandleValueArray(0, nullptr);

     }

     size_t length() const { return length_; }

     const Value *begin() const { return elements_; }

     HandleValue operator[](size_t i) const {

         JS_ASSERT(i < length_);

         return HandleValue::fromMarkedLocation(&elements_[i]);

     }

 };

 }  /* namespace JS */

 /************************************************************************/

 struct JSFreeOp {

   private:

     JSRuntime   *runtime_;

   protected:

     JSFreeOp(JSRuntime *rt)

       : runtime_(rt) { }

   public:

     JSRuntime *runtime() const {

         return runtime_;

     }

 };

 /* Callbacks and their arguments. */

 /************************************************************************/

 typedef enum JSContextOp {

     JSCONTEXT_NEW,

     JSCONTEXT_DESTROY

 } JSContextOp;

 /*

  * The possible values for contextOp when the runtime calls the callback are:

  *   JSCONTEXT_NEW      JS_NewContext successfully created a new JSContext

  *                      instance. The callback can initialize the instance as

  *                      required. If the callback returns false, the instance

  *                      will be destroyed and JS_NewContext returns null. In

  *                      this case the callback is not called again.

  *   JSCONTEXT_DESTROY  One of JS_DestroyContext* methods is called. The

  *                      callback may perform its own cleanup and must always

  *                      return true.

  *   Any other value    For future compatibility the callback must do nothing

  *                      and return true in this case.

  */

 typedef bool

 (* JSContextCallback)(JSContext *cx, unsigned contextOp, void *data);

 typedef enum JSGCStatus {

     JSGC_BEGIN,

     JSGC_END

 } JSGCStatus;

 typedef void

 (* JSGCCallback)(JSRuntime *rt, JSGCStatus status, void *data);

 typedef enum JSFinalizeStatus {

     /*

      * Called when preparing to sweep a group of compartments, before anything

      * has been swept.  The collector will not yield to the mutator before

      * calling the callback with JSFINALIZE_GROUP_END status.

      */

     JSFINALIZE_GROUP_START,

     /*

      * Called when preparing to sweep a group of compartments. Weak references

      * to unmarked things have been removed and things that are not swept

      * incrementally have been finalized at this point.  The collector may yield

      * to the mutator after this point.

      */

     JSFINALIZE_GROUP_END,

     /*

      * Called at the end of collection when everything has been swept.

      */

     JSFINALIZE_COLLECTION_END

 } JSFinalizeStatus;

 typedef void

 (* JSFinalizeCallback)(JSFreeOp *fop, JSFinalizeStatus status, bool isCompartment);

 typedef bool

 (* JSInterruptCallback)(JSContext *cx);

 typedef void

 (* JSErrorReporter)(JSContext *cx, const char *message, JSErrorReport *report);

 #ifdef MOZ_TRACE_JSCALLS

 typedef void

 (* JSFunctionCallback)(const JSFunction *fun,

                        const JSScript *scr,

                        const JSContext *cx,

                        int entering);

 #endif

 /*

  * Possible exception types. These types are part of a JSErrorFormatString

  * structure. They define which error to throw in case of a runtime error.

  * JSEXN_NONE marks an unthrowable error.

  */

 typedef enum JSExnType {

     JSEXN_NONE = -1,

       JSEXN_ERR,

         JSEXN_INTERNALERR,

         JSEXN_EVALERR,

         JSEXN_RANGEERR,

         JSEXN_REFERENCEERR,

         JSEXN_SYNTAXERR,

         JSEXN_TYPEERR,

         JSEXN_URIERR,

         JSEXN_LIMIT

 } JSExnType;

 typedef struct JSErrorFormatString {

     /* The error format string in ASCII. */

     const char *format;

     /* The number of arguments to expand in the formatted error message. */

     uint16_t argCount;

     /* One of the JSExnType constants above. */

     int16_t exnType;

 } JSErrorFormatString;

 typedef const JSErrorFormatString *

 (* JSErrorCallback)(void *userRef, const char *locale,

                     const unsigned errorNumber);

 typedef bool

 (* JSLocaleToUpperCase)(JSContext *cx, JS::HandleString src, JS::MutableHandleValue rval);

 typedef bool

 (* JSLocaleToLowerCase)(JSContext *cx, JS::HandleString src, JS::MutableHandleValue rval);

 typedef bool

 (* JSLocaleCompare)(JSContext *cx, JS::HandleString src1, JS::HandleString src2,

                     JS::MutableHandleValue rval);

 typedef bool

 (* JSLocaleToUnicode)(JSContext *cx, const char *src, JS::MutableHandleValue rval);

 /*

  * Callback used to ask the embedding for the cross compartment wrapper handler

  * that implements the desired prolicy for this kind of object in the

  * destination compartment. |obj| is the object to be wrapped. If |existing| is

  * non-nullptr, it will point to an existing wrapper object that should be

  * re-used if possible. |existing| is guaranteed to be a cross-compartment

  * wrapper with a lazily-defined prototype and the correct global. It is

  * guaranteed not to wrap a function.

  */

 typedef JSObject *

 (* JSWrapObjectCallback)(JSContext *cx, JS::HandleObject existing, JS::HandleObject obj,

                          JS::HandleObject proto, JS::HandleObject parent,

                          unsigned flags);

 /*

  * Callback used by the wrap hook to ask the embedding to prepare an object

  * for wrapping in a context. This might include unwrapping other wrappers

  * or even finding a more suitable object for the new compartment.

  */

 typedef JSObject *

 (* JSPreWrapCallback)(JSContext *cx, JS::HandleObject scope, JS::HandleObject obj,

                       unsigned flags);

 struct JSWrapObjectCallbacks

 {

     JSWrapObjectCallback wrap;

     JSPreWrapCallback preWrap;

 };

 typedef void

 (* JSDestroyCompartmentCallback)(JSFreeOp *fop, JSCompartment *compartment);

 typedef void

 (* JSZoneCallback)(JS::Zone *zone);

 typedef void

 (* JSCompartmentNameCallback)(JSRuntime *rt, JSCompartment *compartment,

                               char *buf, size_t bufsize);

 /************************************************************************/

 static MOZ_ALWAYS_INLINE jsval

 JS_NumberValue(double d)

 {

     int32_t i;

     d = JS::CanonicalizeNaN(d);

     if (mozilla::NumberIsInt32(d, &i))

         return INT_TO_JSVAL(i);

     return DOUBLE_TO_JSVAL(d);

 }

 /************************************************************************/

 JS_PUBLIC_API(bool)

 JS_StringHasBeenInterned(JSContext *cx, JSString *str);

 /*

  * Only JSStrings that have been interned via the JSAPI can be turned into

  * jsids by API clients.

  *

  * N.B. if a jsid is backed by a string which has not been interned, that

  * string must be appropriately rooted to avoid being collected by the GC.

  */

 JS_PUBLIC_API(jsid)

 INTERNED_STRING_TO_JSID(JSContext *cx, JSString *str);

 /*

  * Returns true iff the given jsval is immune to GC and can be used across

  * multiple JSRuntimes without requiring any conversion API.

  */

 static MOZ_ALWAYS_INLINE bool

 JSVAL_IS_UNIVERSAL(jsval v)

 {

     return !JSVAL_IS_GCTHING(v);

 }

 namespace JS {

 class AutoIdRooter : private AutoGCRooter

 {

   public:

     explicit AutoIdRooter(JSContext *cx, jsid aId = INT_TO_JSID(0)

                           MOZ_GUARD_OBJECT_NOTIFIER_PARAM)

       : AutoGCRooter(cx, ID), id_(aId)

     {

         MOZ_GUARD_OBJECT_NOTIFIER_INIT;

     }

     jsid id() {

         return id_;

     }

     jsid * addr() {

         return &id_;

     }

     friend void AutoGCRooter::trace(JSTracer *trc);

   private:

     jsid id_;

     MOZ_DECL_USE_GUARD_OBJECT_NOTIFIER

 };

 // Container class for passing in script source buffers to the JS engine.  This

 // not only groups the buffer and length values, it also provides a way to

 // optionally pass ownership of the buffer to the JS engine without copying.

 // Rules for use:

 //

 //  1) The data array must be allocated with js_malloc() or js_realloc() if

 //     ownership is being granted to the SourceBufferHolder.

 //  2) If ownership is not given to the SourceBufferHolder, then the memory

 //     must be kept alive until the JS compilation is complete.

 //  3) Any code calling SourceBufferHolder::take() must guarantee to keep the

 //     memory alive until JS compilation completes.  Normally only the JS

 //     engine should be calling take().

 //

 // Example use:

 //

 //    size_t length = 512;

 //    jschar* chars = static_cast<jschar*>(js_malloc(sizeof(jschar) * length));

 //    JS::SourceBufferHolder srcBuf(chars, length, JS::SourceBufferHolder::GiveOwnership);

 //    JS::Compile(cx, obj, options, srcBuf);

 //

 class MOZ_STACK_CLASS SourceBufferHolder MOZ_FINAL

 {

   public:

     enum Ownership {

       NoOwnership,

       GiveOwnership

     };

     SourceBufferHolder(const jschar *data, size_t dataLength, Ownership ownership)

       : data_(data),

         length_(dataLength),

         ownsChars_(ownership == GiveOwnership)

     {

         // Ensure that null buffers properly return an unowned, empty,

         // null-terminated string.

         static const jschar NullChar_ = 0;

         if (!get()) {

             data_ = &NullChar_;

             length_ = 0;

             ownsChars_ = false;

         }

     }

     ~SourceBufferHolder() {

         if (ownsChars_)

             js_free(const_cast<jschar *>(data_));

     }

     // Access the underlying source buffer without affecting ownership.

     const jschar *get() const { return data_; }

     // Length of the source buffer in jschars (not bytes)

     size_t length() const { return length_; }

     // Returns true if the SourceBufferHolder owns the buffer and will free

     // it upon destruction.  If true, it is legal to call take().

     bool ownsChars() const { return ownsChars_; }

     // Retrieve and take ownership of the underlying data buffer.  The caller

     // is now responsible for calling js_free() on the returned value, *but only

     // after JS script compilation has completed*.

     //

     // After the buffer has been taken the SourceBufferHolder functions as if

     // it had been constructed on an unowned buffer;  get() and length() still

     // work.  In order for this to be safe the taken buffer must be kept alive

     // until after JS script compilation completes as noted above.

     //

     // Note, it's the caller's responsibility to check ownsChars() before taking

     // the buffer.  Taking and then free'ing an unowned buffer will have dire

     // consequences.

     jschar *take() {

         JS_ASSERT(ownsChars_);

         ownsChars_ = false;

         return const_cast<jschar *>(data_);

     }

   private:

     SourceBufferHolder(SourceBufferHolder &) MOZ_DELETE;

     SourceBufferHolder &operator=(SourceBufferHolder &) MOZ_DELETE;

     const jschar *data_;

     size_t length_;

     bool ownsChars_;

 };

 } /* namespace JS */

 /************************************************************************/

 /* Property attributes, set in JSPropertySpec and passed to API functions. */

 #define JSPROP_ENUMERATE        0x01    /* property is visible to for/in loop */

 #define JSPROP_READONLY         0x02    /* not settable: assignment is no-op.

                                            This flag is only valid when neither

                                            JSPROP_GETTER nor JSPROP_SETTER is

                                            set. */

 #define JSPROP_PERMANENT        0x04    /* property cannot be deleted */

 #define JSPROP_NATIVE_ACCESSORS 0x08    /* set in JSPropertyDescriptor.flags

                                            if getters/setters are JSNatives */

 #define JSPROP_GETTER           0x10    /* property holds getter function */

 #define JSPROP_SETTER           0x20    /* property holds setter function */

 #define JSPROP_SHARED           0x40    /* don't allocate a value slot for this

                                            property; don't copy the property on

                                            set of the same-named property in an

                                            object that delegates to a prototype

                                            containing this property */

 #define JSPROP_INDEX            0x80    /* name is actually (int) index */

 #define JSFUN_STUB_GSOPS       0x200    /* use JS_PropertyStub getter/setter

                                            instead of defaulting to class gsops

                                            for property holding function */

 #define JSFUN_CONSTRUCTOR      0x400    /* native that can be called as a ctor */

 /*

  * Specify a generic native prototype methods, i.e., methods of a class

  * prototype that are exposed as static methods taking an extra leading

  * argument: the generic |this| parameter.

  *

  * If you set this flag in a JSFunctionSpec struct's flags initializer, then

  * that struct must live at least as long as the native static method object

  * created due to this flag by JS_DefineFunctions or JS_InitClass.  Typically

  * JSFunctionSpec structs are allocated in static arrays.

  */

 #define JSFUN_GENERIC_NATIVE   0x800

 #define JSFUN_FLAGS_MASK       0xe00    /* | of all the JSFUN_* flags */

 /*

  * The first call to JS_CallOnce by any thread in a process will call 'func'.

  * Later calls to JS_CallOnce with the same JSCallOnceType object will be

  * suppressed.

  *

  * Equivalently: each distinct JSCallOnceType object will allow one JS_CallOnce

  * to invoke its JSInitCallback.

  */

 extern JS_PUBLIC_API(bool)

 JS_CallOnce(JSCallOnceType *once, JSInitCallback func);

 /* Microseconds since the epoch, midnight, January 1, 1970 UTC. */

 extern JS_PUBLIC_API(int64_t)

 JS_Now(void);

 /* Don't want to export data, so provide accessors for non-inline jsvals. */

 extern JS_PUBLIC_API(jsval)

 JS_GetNaNValue(JSContext *cx);

 extern JS_PUBLIC_API(jsval)

 JS_GetNegativeInfinityValue(JSContext *cx);

 extern JS_PUBLIC_API(jsval)

 JS_GetPositiveInfinityValue(JSContext *cx);

 extern JS_PUBLIC_API(jsval)

 JS_GetEmptyStringValue(JSContext *cx);

 extern JS_PUBLIC_API(JSString *)

 JS_GetEmptyString(JSRuntime *rt);

 /*

  * Format is a string of the following characters (spaces are insignificant),

  * specifying the tabulated type conversions:

  *

  *   b      bool            Boolean

  *   c      uint16_t/jschar ECMA uint16_t, Unicode char

  *   i      int32_t         ECMA int32_t

  *   j      int32_t         ECMA int32_t (used to be different)

  *   u      uint32_t        ECMA uint32_t

  *   d      double          IEEE double

  *   I      double          Integral IEEE double

  *   S      JSString *      Unicode string, accessed by a JSString pointer

  *   W      jschar *        Unicode character vector, 0-terminated (W for wide)

  *   o      JSObject *      Object reference

  *   f      JSFunction *    Function private

  *   v      jsval           Argument value (no conversion)

  *   *      N/A             Skip this argument (no vararg)

  *   /      N/A             End of required arguments

  *

  * The variable argument list after format must consist of &b, &c, &s, e.g.,

  * where those variables have the types given above.  For the pointer types

  * char *, JSString *, and JSObject *, the pointed-at memory returned belongs

  * to the JS runtime, not to the calling native code.  The runtime promises

  * to keep this memory valid so long as argv refers to allocated stack space

  * (so long as the native function is active).

  *

  * Fewer arguments than format specifies may be passed only if there is a /

  * in format after the last required argument specifier and argc is at least

  * the number of required arguments.  More arguments than format specifies

  * may be passed without error; it is up to the caller to deal with trailing

  * unconverted arguments.

  */

 extern JS_PUBLIC_API(bool)

 JS_ConvertArguments(JSContext *cx, const JS::CallArgs &args, const char *format, ...);

 #ifdef va_start

 extern JS_PUBLIC_API(bool)

 JS_ConvertArgumentsVA(JSContext *cx, const JS::CallArgs &args, const char *format,

                       va_list ap);

 #endif

 extern JS_PUBLIC_API(bool)

 JS_ConvertValue(JSContext *cx, JS::HandleValue v, JSType type, JS::MutableHandleValue vp);

 extern JS_PUBLIC_API(bool)

 JS_ValueToObject(JSContext *cx, JS::HandleValue v, JS::MutableHandleObject objp);

 extern JS_PUBLIC_API(JSFunction *)

 JS_ValueToFunction(JSContext *cx, JS::HandleValue v);

 extern JS_PUBLIC_API(JSFunction *)

 JS_ValueToConstructor(JSContext *cx, JS::HandleValue v);

 extern JS_PUBLIC_API(JSString *)

 JS_ValueToSource(JSContext *cx, JS::Handle<JS::Value> v);

 namespace js {

 /*

  * DO NOT CALL THIS.  Use JS::ToNumber

  */

 extern JS_PUBLIC_API(bool)

 ToNumberSlow(JSContext *cx, JS::Value v, double *dp);

 /*

  * DO NOT CALL THIS. Use JS::ToBoolean

  */

 extern JS_PUBLIC_API(bool)

 ToBooleanSlow(JS::HandleValue v);

 /*

  * DO NOT CALL THIS. Use JS::ToString

  */

 extern JS_PUBLIC_API(JSString*)

 ToStringSlow(JSContext *cx, JS::HandleValue v);

 } /* namespace js */

 namespace JS {

 /* ES5 9.3 ToNumber. */

 MOZ_ALWAYS_INLINE bool

 ToNumber(JSContext *cx, HandleValue v, double *out)

 {

     AssertArgumentsAreSane(cx, v);

     if (v.isNumber()) {

         *out = v.toNumber();

         return true;

     }

     return js::ToNumberSlow(cx, v, out);

 }

 MOZ_ALWAYS_INLINE bool

 ToBoolean(HandleValue v)

 {

     if (v.isBoolean())

         return v.toBoolean();

     if (v.isInt32())

         return v.toInt32() != 0;

     if (v.isNullOrUndefined())

         return false;

     if (v.isDouble()) {

         double d = v.toDouble();

         return !mozilla::IsNaN(d) && d != 0;

     }

     /* The slow path handles strings and objects. */

     return js::ToBooleanSlow(v);

 }

 MOZ_ALWAYS_INLINE JSString*

 ToString(JSContext *cx, HandleValue v)

 {

     if (v.isString())

         return v.toString();

     return js::ToStringSlow(cx, v);

 }

 } /* namespace JS */

 extern JS_PUBLIC_API(bool)

 JS_DoubleIsInt32(double d, int32_t *ip);

 extern JS_PUBLIC_API(int32_t)

 JS_DoubleToInt32(double d);

 extern JS_PUBLIC_API(uint32_t)

 JS_DoubleToUint32(double d);

 namespace js {

 /* DO NOT CALL THIS. Use JS::ToUint16. */

 extern JS_PUBLIC_API(bool)

 ToUint16Slow(JSContext *cx, JS::HandleValue v, uint16_t *out);

 /* DO NOT CALL THIS. Use JS::ToInt32. */

 extern JS_PUBLIC_API(bool)

 ToInt32Slow(JSContext *cx, JS::HandleValue v, int32_t *out);

 /* DO NOT CALL THIS. Use JS::ToUint32. */

 extern JS_PUBLIC_API(bool)

 ToUint32Slow(JSContext *cx, JS::HandleValue v, uint32_t *out);

 /* DO NOT CALL THIS. Use JS::ToInt64. */

 extern JS_PUBLIC_API(bool)

 ToInt64Slow(JSContext *cx, JS::HandleValue v, int64_t *out);

 /* DO NOT CALL THIS. Use JS::ToUint64. */

 extern JS_PUBLIC_API(bool)

 ToUint64Slow(JSContext *cx, JS::HandleValue v, uint64_t *out);

 } /* namespace js */

 namespace JS {

 MOZ_ALWAYS_INLINE bool

 ToUint16(JSContext *cx, JS::HandleValue v, uint16_t *out)

 {

     AssertArgumentsAreSane(cx, v);

     if (v.isInt32()) {

         *out = uint16_t(v.toInt32());

         return true;

     }

     return js::ToUint16Slow(cx, v, out);

 }

 MOZ_ALWAYS_INLINE bool

 ToInt32(JSContext *cx, JS::HandleValue v, int32_t *out)

 {

     AssertArgumentsAreSane(cx, v);

     if (v.isInt32()) {

         *out = v.toInt32();

         return true;

     }

     return js::ToInt32Slow(cx, v, out);

 }

 MOZ_ALWAYS_INLINE bool

 ToUint32(JSContext *cx, JS::HandleValue v, uint32_t *out)

 {

     AssertArgumentsAreSane(cx, v);

     if (v.isInt32()) {

         *out = uint32_t(v.toInt32());

         return true;

     }

     return js::ToUint32Slow(cx, v, out);

 }

 MOZ_ALWAYS_INLINE bool

 ToInt64(JSContext *cx, JS::HandleValue v, int64_t *out)

 {

     AssertArgumentsAreSane(cx, v);

     if (v.isInt32()) {

         *out = int64_t(v.toInt32());

         return true;

     }

     return js::ToInt64Slow(cx, v, out);

 }

 MOZ_ALWAYS_INLINE bool

 ToUint64(JSContext *cx, JS::HandleValue v, uint64_t *out)

 {

     AssertArgumentsAreSane(cx, v);

     if (v.isInt32()) {

         /* Account for sign extension of negatives into the longer 64bit space. */

         *out = uint64_t(int64_t(v.toInt32()));

         return true;

     }

     return js::ToUint64Slow(cx, v, out);

 }

 } /* namespace JS */

 extern JS_PUBLIC_API(JSType)

 JS_TypeOfValue(JSContext *cx, JS::Handle<JS::Value> v);

 extern JS_PUBLIC_API(const char *)

 JS_GetTypeName(JSContext *cx, JSType type);

 extern JS_PUBLIC_API(bool)

 JS_StrictlyEqual(JSContext *cx, jsval v1, jsval v2, bool *equal);

 extern JS_PUBLIC_API(bool)

 JS_LooselyEqual(JSContext *cx, JS::Handle<JS::Value> v1, JS::Handle<JS::Value> v2, bool *equal);

 extern JS_PUBLIC_API(bool)

 JS_SameValue(JSContext *cx, jsval v1, jsval v2, bool *same);

 /* True iff fun is the global eval function. */

 extern JS_PUBLIC_API(bool)

 JS_IsBuiltinEvalFunction(JSFunction *fun);

 /* True iff fun is the Function constructor. */

 extern JS_PUBLIC_API(bool)

 JS_IsBuiltinFunctionConstructor(JSFunction *fun);

 /************************************************************************/

 /*

  * Initialization, locking, contexts, and memory allocation.

  *

  * It is important that the first runtime and first context be created in a

  * single-threaded fashion, otherwise the behavior of the library is undefined.

  * See: http://developer.mozilla.org/en/docs/Category:JSAPI_Reference

  */

 typedef enum JSUseHelperThreads

 {

     JS_NO_HELPER_THREADS,

     JS_USE_HELPER_THREADS

 } JSUseHelperThreads;

 /**

  * 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.

  */

 extern JS_PUBLIC_API(bool)

 JS_Init(void);

 /**

  * 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.

  */

 extern JS_PUBLIC_API(void)

 JS_ShutDown(void);

 extern JS_PUBLIC_API(JSRuntime *)

 JS_NewRuntime(uint32_t maxbytes, JSUseHelperThreads useHelperThreads,

               JSRuntime *parentRuntime = nullptr);

 extern JS_PUBLIC_API(void)

 JS_DestroyRuntime(JSRuntime *rt);

 // These are equivalent to ICU's |UMemAllocFn|, |UMemReallocFn|, and

 // |UMemFreeFn| types.  The first argument (called |context| in the ICU docs)

 // will always be nullptr, and should be ignored.

 typedef void *(*JS_ICUAllocFn)(const void *, size_t size);

 typedef void *(*JS_ICUReallocFn)(const void *, void *p, size_t size);

 typedef void (*JS_ICUFreeFn)(const void *, void *p);

 // This function can be used to track memory used by ICU.

 // Do not use it unless you know what you are doing!

 extern JS_PUBLIC_API(bool)

 JS_SetICUMemoryFunctions(JS_ICUAllocFn allocFn, JS_ICUReallocFn reallocFn, JS_ICUFreeFn freeFn);

 JS_PUBLIC_API(void *)

 JS_GetRuntimePrivate(JSRuntime *rt);

 extern JS_PUBLIC_API(JSRuntime *)

 JS_GetRuntime(JSContext *cx);

 extern JS_PUBLIC_API(JSRuntime *)

 JS_GetParentRuntime(JSContext *cx);

 JS_PUBLIC_API(void)

 JS_SetRuntimePrivate(JSRuntime *rt, void *data);

 extern JS_PUBLIC_API(void)

 JS_BeginRequest(JSContext *cx);

 extern JS_PUBLIC_API(void)

 JS_EndRequest(JSContext *cx);

 extern JS_PUBLIC_API(bool)

 JS_IsInRequest(JSRuntime *rt);

 namespace js {

 void

 AssertHeapIsIdle(JSRuntime *rt);

 void

 AssertHeapIsIdle(JSContext *cx);

 } /* namespace js */

 class JSAutoRequest

 {

   public:

     JSAutoRequest(JSContext *cx

                   MOZ_GUARD_OBJECT_NOTIFIER_PARAM)

       : mContext(cx)

     {

         MOZ_GUARD_OBJECT_NOTIFIER_INIT;

         JS_BeginRequest(mContext);

     }

     ~JSAutoRequest() {

         JS_EndRequest(mContext);

     }

   protected:

     JSContext *mContext;

     MOZ_DECL_USE_GUARD_OBJECT_NOTIFIER

 #if 0

   private:

     static void *operator new(size_t) CPP_THROW_NEW { return 0; };

     static void operator delete(void *, size_t) { };

 #endif

 };

 class JSAutoCheckRequest

 {

   public:

     JSAutoCheckRequest(JSContext *cx

                        MOZ_GUARD_OBJECT_NOTIFIER_PARAM)

     {

 #if defined JS_THREADSAFE && defined JS_DEBUG

         mContext = cx;

         JS_ASSERT(JS_IsInRequest(JS_GetRuntime(cx)));

 #endif

         MOZ_GUARD_OBJECT_NOTIFIER_INIT;

     }

     ~JSAutoCheckRequest() {

 #if defined JS_THREADSAFE && defined JS_DEBUG

         JS_ASSERT(JS_IsInRequest(JS_GetRuntime(mContext)));

 #endif

     }

   private:

 #if defined JS_THREADSAFE && defined JS_DEBUG

     JSContext *mContext;

 #endif

     MOZ_DECL_USE_GUARD_OBJECT_NOTIFIER

 };

 extern JS_PUBLIC_API(void)

 JS_SetContextCallback(JSRuntime *rt, JSContextCallback cxCallback, void *data);

 extern JS_PUBLIC_API(JSContext *)

 JS_NewContext(JSRuntime *rt, size_t stackChunkSize);

 extern JS_PUBLIC_API(void)

 JS_DestroyContext(JSContext *cx);

 extern JS_PUBLIC_API(void)

 JS_DestroyContextNoGC(JSContext *cx);

 extern JS_PUBLIC_API(void *)

 JS_GetContextPrivate(JSContext *cx);

 extern JS_PUBLIC_API(void)

 JS_SetContextPrivate(JSContext *cx, void *data);

 extern JS_PUBLIC_API(void *)

 JS_GetSecondContextPrivate(JSContext *cx);

 extern JS_PUBLIC_API(void)

 JS_SetSecondContextPrivate(JSContext *cx, void *data);

 extern JS_PUBLIC_API(JSRuntime *)

 JS_GetRuntime(JSContext *cx);

 extern JS_PUBLIC_API(JSContext *)

 JS_ContextIterator(JSRuntime *rt, JSContext **iterp);

 extern JS_PUBLIC_API(JSVersion)

 JS_GetVersion(JSContext *cx);

 // Mutate the version on the compartment. This is generally discouraged, but

 // necessary to support the version mutation in the js and xpc shell command

 // set.

 //

 // It would be nice to put this in jsfriendapi, but the linkage requirements

 // of the shells make that impossible.

 JS_PUBLIC_API(void)

 JS_SetVersionForCompartment(JSCompartment *compartment, JSVersion version);

 extern JS_PUBLIC_API(const char *)

 JS_VersionToString(JSVersion version);

 extern JS_PUBLIC_API(JSVersion)

 JS_StringToVersion(const char *string);

 namespace JS {

 class JS_PUBLIC_API(RuntimeOptions) {

   public:

     RuntimeOptions()

       : baseline_(false),

         ion_(false),

         asmJS_(false)

     {

     }

     bool baseline() const { return baseline_; }

     RuntimeOptions &setBaseline(bool flag) {

         baseline_ = flag;

         return *this;

     }

     RuntimeOptions &toggleBaseline() {

         baseline_ = !baseline_;

         return *this;

     }

     bool ion() const { return ion_; }

     RuntimeOptions &setIon(bool flag) {

         ion_ = flag;

         return *this;

     }

     RuntimeOptions &toggleIon() {

         ion_ = !ion_;

         return *this;

     }

     bool asmJS() const { return asmJS_; }

     RuntimeOptions &setAsmJS(bool flag) {

         asmJS_ = flag;

         return *this;

     }

     RuntimeOptions &toggleAsmJS() {

         asmJS_ = !asmJS_;

         return *this;

     }

   private:

     bool baseline_ : 1;

     bool ion_ : 1;

     bool asmJS_ : 1;

 };

 JS_PUBLIC_API(RuntimeOptions &)

 RuntimeOptionsRef(JSRuntime *rt);

 JS_PUBLIC_API(RuntimeOptions &)

 RuntimeOptionsRef(JSContext *cx);

 class JS_PUBLIC_API(ContextOptions) {

   public:

     ContextOptions()

       : extraWarnings_(false),

         werror_(false),

         varObjFix_(false),

         privateIsNSISupports_(false),

         dontReportUncaught_(false),

         noDefaultCompartmentObject_(false),

         noScriptRval_(false),

         strictMode_(false),

         cloneSingletons_(false)

     {

     }

     bool extraWarnings() const { return extraWarnings_; }

     ContextOptions &setExtraWarnings(bool flag) {

         extraWarnings_ = flag;

         return *this;

     }

     ContextOptions &toggleExtraWarnings() {

         extraWarnings_ = !extraWarnings_;

         return *this;

     }

     bool werror() const { return werror_; }

     ContextOptions &setWerror(bool flag) {

         werror_ = flag;

         return *this;

     }

     ContextOptions &toggleWerror() {

         werror_ = !werror_;

         return *this;

     }

     bool varObjFix() const { return varObjFix_; }

     ContextOptions &setVarObjFix(bool flag) {

         varObjFix_ = flag;

         return *this;

     }

     ContextOptions &toggleVarObjFix() {

         varObjFix_ = !varObjFix_;

         return *this;

     }

     bool privateIsNSISupports() const { return privateIsNSISupports_; }

     ContextOptions &setPrivateIsNSISupports(bool flag) {

         privateIsNSISupports_ = flag;

         return *this;

     }

     ContextOptions &togglePrivateIsNSISupports() {

         privateIsNSISupports_ = !privateIsNSISupports_;

         return *this;

     }

     bool dontReportUncaught() const { return dontReportUncaught_; }

     ContextOptions &setDontReportUncaught(bool flag) {

         dontReportUncaught_ = flag;

         return *this;

     }

     ContextOptions &toggleDontReportUncaught() {

         dontReportUncaught_ = !dontReportUncaught_;

         return *this;

     }

     bool noDefaultCompartmentObject() const { return noDefaultCompartmentObject_; }

     ContextOptions &setNoDefaultCompartmentObject(bool flag) {

         noDefaultCompartmentObject_ = flag;

         return *this;

     }

     ContextOptions &toggleNoDefaultCompartmentObject() {

         noDefaultCompartmentObject_ = !noDefaultCompartmentObject_;

         return *this;

     }

     bool noScriptRval() const { return noScriptRval_; }

     ContextOptions &setNoScriptRval(bool flag) {

         noScriptRval_ = flag;

         return *this;

     }

     ContextOptions &toggleNoScriptRval() {

         noScriptRval_ = !noScriptRval_;

         return *this;

     }

     bool strictMode() const { return strictMode_; }

     ContextOptions &setStrictMode(bool flag) {

         strictMode_ = flag;

         return *this;

     }

     ContextOptions &toggleStrictMode() {

         strictMode_ = !strictMode_;

         return *this;

     }

     bool cloneSingletons() const { return cloneSingletons_; }

     ContextOptions &setCloneSingletons(bool flag) {

         cloneSingletons_ = flag;

         return *this;

     }

     ContextOptions &toggleCloneSingletons() {

         cloneSingletons_ = !cloneSingletons_;

         return *this;

     }

   private:

     bool extraWarnings_ : 1;

     bool werror_ : 1;

     bool varObjFix_ : 1;

     bool privateIsNSISupports_ : 1;

     bool dontReportUncaught_ : 1;

     bool noDefaultCompartmentObject_ : 1;

     bool noScriptRval_ : 1;

     bool strictMode_ : 1;

     bool cloneSingletons_ : 1;

 };

 JS_PUBLIC_API(ContextOptions &)

 ContextOptionsRef(JSContext *cx);

 class JS_PUBLIC_API(AutoSaveContextOptions) {

   public:

     AutoSaveContextOptions(JSContext *cx)

       : cx_(cx),

         oldOptions_(ContextOptionsRef(cx_))

     {

     }

     ~AutoSaveContextOptions()

     {

         ContextOptionsRef(cx_) = oldOptions_;

     }

   private:

     JSContext *cx_;

     JS::ContextOptions oldOptions_;

 };

 } /* namespace JS */

 extern JS_PUBLIC_API(const char *)

 JS_GetImplementationVersion(void);

 extern JS_PUBLIC_API(void)

 JS_SetDestroyCompartmentCallback(JSRuntime *rt, JSDestroyCompartmentCallback callback);

 extern JS_PUBLIC_API(void)

 JS_SetDestroyZoneCallback(JSRuntime *rt, JSZoneCallback callback);

 extern JS_PUBLIC_API(void)

 JS_SetSweepZoneCallback(JSRuntime *rt, JSZoneCallback callback);

 extern JS_PUBLIC_API(void)

 JS_SetCompartmentNameCallback(JSRuntime *rt, JSCompartmentNameCallback callback);

 extern JS_PUBLIC_API(void)

 JS_SetWrapObjectCallbacks(JSRuntime *rt, const JSWrapObjectCallbacks *callbacks);

 extern JS_PUBLIC_API(void)

 JS_SetCompartmentPrivate(JSCompartment *compartment, void *data);

 extern JS_PUBLIC_API(void *)

 JS_GetCompartmentPrivate(JSCompartment *compartment);

 extern JS_PUBLIC_API(void)

 JS_SetZoneUserData(JS::Zone *zone, void *data);

 extern JS_PUBLIC_API(void *)

 JS_GetZoneUserData(JS::Zone *zone);

 extern JS_PUBLIC_API(bool)

 JS_WrapObject(JSContext *cx, JS::MutableHandleObject objp);

 extern JS_PUBLIC_API(bool)

 JS_WrapValue(JSContext *cx, JS::MutableHandleValue vp);

 extern JS_PUBLIC_API(bool)

 JS_WrapId(JSContext *cx, JS::MutableHandleId idp);

 extern JS_PUBLIC_API(JSObject *)

 JS_TransplantObject(JSContext *cx, JS::HandleObject origobj, JS::HandleObject target);

 extern JS_PUBLIC_API(bool)

 JS_RefreshCrossCompartmentWrappers(JSContext *cx, JS::Handle<JSObject*> obj);

 /*

  * At any time, a JSContext has a current (possibly-nullptr) compartment.

  * Compartments are described in:

  *

  *   developer.mozilla.org/en-US/docs/SpiderMonkey/SpiderMonkey_compartments

  *

  * The current compartment of a context may be changed. The preferred way to do

  * this is with JSAutoCompartment:

  *

  *   void foo(JSContext *cx, JSObject *obj) {

  *     // in some compartment 'c'

  *     {

  *       JSAutoCompartment ac(cx, obj);  // constructor enters

  *       // in the compartment of 'obj'

  *     }                                 // destructor leaves

  *     // back in compartment 'c'

  *   }

  *

  * For more complicated uses that don't neatly fit in a C++ stack frame, the

  * compartment can entered and left using separate function calls:

  *

  *   void foo(JSContext *cx, JSObject *obj) {

  *     // in 'oldCompartment'

  *     JSCompartment *oldCompartment = JS_EnterCompartment(cx, obj);

  *     // in the compartment of 'obj'

  *     JS_LeaveCompartment(cx, oldCompartment);

  *     // back in 'oldCompartment'

  *   }

  *

  * Note: these calls must still execute in a LIFO manner w.r.t all other

  * enter/leave calls on the context. Furthermore, only the return value of a

  * JS_EnterCompartment call may be passed as the 'oldCompartment' argument of

  * the corresponding JS_LeaveCompartment call.

  */

 class JS_PUBLIC_API(JSAutoCompartment)

 {

     JSContext *cx_;

     JSCompartment *oldCompartment_;

   public:

     JSAutoCompartment(JSContext *cx, JSObject *target);

     JSAutoCompartment(JSContext *cx, JSScript *target);

     ~JSAutoCompartment();

 };

 class JS_PUBLIC_API(JSAutoNullCompartment)

 {

     JSContext *cx_;

     JSCompartment *oldCompartment_;

   public:

     JSAutoNullCompartment(JSContext *cx);

     ~JSAutoNullCompartment();

 };

 /* NB: This API is infallible; a nullptr return value does not indicate error. */

 extern JS_PUBLIC_API(JSCompartment *)

 JS_EnterCompartment(JSContext *cx, JSObject *target);

 extern JS_PUBLIC_API(void)

 JS_LeaveCompartment(JSContext *cx, JSCompartment *oldCompartment);

 typedef void (*JSIterateCompartmentCallback)(JSRuntime *rt, void *data, JSCompartment *compartment);

 /*

  * This function calls |compartmentCallback| on every compartment.  Beware that

  * there is no guarantee that the compartment will survive after the callback

  * returns.

  */

 extern JS_PUBLIC_API(void)

 JS_IterateCompartments(JSRuntime *rt, void *data,

                        JSIterateCompartmentCallback compartmentCallback);

 /*

  * Initialize standard JS class constructors, prototypes, and any top-level

  * functions and constants associated with the standard classes (e.g. isNaN

  * for Number).

  *

  * NB: This sets cx's global object to obj if it was null.

  */

 extern JS_PUBLIC_API(bool)

 JS_InitStandardClasses(JSContext *cx, JS::Handle<JSObject*> obj);

 /*

  * Resolve id, which must contain either a string or an int, to a standard

  * class name in obj if possible, defining the class's constructor and/or

  * prototype and storing true in *resolved.  If id does not name a standard

  * class or a top-level property induced by initializing a standard class,

  * store false in *resolved and just return true.  Return false on error,

  * as usual for bool result-typed API entry points.

  *

  * This API can be called directly from a global object class's resolve op,

  * to define standard classes lazily.  The class's enumerate op should call

  * JS_EnumerateStandardClasses(cx, obj), to define eagerly during for..in

  * loops any classes not yet resolved lazily.

  */

 extern JS_PUBLIC_API(bool)

 JS_ResolveStandardClass(JSContext *cx, JS::HandleObject obj, JS::HandleId id, bool *resolved);

 extern JS_PUBLIC_API(bool)

 JS_EnumerateStandardClasses(JSContext *cx, JS::HandleObject obj);

 extern JS_PUBLIC_API(bool)

 JS_GetClassObject(JSContext *cx, JSProtoKey key, JS::MutableHandle<JSObject*> objp);

 extern JS_PUBLIC_API(bool)

 JS_GetClassPrototype(JSContext *cx, JSProtoKey key, JS::MutableHandle<JSObject*> objp);

 namespace JS {

 /*

  * Determine if the given object is an instance or prototype for a standard

  * class. If so, return the associated JSProtoKey. If not, return JSProto_Null.

  */

 extern JS_PUBLIC_API(JSProtoKey)

 IdentifyStandardInstance(JSObject *obj);

 extern JS_PUBLIC_API(JSProtoKey)

 IdentifyStandardPrototype(JSObject *obj);

 extern JS_PUBLIC_API(JSProtoKey)

 IdentifyStandardInstanceOrPrototype(JSObject *obj);

 } /* namespace JS */

 extern JS_PUBLIC_API(JSProtoKey)

 JS_IdToProtoKey(JSContext *cx, JS::HandleId id);

 /*

  * Returns the original value of |Function.prototype| from the global object in

  * which |forObj| was created.

  */

 extern JS_PUBLIC_API(JSObject *)

 JS_GetFunctionPrototype(JSContext *cx, JS::HandleObject forObj);

 /*

  * Returns the original value of |Object.prototype| from the global object in

  * which |forObj| was created.

  */

 extern JS_PUBLIC_API(JSObject *)

 JS_GetObjectPrototype(JSContext *cx, JS::HandleObject forObj);

 /*

  * Returns the original value of |Array.prototype| from the global object in

  * which |forObj| was created.

  */

 extern JS_PUBLIC_API(JSObject *)

 JS_GetArrayPrototype(JSContext *cx, JS::HandleObject forObj);

 extern JS_PUBLIC_API(JSObject *)

 JS_GetGlobalForObject(JSContext *cx, JSObject *obj);

 extern JS_PUBLIC_API(bool)

 JS_IsGlobalObject(JSObject *obj);

 /*

  * May return nullptr, if |c| never had a global (e.g. the atoms compartment),

  * or if |c|'s global has been collected.

  */

 extern JS_PUBLIC_API(JSObject *)

 JS_GetGlobalForCompartmentOrNull(JSContext *cx, JSCompartment *c);

 namespace JS {

 extern JS_PUBLIC_API(JSObject *)

 CurrentGlobalOrNull(JSContext *cx);

 }

 /*

  * Initialize the 'Reflect' object on a global object.

  */

 extern JS_PUBLIC_API(JSObject *)

 JS_InitReflect(JSContext *cx, JS::HandleObject global);

 #ifdef JS_HAS_CTYPES

 /*

  * Initialize the 'ctypes' object on a global variable 'obj'. The 'ctypes'

  * object will be sealed.

  */

 extern JS_PUBLIC_API(bool)

 JS_InitCTypesClass(JSContext *cx, JS::HandleObject global);

 /*

  * Convert a unicode string 'source' of length 'slen' to the platform native

  * charset, returning a null-terminated string allocated with JS_malloc. On

  * failure, this function should report an error.

  */

 typedef char *

 (* JSCTypesUnicodeToNativeFun)(JSContext *cx, const jschar *source, size_t slen);

 /*

  * Set of function pointers that ctypes can use for various internal functions.

  * See JS_SetCTypesCallbacks below. Providing nullptr for a function is safe,

  * and will result in the applicable ctypes functionality not being available.

  */

 struct JSCTypesCallbacks {

     JSCTypesUnicodeToNativeFun unicodeToNative;

 };

 typedef struct JSCTypesCallbacks JSCTypesCallbacks;

 /*

  * Set the callbacks on the provided 'ctypesObj' object. 'callbacks' should be a

  * pointer to static data that exists for the lifetime of 'ctypesObj', but it

  * may safely be altered after calling this function and without having

  * to call this function again.

  */

 extern JS_PUBLIC_API(void)

 JS_SetCTypesCallbacks(JSObject *ctypesObj, JSCTypesCallbacks *callbacks);

 #endif

 typedef bool

 (* JSEnumerateDiagnosticMemoryCallback)(void *ptr, size_t length);

 /*

  * Enumerate memory regions that contain diagnostic information

  * intended to be included in crash report minidumps.

  */

 extern JS_PUBLIC_API(void)

 JS_EnumerateDiagnosticMemoryRegions(JSEnumerateDiagnosticMemoryCallback callback);

 extern JS_PUBLIC_API(void *)

 JS_malloc(JSContext *cx, size_t nbytes);

 extern JS_PUBLIC_API(void *)

 JS_realloc(JSContext *cx, void *p, size_t nbytes);

 /*

  * A wrapper for js_free(p) that may delay js_free(p) invocation as a

  * performance optimization.

  * cx may be nullptr.

  */

 extern JS_PUBLIC_API(void)

 JS_free(JSContext *cx, void *p);

 /*

  * A wrapper for js_free(p) that may delay js_free(p) invocation as a

  * performance optimization as specified by the given JSFreeOp instance.

  */

 extern JS_PUBLIC_API(void)

 JS_freeop(JSFreeOp *fop, void *p);

 extern JS_PUBLIC_API(JSFreeOp *)

 JS_GetDefaultFreeOp(JSRuntime *rt);

 extern JS_PUBLIC_API(void)

 JS_updateMallocCounter(JSContext *cx, size_t nbytes);

 extern JS_PUBLIC_API(char *)

 JS_strdup(JSContext *cx, const char *s);

 /* Duplicate a string.  Does not report an error on failure. */

 extern JS_PUBLIC_API(char *)

 JS_strdup(JSRuntime *rt, const char *s);

 namespace JS {

 /*

  * A GC root is a pointer to a jsval, JSObject * or JSString * that itself

  * points into the GC heap. JS_AddValueRoot takes a pointer to a jsval and

  * JS_AddGCThingRoot takes a pointer to a JSObject * or JString *.

  *

  * Note that, since JS_Add*Root stores the address of a variable (of type

  * jsval, JSString *, or JSObject *), that variable must live until

  * JS_Remove*Root is called to remove that variable. For example, after:

  *

  *   void some_function() {

  *     jsval v;

  *     JS_AddNamedValueRoot(cx, &v, "name");

  *

  * the caller must perform

  *

  *     JS_RemoveValueRoot(cx, &v);

  *

  * before some_function() returns.

  *

  * Also, use JS_AddNamed*Root(cx, &structPtr->memberObj, "structPtr->memberObj")

  * in preference to JS_Add*Root(cx, &structPtr->memberObj), in order to identify

  * roots by their source callsites.  This way, you can find the callsite while

  * debugging if you should fail to do JS_Remove*Root(cx, &structPtr->memberObj)

  * before freeing structPtr's memory.

  */

 extern JS_PUBLIC_API(bool)

 AddValueRoot(JSContext *cx, JS::Heap<JS::Value> *vp);

 extern JS_PUBLIC_API(bool)

 AddStringRoot(JSContext *cx, JS::Heap<JSString *> *rp);

 extern JS_PUBLIC_API(bool)

 AddObjectRoot(JSContext *cx, JS::Heap<JSObject *> *rp);

 extern JS_PUBLIC_API(bool)

 AddNamedValueRoot(JSContext *cx, JS::Heap<JS::Value> *vp, const char *name);

 extern JS_PUBLIC_API(bool)

 AddNamedValueRootRT(JSRuntime *rt, JS::Heap<JS::Value> *vp, const char *name);

 extern JS_PUBLIC_API(bool)

 AddNamedStringRoot(JSContext *cx, JS::Heap<JSString *> *rp, const char *name);

 extern JS_PUBLIC_API(bool)

 AddNamedObjectRoot(JSContext *cx, JS::Heap<JSObject *> *rp, const char *name);

 extern JS_PUBLIC_API(bool)

 AddNamedScriptRoot(JSContext *cx, JS::Heap<JSScript *> *rp, const char *name);

 extern JS_PUBLIC_API(void)

 RemoveValueRoot(JSContext *cx, JS::Heap<JS::Value> *vp);

 extern JS_PUBLIC_API(void)

 RemoveStringRoot(JSContext *cx, JS::Heap<JSString *> *rp);

 extern JS_PUBLIC_API(void)

 RemoveObjectRoot(JSContext *cx, JS::Heap<JSObject *> *rp);

 extern JS_PUBLIC_API(void)

 RemoveScriptRoot(JSContext *cx, JS::Heap<JSScript *> *rp);

 extern JS_PUBLIC_API(void)

 RemoveValueRootRT(JSRuntime *rt, JS::Heap<JS::Value> *vp);

 extern JS_PUBLIC_API(void)

 RemoveStringRootRT(JSRuntime *rt, JS::Heap<JSString *> *rp);

 extern JS_PUBLIC_API(void)

 RemoveObjectRootRT(JSRuntime *rt, JS::Heap<JSObject *> *rp);

 extern JS_PUBLIC_API(void)

 RemoveScriptRootRT(JSRuntime *rt, JS::Heap<JSScript *> *rp);

 } /* namespace JS */

 /*

  * Register externally maintained GC roots.

  *

  * traceOp: the trace operation. For each root the implementation should call

  *          JS_CallTracer whenever the root contains a traceable thing.

  * data:    the data argument to pass to each invocation of traceOp.

  */

 extern JS_PUBLIC_API(bool)

 JS_AddExtraGCRootsTracer(JSRuntime *rt, JSTraceDataOp traceOp, void *data);

 /* Undo a call to JS_AddExtraGCRootsTracer. */

 extern JS_PUBLIC_API(void)

 JS_RemoveExtraGCRootsTracer(JSRuntime *rt, JSTraceDataOp traceOp, void *data);

 #ifdef JS_DEBUG

 /*

  * Debug-only method to dump the object graph of heap-allocated things.

  *

  * fp:              file for the dump output.

  * start:           when non-null, dump only things reachable from start

  *                  thing. Otherwise dump all things reachable from the

  *                  runtime roots.

  * startKind:       trace kind of start if start is not null. Must be

  *                  JSTRACE_OBJECT when start is null.

  * thingToFind:     dump only paths in the object graph leading to thingToFind

  *                  when non-null.

  * maxDepth:        the upper bound on the number of edges to descend from the

  *                  graph roots.

  * thingToIgnore:   thing to ignore during the graph traversal when non-null.

  */

 extern JS_PUBLIC_API(bool)

 JS_DumpHeap(JSRuntime *rt, FILE *fp, void* startThing, JSGCTraceKind kind,

             void *thingToFind, size_t maxDepth, void *thingToIgnore);

 #endif

 /*

  * Garbage collector API.

  */

 extern JS_PUBLIC_API(void)

 JS_GC(JSRuntime *rt);

 extern JS_PUBLIC_API(void)

 JS_MaybeGC(JSContext *cx);

 extern JS_PUBLIC_API(void)

 JS_SetGCCallback(JSRuntime *rt, JSGCCallback cb, void *data);

 extern JS_PUBLIC_API(void)

 JS_SetFinalizeCallback(JSRuntime *rt, JSFinalizeCallback cb);

 extern JS_PUBLIC_API(bool)

 JS_IsGCMarkingTracer(JSTracer *trc);

 /* For assertions only. */

 #ifdef JS_DEBUG

 extern JS_PUBLIC_API(bool)

 JS_IsMarkingGray(JSTracer *trc);

 #endif

 /*

  * JS_IsAboutToBeFinalized checks if the given object is going to be finalized

  * at the end of the current GC. When called outside of the context of a GC,

  * this function will return false. Typically this function is used on weak

  * references, where the reference should be nulled out or destroyed if the

  * given object is about to be finalized.

  *

  * The argument to JS_IsAboutToBeFinalized is an in-out param: when the

  * function returns false, the object being referenced is still alive, but the

  * garbage collector might have moved it. In this case, the reference passed

  * to JS_IsAboutToBeFinalized will be updated to the object's new location.

  * Callers of this method are responsible for updating any state that is

  * dependent on the object's address. For example, if the object's address is

  * used as a key in a hashtable, then the object must be removed and

  * re-inserted with the correct hash.

  */

 extern JS_PUBLIC_API(bool)

 JS_IsAboutToBeFinalized(JS::Heap<JSObject *> *objp);

 extern JS_PUBLIC_API(bool)

 JS_IsAboutToBeFinalizedUnbarriered(JSObject **objp);

 typedef enum JSGCParamKey {

     /* Maximum nominal heap before last ditch GC. */

     JSGC_MAX_BYTES          = 0,

     /* Number of JS_malloc bytes before last ditch GC. */

     JSGC_MAX_MALLOC_BYTES   = 1,

     /* Amount of bytes allocated by the GC. */

     JSGC_BYTES = 3,

     /* Number of times when GC was invoked. */

     JSGC_NUMBER = 4,

     /* Max size of the code cache in bytes. */

     JSGC_MAX_CODE_CACHE_BYTES = 5,

     /* Select GC mode. */

     JSGC_MODE = 6,

     /* Number of cached empty GC chunks. */

     JSGC_UNUSED_CHUNKS = 7,

     /* Total number of allocated GC chunks. */

     JSGC_TOTAL_CHUNKS = 8,

     /* Max milliseconds to spend in an incremental GC slice. */

     JSGC_SLICE_TIME_BUDGET = 9,

     /* Maximum size the GC mark stack can grow to. */

     JSGC_MARK_STACK_LIMIT = 10,

     /*

      * GCs less than this far apart in time will be considered 'high-frequency GCs'.

      * See setGCLastBytes in jsgc.cpp.

      */

     JSGC_HIGH_FREQUENCY_TIME_LIMIT = 11,

     /* Start of dynamic heap growth. */

     JSGC_HIGH_FREQUENCY_LOW_LIMIT = 12,

     /* End of dynamic heap growth. */

     JSGC_HIGH_FREQUENCY_HIGH_LIMIT = 13,

     /* Upper bound of heap growth. */

     JSGC_HIGH_FREQUENCY_HEAP_GROWTH_MAX = 14,

     /* Lower bound of heap growth. */

     JSGC_HIGH_FREQUENCY_HEAP_GROWTH_MIN = 15,

     /* Heap growth for low frequency GCs. */

     JSGC_LOW_FREQUENCY_HEAP_GROWTH = 16,

     /*

      * If false, the heap growth factor is fixed at 3. If true, it is determined

      * based on whether GCs are high- or low- frequency.

      */

     JSGC_DYNAMIC_HEAP_GROWTH = 17,

     /* If true, high-frequency GCs will use a longer mark slice. */

     JSGC_DYNAMIC_MARK_SLICE = 18,

     /* Lower limit after which we limit the heap growth. */

     JSGC_ALLOCATION_THRESHOLD = 19,

     /*

      * We decommit memory lazily. If more than this number of megabytes is

      * available to be decommitted, then JS_MaybeGC will trigger a shrinking GC

      * to decommit it.

      */

     JSGC_DECOMMIT_THRESHOLD = 20

 } JSGCParamKey;

 extern JS_PUBLIC_API(void)

 JS_SetGCParameter(JSRuntime *rt, JSGCParamKey key, uint32_t value);

 extern JS_PUBLIC_API(uint32_t)

 JS_GetGCParameter(JSRuntime *rt, JSGCParamKey key);

 extern JS_PUBLIC_API(void)

 JS_SetGCParameterForThread(JSContext *cx, JSGCParamKey key, uint32_t value);

 extern JS_PUBLIC_API(uint32_t)

 JS_GetGCParameterForThread(JSContext *cx, JSGCParamKey key);

 extern JS_PUBLIC_API(void)

 JS_SetGCParametersBasedOnAvailableMemory(JSRuntime *rt, uint32_t availMem);

 /*

  * Create a new JSString whose chars member refers to external memory, i.e.,

  * memory requiring application-specific finalization.

  */

 extern JS_PUBLIC_API(JSString *)

 JS_NewExternalString(JSContext *cx, const jschar *chars, size_t length,

                      const JSStringFinalizer *fin);

 /*

  * Return whether 'str' was created with JS_NewExternalString or

  * JS_NewExternalStringWithClosure.

  */

 extern JS_PUBLIC_API(bool)

 JS_IsExternalString(JSString *str);

 /*

  * Return the 'closure' arg passed to JS_NewExternalStringWithClosure or

  * nullptr if the external string was created via JS_NewExternalString.

  */

 extern JS_PUBLIC_API(const JSStringFinalizer *)

 JS_GetExternalStringFinalizer(JSString *str);

 /*

  * Set the size of the native stack that should not be exceed. To disable

  * stack size checking pass 0.

  *

  * SpiderMonkey allows for a distinction between system code (such as GCs, which

  * may incidentally be triggered by script but are not strictly performed on

  * behalf of such script), trusted script (as determined by JS_SetTrustedPrincipals),

  * and untrusted script. Each kind of code may have a different stack quota,

  * allowing embedders to keep higher-priority machinery running in the face of

  * scripted stack exhaustion by something else.

  *

  * The stack quotas for each kind of code should be monotonically descending,

  * and may be specified with this function. If 0 is passed for a given kind

  * of code, it defaults to the value of the next-highest-priority kind.

  */

 extern JS_PUBLIC_API(void)

 JS_SetNativeStackQuota(JSRuntime *cx, size_t systemCodeStackSize,

                        size_t trustedScriptStackSize = 0,

                        size_t untrustedScriptStackSize = 0);

 /************************************************************************/

 extern JS_PUBLIC_API(int)

 JS_IdArrayLength(JSContext *cx, JSIdArray *ida);

 extern JS_PUBLIC_API(jsid)

 JS_IdArrayGet(JSContext *cx, JSIdArray *ida, int index);

 extern JS_PUBLIC_API(void)

 JS_DestroyIdArray(JSContext *cx, JSIdArray *ida);

 namespace JS {

 class AutoIdArray : private AutoGCRooter

 {

   public:

     AutoIdArray(JSContext *cx, JSIdArray *ida

                 MOZ_GUARD_OBJECT_NOTIFIER_PARAM)

       : AutoGCRooter(cx, IDARRAY), context(cx), idArray(ida)

     {

         MOZ_GUARD_OBJECT_NOTIFIER_INIT;

     }

     ~AutoIdArray() {

         if (idArray)

             JS_DestroyIdArray(context, idArray);

     }

     bool operator!() {

         return !idArray;

     }

     jsid operator[](size_t i) const {

         JS_ASSERT(idArray);

         return JS_IdArrayGet(context, idArray, i);

     }

     size_t length() const {

         return JS_IdArrayLength(context, idArray);

     }

     friend void AutoGCRooter::trace(JSTracer *trc);

     JSIdArray *steal() {

         JSIdArray *copy = idArray;

         idArray = nullptr;

         return copy;

     }

   protected:

     inline void trace(JSTracer *trc);

   private:

     JSContext *context;

     JSIdArray *idArray;

     MOZ_DECL_USE_GUARD_OBJECT_NOTIFIER

     /* No copy or assignment semantics. */

     AutoIdArray(AutoIdArray &ida) MOZ_DELETE;

     void operator=(AutoIdArray &ida) MOZ_DELETE;

 };

 } /* namespace JS */

 extern JS_PUBLIC_API(bool)

 JS_ValueToId(JSContext *cx, JS::HandleValue v, JS::MutableHandleId idp);

 extern JS_PUBLIC_API(bool)

 JS_StringToId(JSContext *cx, JS::HandleString s, JS::MutableHandleId idp);

 extern JS_PUBLIC_API(bool)

 JS_IdToValue(JSContext *cx, jsid id, JS::MutableHandle<JS::Value> vp);

 /*

  * Invoke the [[DefaultValue]] hook (see ES5 8.6.2) with the provided hint on

  * the specified object, computing a primitive default value for the object.

  * The hint must be JSTYPE_STRING, JSTYPE_NUMBER, or JSTYPE_VOID (no hint).  On

  * success the resulting value is stored in *vp.

  */

 extern JS_PUBLIC_API(bool)

 JS_DefaultValue(JSContext *cx, JS::Handle<JSObject*> obj, JSType hint,

                 JS::MutableHandle<JS::Value> vp);

 extern JS_PUBLIC_API(bool)

 JS_PropertyStub(JSContext *cx, JS::HandleObject obj, JS::HandleId id,

                 JS::MutableHandleValue vp);

 extern JS_PUBLIC_API(bool)

 JS_StrictPropertyStub(JSContext *cx, JS::HandleObject obj, JS::HandleId id, bool strict,

                       JS::MutableHandleValue vp);

 extern JS_PUBLIC_API(bool)

 JS_DeletePropertyStub(JSContext *cx, JS::HandleObject obj, JS::HandleId id,

                       bool *succeeded);

 extern JS_PUBLIC_API(bool)

 JS_EnumerateStub(JSContext *cx, JS::HandleObject obj);

 extern JS_PUBLIC_API(bool)

 JS_ResolveStub(JSContext *cx, JS::HandleObject obj, JS::HandleId id);

 extern JS_PUBLIC_API(bool)

 JS_ConvertStub(JSContext *cx, JS::HandleObject obj, JSType type,

                JS::MutableHandleValue vp);

 struct JSConstDoubleSpec {

     double          dval;

     const char      *name;

     uint8_t         flags;

     uint8_t         spare[3];

 };

 struct JSJitInfo;

 /*

  * Wrappers to replace {Strict,}PropertyOp for JSPropertySpecs. This will allow

  * us to pass one JSJitInfo per function with the property spec, without

  * additional field overhead.

  */

 typedef struct JSStrictPropertyOpWrapper {

     JSStrictPropertyOp  op;

     const JSJitInfo     *info;

 } JSStrictPropertyOpWrapper;

 typedef struct JSPropertyOpWrapper {

     JSPropertyOp        op;

     const JSJitInfo     *info;

 } JSPropertyOpWrapper;

 /*

  * Wrapper to do as above, but for JSNatives for JSFunctionSpecs.

  */

 typedef struct JSNativeWrapper {

     JSNative        op;

     const JSJitInfo *info;

 } JSNativeWrapper;

 /*

  * Macro static initializers which make it easy to pass no JSJitInfo as part of a

  * JSPropertySpec or JSFunctionSpec.

  */

 #define JSOP_WRAPPER(op) { {op, nullptr} }

 #define JSOP_NULLWRAPPER JSOP_WRAPPER(nullptr)

 /*

  * To define an array element rather than a named property member, cast the

  * element's index to (const char *) and initialize name with it, and set the

  * JSPROP_INDEX bit in flags.

  */

 struct JSPropertySpec {

     struct SelfHostedWrapper {

         void       *unused;

         const char *funname;

     };

     const char                  *name;

     uint8_t                     flags;

     union {

         JSPropertyOpWrapper propertyOp;

         SelfHostedWrapper   selfHosted;

     } getter;

     union {

         JSStrictPropertyOpWrapper propertyOp;

         SelfHostedWrapper         selfHosted;

     } setter;

 private:

     void StaticAsserts() {

         JS_STATIC_ASSERT(sizeof(SelfHostedWrapper) == sizeof(JSPropertyOpWrapper));

         JS_STATIC_ASSERT(sizeof(SelfHostedWrapper) == sizeof(JSStrictPropertyOpWrapper));

         JS_STATIC_ASSERT(offsetof(SelfHostedWrapper, funname) ==

                          offsetof(JSPropertyOpWrapper, info));

     }

 };

 namespace JS {

 namespace detail {

 /* NEVER DEFINED, DON'T USE.  For use by JS_CAST_NATIVE_TO only. */

 inline int CheckIsNative(JSNative native);

 /* NEVER DEFINED, DON'T USE.  For use by JS_CAST_STRING_TO only. */

 template<size_t N>

 inline int

 CheckIsCharacterLiteral(const char (&arr)[N]);

 } // namespace detail

 } // namespace JS

 #define JS_CAST_NATIVE_TO(v, To) \

   (static_cast<void>(sizeof(JS::detail::CheckIsNative(v))), \

    reinterpret_cast<To>(v))

 #define JS_CAST_STRING_TO(s, To) \

   (static_cast<void>(sizeof(JS::detail::CheckIsCharacterLiteral(s))), \

    reinterpret_cast<To>(s))

 #define JS_CHECK_ACCESSOR_FLAGS(flags) \

   (static_cast<mozilla::EnableIf<!((flags) & (JSPROP_READONLY | JSPROP_SHARED | JSPROP_NATIVE_ACCESSORS))>::Type>(0), \

    (flags))

 /*

  * JSPropertySpec uses JSAPI JSPropertyOp and JSStrictPropertyOp in function

  * signatures.  These macros encapsulate the definition of JSNative-backed

  * JSPropertySpecs, performing type-safe casts on the getter/setter functions

  * and adding the necessary property flags to trigger interpretation as

  * JSNatives.

  */

 #define JS_PSG(name, getter, flags) \

     {name, \

      uint8_t(JS_CHECK_ACCESSOR_FLAGS(flags) | JSPROP_SHARED | JSPROP_NATIVE_ACCESSORS), \

      JSOP_WRAPPER(JS_CAST_NATIVE_TO(getter, JSPropertyOp)), \

      JSOP_NULLWRAPPER}

 #define JS_PSGS(name, getter, setter, flags) \

     {name, \

      uint8_t(JS_CHECK_ACCESSOR_FLAGS(flags) | JSPROP_SHARED | JSPROP_NATIVE_ACCESSORS), \

      JSOP_WRAPPER(JS_CAST_NATIVE_TO(getter, JSPropertyOp)), \

      JSOP_WRAPPER(JS_CAST_NATIVE_TO(setter, JSStrictPropertyOp))}

 #define JS_SELF_HOSTED_GET(name, getterName, flags) \

     {name, \

      uint8_t(JS_CHECK_ACCESSOR_FLAGS(flags) | JSPROP_SHARED | JSPROP_GETTER), \

      { nullptr, JS_CAST_STRING_TO(getterName, const JSJitInfo *) }, \

      JSOP_NULLWRAPPER }

 #define JS_SELF_HOSTED_GETSET(name, getterName, setterName, flags) \

     {name, \

      uint8_t(JS_CHECK_ACCESSOR_FLAGS(flags) | JSPROP_SHARED | JSPROP_GETTER | JSPROP_SETTER), \

      { nullptr, JS_CAST_STRING_TO(getterName, const JSJitInfo *) },  \

      { nullptr, JS_CAST_STRING_TO(setterName, const JSJitInfo *) } }

 #define JS_PS_END { nullptr, 0, JSOP_NULLWRAPPER, JSOP_NULLWRAPPER }

 /*

  * To define a native function, set call to a JSNativeWrapper. To define a

  * self-hosted function, set selfHostedName to the name of a function

  * compiled during JSRuntime::initSelfHosting.

  */

 struct JSFunctionSpec {

     const char      *name;

     JSNativeWrapper call;

     uint16_t        nargs;

     uint16_t        flags;

     const char      *selfHostedName;

 };

 /*

  * Terminating sentinel initializer to put at the end of a JSFunctionSpec array

  * that's passed to JS_DefineFunctions or JS_InitClass.

  */

 #define JS_FS_END JS_FS(nullptr,nullptr,0,0)

 /*

  * Initializer macros for a JSFunctionSpec array element. JS_FN (whose name pays

  * homage to the old JSNative/JSFastNative split) simply adds the flag

  * JSFUN_STUB_GSOPS. JS_FNINFO allows the simple adding of

  * JSJitInfos. JS_SELF_HOSTED_FN declares a self-hosted function. Finally

  * JS_FNSPEC has slots for all the fields.

  */

 #define JS_FS(name,call,nargs,flags)                                          \

     JS_FNSPEC(name, call, nullptr, nargs, flags, nullptr)

 #define JS_FN(name,call,nargs,flags)                                          \

     JS_FNSPEC(name, call, nullptr, nargs, (flags) | JSFUN_STUB_GSOPS, nullptr)

 #define JS_FNINFO(name,call,info,nargs,flags)                                 \

     JS_FNSPEC(name, call, info, nargs, flags, nullptr)

 #define JS_SELF_HOSTED_FN(name,selfHostedName,nargs,flags)                    \

     JS_FNSPEC(name, nullptr, nullptr, nargs, flags, selfHostedName)

 #define JS_FNSPEC(name,call,info,nargs,flags,selfHostedName)                  \

     {name, {call, info}, nargs, flags, selfHostedName}

 extern JS_PUBLIC_API(JSObject *)

 JS_InitClass(JSContext *cx, JS::HandleObject obj, JS::HandleObject parent_proto,

              const JSClass *clasp, JSNative constructor, unsigned nargs,

              const JSPropertySpec *ps, const JSFunctionSpec *fs,

              const JSPropertySpec *static_ps, const JSFunctionSpec *static_fs);

 /*

  * Set up ctor.prototype = proto and proto.constructor = ctor with the

  * right property flags.

  */

 extern JS_PUBLIC_API(bool)

 JS_LinkConstructorAndPrototype(JSContext *cx, JS::Handle<JSObject*> ctor,

                                JS::Handle<JSObject*> proto);

 extern JS_PUBLIC_API(const JSClass *)

 JS_GetClass(JSObject *obj);

 extern JS_PUBLIC_API(bool)

 JS_InstanceOf(JSContext *cx, JS::Handle<JSObject*> obj, const JSClass *clasp, JS::CallArgs *args);

 extern JS_PUBLIC_API(bool)

 JS_HasInstance(JSContext *cx, JS::Handle<JSObject*> obj, JS::Handle<JS::Value> v, bool *bp);

 extern JS_PUBLIC_API(void *)

 JS_GetPrivate(JSObject *obj);

 extern JS_PUBLIC_API(void)

 JS_SetPrivate(JSObject *obj, void *data);

 extern JS_PUBLIC_API(void *)

 JS_GetInstancePrivate(JSContext *cx, JS::Handle<JSObject*> obj, const JSClass *clasp,

                       JS::CallArgs *args);

 extern JS_PUBLIC_API(bool)

 JS_GetPrototype(JSContext *cx, JS::HandleObject obj, JS::MutableHandleObject protop);

 extern JS_PUBLIC_API(bool)

 JS_SetPrototype(JSContext *cx, JS::HandleObject obj, JS::HandleObject proto);

 extern JS_PUBLIC_API(JSObject *)

 JS_GetParent(JSObject *obj);

 extern JS_PUBLIC_API(bool)

 JS_SetParent(JSContext *cx, JS::HandleObject obj, JS::HandleObject parent);

 extern JS_PUBLIC_API(JSObject *)

 JS_GetConstructor(JSContext *cx, JS::Handle<JSObject*> proto);

 namespace JS {

 enum ZoneSpecifier {

     FreshZone = 0,

     SystemZone = 1

 };

 class JS_PUBLIC_API(CompartmentOptions)

 {

   public:

     class Override {

       public:

         Override() : mode_(Default) {}

         bool get(bool defaultValue) const {

             if (mode_ == Default)

                 return defaultValue;

             return mode_ == ForceTrue;

         };

         void set(bool overrideValue) {

             mode_ = overrideValue ? ForceTrue : ForceFalse;

         };

         void reset() {

             mode_ = Default;

         }

       private:

         enum Mode {

             Default,

             ForceTrue,

             ForceFalse

         };

         Mode mode_;

     };

     explicit CompartmentOptions()

       : version_(JSVERSION_UNKNOWN)

       , invisibleToDebugger_(false)

       , mergeable_(false)

       , discardSource_(false)

       , traceGlobal_(nullptr)

       , singletonsAsTemplates_(true)

     {

         zone_.spec = JS::FreshZone;

     }

     JSVersion version() const { return version_; }

     CompartmentOptions &setVersion(JSVersion aVersion) {

         MOZ_ASSERT(aVersion != JSVERSION_UNKNOWN);

         version_ = aVersion;

         return *this;

     }

     // Certain scopes (i.e. XBL compilation scopes) are implementation details

     // of the embedding, and references to them should never leak out to script.

     // This flag causes the this compartment to skip firing onNewGlobalObject

     // and makes addDebuggee a no-op for this global.

     bool invisibleToDebugger() const { return invisibleToDebugger_; }

     CompartmentOptions &setInvisibleToDebugger(bool flag) {

         invisibleToDebugger_ = flag;

         return *this;

     }

     // Compartments used for off-thread compilation have their contents merged

     // into a target compartment when the compilation is finished. This is only

     // allowed if this flag is set.  The invisibleToDebugger flag must also be

     // set for such compartments.

     bool mergeable() const { return mergeable_; }

     CompartmentOptions &setMergeable(bool flag) {

         mergeable_ = flag;