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

*/

#include "jsapi.h"

#include "mozilla/FloatingPoint.h"

#include "mozilla/PodOperations.h"

#include "mozilla/UniquePtr.h"

#include <ctype.h>

#include <stdarg.h>

#include <string.h>

#include <sys/stat.h>

#include "jsarray.h"

#include "jsatom.h"

#include "jsbool.h"

#include "jscntxt.h"

#include "jsdate.h"

#include "jsexn.h"

#include "jsfriendapi.h"

#include "jsfun.h"

#include "jsgc.h"

#include "jsiter.h"

#include "jslock.h"

#include "jsmath.h"

#include "jsnum.h"

#include "jsobj.h"

#include "json.h"

#include "jsprf.h"

#include "jsscript.h"

#include "jsstr.h"

#include "jstypes.h"

#include "jsutil.h"

#include "jswatchpoint.h"

#include "jsweakmap.h"

#include "jswrapper.h"

#include "asmjs/AsmJSLink.h"

#include "builtin/AtomicsObject.h"

#include "builtin/Eval.h"

#include "builtin/Intl.h"

#include "builtin/MapObject.h"

#include "builtin/RegExp.h"

#include "builtin/SymbolObject.h"

#ifdef ENABLE_BINARYDATA

#include "builtin/SIMD.h"

#include "builtin/TypedObject.h"

#endif

#include "frontend/BytecodeCompiler.h"

#include "frontend/FullParseHandler.h" // for JS_BufferIsCompileableUnit

#include "frontend/Parser.h" // for JS_BufferIsCompileableUnit

#include "gc/Marking.h"

#include "jit/JitCommon.h"

#include "js/CharacterEncoding.h"

#include "js/Conversions.h"

#include "js/Date.h"

#include "js/Initialization.h"

#include "js/Proxy.h"

#include "js/SliceBudget.h"

#include "js/StructuredClone.h"

#include "vm/DateObject.h"

#include "vm/Debugger.h"

#include "vm/ErrorObject.h"

#include "vm/HelperThreads.h"

#include "vm/Interpreter.h"

#include "vm/RegExpStatics.h"

#include "vm/Runtime.h"

#include "vm/SavedStacks.h"

#include "vm/ScopeObject.h"

#include "vm/Shape.h"

#include "vm/StopIterationObject.h"

#include "vm/StringBuffer.h"

#include "vm/Symbol.h"

#include "vm/TypedArrayCommon.h"

#include "vm/WrapperObject.h"

#include "vm/Xdr.h"

#include "jsatominlines.h"

#include "jsfuninlines.h"

#include "jsscriptinlines.h"

#include "vm/Interpreter-inl.h"

#include "vm/NativeObject-inl.h"

#include "vm/SavedStacks-inl.h"

#include "vm/String-inl.h"

using namespace js;

using namespace js::gc;

using mozilla::Maybe;

using mozilla::PodCopy;

using mozilla::PodZero;

using mozilla::UniquePtr;

using JS::AutoGCRooter;

using JS::ToInt32;

using JS::ToInteger;

using JS::ToUint32;

using js::frontend::Parser;

#ifdef HAVE_VA_LIST_AS_ARRAY

#define JS_ADDRESSOF_VA_LIST(ap) ((va_list*)(ap))

#else

#define JS_ADDRESSOF_VA_LIST(ap) (&(ap))

#endif

bool

JS::CallArgs::requireAtLeast(JSContext* cx, const char* fnname, unsigned required) const

{

if (length() < required) {

char numArgsStr[40];

JS_snprintf(numArgsStr, sizeof numArgsStr, "%u", required - 1);

JS_ReportErrorNumber(cx, GetErrorMessage, nullptr, JSMSG_MORE_ARGS_NEEDED,

fnname, numArgsStr, required == 2 ? "" : "s");

return false;

}

return true;

}

static bool

ErrorTakesArguments(unsigned msg)

{

MOZ_ASSERT(msg < JSErr_Limit);

unsigned argCount = js_ErrorFormatString[msg].argCount;

MOZ_ASSERT(argCount <= 2);

return argCount == 1 || argCount == 2;

}

static bool

ErrorTakesObjectArgument(unsigned msg)

{

MOZ_ASSERT(msg < JSErr_Limit);

unsigned argCount = js_ErrorFormatString[msg].argCount;

MOZ_ASSERT(argCount <= 2);

return argCount == 2;

}

JS_PUBLIC_API(bool)

JS::ObjectOpResult::reportStrictErrorOrWarning(JSContext* cx, HandleObject obj, HandleId id,

bool strict)

{

static_assert(unsigned(OkCode) == unsigned(JSMSG_NOT_AN_ERROR),

"unsigned value of OkCode must not be an error code");

MOZ_ASSERT(code_ != Uninitialized);

MOZ_ASSERT(!ok());

unsigned flags = strict ? JSREPORT_ERROR : (JSREPORT_WARNING | JSREPORT_STRICT);

if (code_ == JSMSG_OBJECT_NOT_EXTENSIBLE || code_ == JSMSG_SET_NON_OBJECT_RECEIVER) {

RootedValue val(cx, ObjectValue(*obj));

return ReportValueErrorFlags(cx, flags, code_, JSDVG_IGNORE_STACK, val,

nullptr, nullptr, nullptr);

}

if (ErrorTakesArguments(code_)) {

RootedValue idv(cx, IdToValue(id));

RootedString str(cx, ValueToSource(cx, idv));

if (!str)

return false;

JSAutoByteString propName(cx, str);

if (!propName)

return false;

if (ErrorTakesObjectArgument(code_)) {

return JS_ReportErrorFlagsAndNumber(cx, flags, GetErrorMessage, nullptr, code_,

obj->getClass()->name, propName.ptr());

}

return JS_ReportErrorFlagsAndNumber(cx, flags, GetErrorMessage, nullptr, code_,

propName.ptr());

}

return JS_ReportErrorFlagsAndNumber(cx, flags, GetErrorMessage, nullptr, code_);

}

JS_PUBLIC_API(bool)

JS::ObjectOpResult::reportStrictErrorOrWarning(JSContext* cx, HandleObject obj, bool strict)

{

MOZ_ASSERT(code_ != Uninitialized);

MOZ_ASSERT(!ok());

MOZ_ASSERT(!ErrorTakesArguments(code_));

unsigned flags = strict ? JSREPORT_ERROR : (JSREPORT_WARNING | JSREPORT_STRICT);

return JS_ReportErrorFlagsAndNumber(cx, flags, GetErrorMessage, nullptr, code_);

}

JS_PUBLIC_API(bool)

JS::ObjectOpResult::failCantRedefineProp()

{

return fail(JSMSG_CANT_REDEFINE_PROP);

}

JS_PUBLIC_API(bool)

JS::ObjectOpResult::failReadOnly()

{

return fail(JSMSG_READ_ONLY);

}

JS_PUBLIC_API(bool)

JS::ObjectOpResult::failGetterOnly()

{

return fail(JSMSG_GETTER_ONLY);

}

JS_PUBLIC_API(bool)

JS::ObjectOpResult::failCantDelete()

{

return fail(JSMSG_CANT_DELETE);

}

JS_PUBLIC_API(bool)

JS::ObjectOpResult::failCantSetInterposed()

{

return fail(JSMSG_CANT_SET_INTERPOSED);

}

JS_PUBLIC_API(bool)

JS::ObjectOpResult::failCantDefineWindowElement()

{

return fail(JSMSG_CANT_DEFINE_WINDOW_ELEMENT);

}

JS_PUBLIC_API(bool)

JS::ObjectOpResult::failCantDeleteWindowElement()

{

return fail(JSMSG_CANT_DELETE_WINDOW_ELEMENT);

}

JS_PUBLIC_API(bool)

JS::ObjectOpResult::failCantDeleteWindowNamedProperty()

{

return fail(JSMSG_CANT_DELETE_WINDOW_NAMED_PROPERTY);

}

JS_PUBLIC_API(bool)

JS::ObjectOpResult::failCantPreventExtensions()

{

return fail(JSMSG_CANT_PREVENT_EXTENSIONS);

}

JS_PUBLIC_API(bool)

JS::ObjectOpResult::failCantSetProto()

{

return fail(JSMSG_CANT_SET_PROTO);

}

JS_PUBLIC_API(bool)

JS::ObjectOpResult::failNoNamedSetter()

{

return fail(JSMSG_NO_NAMED_SETTER);

}

JS_PUBLIC_API(bool)

JS::ObjectOpResult::failNoIndexedSetter()

{

return fail(JSMSG_NO_INDEXED_SETTER);

}

JS_PUBLIC_API(int64_t)

JS_Now()

{

return PRMJ_Now();

}

JS_PUBLIC_API(Value)

JS_GetNaNValue(JSContext* cx)

{

return cx->runtime()->NaNValue;

}

JS_PUBLIC_API(Value)

JS_GetNegativeInfinityValue(JSContext* cx)

{

return cx->runtime()->negativeInfinityValue;

}

JS_PUBLIC_API(Value)

JS_GetPositiveInfinityValue(JSContext* cx)

{

return cx->runtime()->positiveInfinityValue;

}

JS_PUBLIC_API(Value)

JS_GetEmptyStringValue(JSContext* cx)

{

return StringValue(cx->runtime()->emptyString);

}

JS_PUBLIC_API(JSString*)

JS_GetEmptyString(JSRuntime* rt)

{

MOZ_ASSERT(rt->hasContexts());

return rt->emptyString;

}

namespace js {

void

AssertHeapIsIdle(JSRuntime* rt)

{

MOZ_ASSERT(!rt->isHeapBusy());

}

void

AssertHeapIsIdle(JSContext* cx)

{

AssertHeapIsIdle(cx->runtime());

}

} // namespace js

static void

AssertHeapIsIdleOrIterating(JSRuntime* rt)

{

MOZ_ASSERT(!rt->isHeapCollecting());

}

static void

AssertHeapIsIdleOrIterating(JSContext* cx)

{

AssertHeapIsIdleOrIterating(cx->runtime());

}

static void

AssertHeapIsIdleOrStringIsFlat(JSContext* cx, JSString* str)

{

/*

* We allow some functions to be called during a GC as long as the argument

* is a flat string, since that will not cause allocation.

*/

MOZ_ASSERT_IF(cx->runtime()->isHeapBusy(), str->isFlat());

}

JS_PUBLIC_API(bool)

JS_ValueToObject(JSContext* cx, HandleValue value, MutableHandleObject objp)

{

AssertHeapIsIdle(cx);

CHECK_REQUEST(cx);

assertSameCompartment(cx, value);

if (value.isNullOrUndefined()) {

objp.set(nullptr);

return true;

}

JSObject* obj = ToObject(cx, value);

if (!obj)

return false;

objp.set(obj);

return true;

}

JS_PUBLIC_API(JSFunction*)

JS_ValueToFunction(JSContext* cx, HandleValue value)

{

AssertHeapIsIdle(cx);

CHECK_REQUEST(cx);

assertSameCompartment(cx, value);

return ReportIfNotFunction(cx, value);

}

JS_PUBLIC_API(JSFunction*)

JS_ValueToConstructor(JSContext* cx, HandleValue value)

{

AssertHeapIsIdle(cx);

CHECK_REQUEST(cx);

assertSameCompartment(cx, value);

return ReportIfNotFunction(cx, value);

}

JS_PUBLIC_API(JSString*)

JS_ValueToSource(JSContext* cx, HandleValue value)

{

AssertHeapIsIdle(cx);

CHECK_REQUEST(cx);

assertSameCompartment(cx, value);

return ValueToSource(cx, value);

}

JS_PUBLIC_API(bool)

JS_DoubleIsInt32(double d, int32_t* ip)

{

return mozilla::NumberIsInt32(d, ip);

}

JS_PUBLIC_API(JSType)

JS_TypeOfValue(JSContext* cx, HandleValue value)

{

AssertHeapIsIdle(cx);

CHECK_REQUEST(cx);

assertSameCompartment(cx, value);

return TypeOfValue(value);

}

JS_PUBLIC_API(bool)

JS_StrictlyEqual(JSContext* cx, HandleValue value1, HandleValue value2, bool* equal)

{

AssertHeapIsIdle(cx);

CHECK_REQUEST(cx);

assertSameCompartment(cx, value1, value2);

MOZ_ASSERT(equal);

return StrictlyEqual(cx, value1, value2, equal);

}

JS_PUBLIC_API(bool)

JS_LooselyEqual(JSContext* cx, HandleValue value1, HandleValue value2, bool* equal)

{

AssertHeapIsIdle(cx);

CHECK_REQUEST(cx);

assertSameCompartment(cx, value1, value2);

MOZ_ASSERT(equal);

return LooselyEqual(cx, value1, value2, equal);

}

JS_PUBLIC_API(bool)

JS_SameValue(JSContext* cx, HandleValue value1, HandleValue value2, bool* same)

{

AssertHeapIsIdle(cx);

CHECK_REQUEST(cx);

assertSameCompartment(cx, value1, value2);

MOZ_ASSERT(same);

return SameValue(cx, value1, value2, same);

}

JS_PUBLIC_API(bool)

JS_IsBuiltinEvalFunction(JSFunction* fun)

{

return IsAnyBuiltinEval(fun);

}

JS_PUBLIC_API(bool)

JS_IsBuiltinFunctionConstructor(JSFunction* fun)

{

return fun->isBuiltinFunctionConstructor();

}

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

#ifdef DEBUG

JS_FRIEND_API(bool)

JS::isGCEnabled()

{

return !TlsPerThreadData.get()->suppressGC;

}

#else

JS_FRIEND_API(bool) JS::isGCEnabled() { return true; }

#endif

JS_PUBLIC_API(JSRuntime*)

JS_NewRuntime(uint32_t maxbytes, uint32_t maxNurseryBytes, JSRuntime* parentRuntime)

{

MOZ_ASSERT(JS::detail::libraryInitState == JS::detail::InitState::Running,

"must call JS_Init prior to creating any JSRuntimes");

// Make sure that all parent runtimes are the topmost parent.

while (parentRuntime && parentRuntime->parentRuntime)

parentRuntime = parentRuntime->parentRuntime;

JSRuntime* rt = js_new<JSRuntime>(parentRuntime);

if (!rt)

return nullptr;

if (!rt->init(maxbytes, maxNurseryBytes)) {

JS_DestroyRuntime(rt);

return nullptr;

}

return rt;

}

JS_PUBLIC_API(void)

JS_DestroyRuntime(JSRuntime* rt)

{

js_delete(rt);

}

static JS_CurrentEmbedderTimeFunction currentEmbedderTimeFunction;

JS_PUBLIC_API(void)

JS_SetCurrentEmbedderTimeFunction(JS_CurrentEmbedderTimeFunction timeFn)

{

currentEmbedderTimeFunction = timeFn;

}

JS_PUBLIC_API(double)

JS_GetCurrentEmbedderTime()

{

if (currentEmbedderTimeFunction)

return currentEmbedderTimeFunction();

return PRMJ_Now() / static_cast<double>(PRMJ_USEC_PER_MSEC);

}

JS_PUBLIC_API(void*)

JS_GetRuntimePrivate(JSRuntime* rt)

{

return rt->data;

}

JS_PUBLIC_API(void)

JS_SetRuntimePrivate(JSRuntime* rt, void* data)

{

rt->data = data;

}

static void

StartRequest(JSContext* cx)

{

JSRuntime* rt = cx->runtime();

MOZ_ASSERT(CurrentThreadCanAccessRuntime(rt));

if (rt->requestDepth) {

rt->requestDepth++;

} else {

/* Indicate that a request is running. */

rt->requestDepth = 1;

rt->triggerActivityCallback(true);

}

}

static void

StopRequest(JSContext* cx)

{

JSRuntime* rt = cx->runtime();

MOZ_ASSERT(CurrentThreadCanAccessRuntime(rt));

MOZ_ASSERT(rt->requestDepth != 0);

if (rt->requestDepth != 1) {

rt->requestDepth--;

} else {

rt->requestDepth = 0;

rt->triggerActivityCallback(false);

}

}

JS_PUBLIC_API(void)

JS_BeginRequest(JSContext* cx)

{

cx->outstandingRequests++;

StartRequest(cx);

}

JS_PUBLIC_API(void)

JS_EndRequest(JSContext* cx)

{

MOZ_ASSERT(cx->outstandingRequests != 0);

cx->outstandingRequests--;

StopRequest(cx);

}

JS_PUBLIC_API(void)

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

{

rt->cxCallback = cxCallback;

rt->cxCallbackData = data;

}

JS_PUBLIC_API(JSContext*)

JS_NewContext(JSRuntime* rt, size_t stackChunkSize)

{

return NewContext(rt, stackChunkSize);

}

JS_PUBLIC_API(void)

JS_DestroyContext(JSContext* cx)

{

MOZ_ASSERT(!cx->compartment());

DestroyContext(cx, DCM_FORCE_GC);

}

JS_PUBLIC_API(void)

JS_DestroyContextNoGC(JSContext* cx)

{

MOZ_ASSERT(!cx->compartment());

DestroyContext(cx, DCM_NO_GC);

}

JS_PUBLIC_API(void*)

JS_GetContextPrivate(JSContext* cx)

{

return cx->data;

}

JS_PUBLIC_API(void)

JS_SetContextPrivate(JSContext* cx, void* data)

{

cx->data = data;

}

JS_PUBLIC_API(void*)

JS_GetSecondContextPrivate(JSContext* cx)

{

return cx->data2;

}

JS_PUBLIC_API(void)

JS_SetSecondContextPrivate(JSContext* cx, void* data)

{

cx->data2 = data;

}

JS_PUBLIC_API(JSRuntime*)

JS_GetRuntime(JSContext* cx)

{

return cx->runtime();

}

JS_PUBLIC_API(JSRuntime*)

JS_GetParentRuntime(JSContext* cx)

{

JSRuntime* rt = cx->runtime();

return rt->parentRuntime ? rt->parentRuntime : rt;

}

JS_PUBLIC_API(JSContext*)

JS_ContextIterator(JSRuntime* rt, JSContext** iterp)

{

JSContext* cx = *iterp;

cx = cx ? cx->getNext() : rt->contextList.getFirst();

*iterp = cx;

return cx;

}

JS_PUBLIC_API(JSVersion)

JS_GetVersion(JSContext* cx)

{

return VersionNumber(cx->findVersion());

}

JS_PUBLIC_API(void)

JS_SetVersionForCompartment(JSCompartment* compartment, JSVersion version)

{

compartment->options().setVersion(version);

}

static const struct v2smap {

JSVersion version;

const char* string;

} v2smap[] = {

{JSVERSION_ECMA_3, "ECMAv3"},

{JSVERSION_1_6, "1.6"},

{JSVERSION_1_7, "1.7"},

{JSVERSION_1_8, "1.8"},

{JSVERSION_ECMA_5, "ECMAv5"},

{JSVERSION_DEFAULT, js_default_str},

{JSVERSION_DEFAULT, "1.0"},

{JSVERSION_DEFAULT, "1.1"},

{JSVERSION_DEFAULT, "1.2"},

{JSVERSION_DEFAULT, "1.3"},

{JSVERSION_DEFAULT, "1.4"},

{JSVERSION_DEFAULT, "1.5"},

{JSVERSION_UNKNOWN, nullptr}, /* must be last, nullptr is sentinel */

};

JS_PUBLIC_API(const char*)

JS_VersionToString(JSVersion version)

{

int i;

for (i = 0; v2smap[i].string; i++)

if (v2smap[i].version == version)

return v2smap[i].string;

return "unknown";

}

JS_PUBLIC_API(JSVersion)

JS_StringToVersion(const char* string)

{

int i;

for (i = 0; v2smap[i].string; i++)

if (strcmp(v2smap[i].string, string) == 0)

return v2smap[i].version;

return JSVERSION_UNKNOWN;

}

JS_PUBLIC_API(JS::RuntimeOptions&)

JS::RuntimeOptionsRef(JSRuntime* rt)

{

return rt->options();

}

JS_PUBLIC_API(JS::RuntimeOptions&)

JS::RuntimeOptionsRef(JSContext* cx)

{

return cx->runtime()->options();

}

JS_PUBLIC_API(JS::ContextOptions&)

JS::ContextOptionsRef(JSContext* cx)

{

return cx->options();

}

JS_PUBLIC_API(const char*)

JS_GetImplementationVersion(void)

{

return "JavaScript-C" MOZILLA_VERSION;

}

JS_PUBLIC_API(void)

JS_SetDestroyCompartmentCallback(JSRuntime* rt, JSDestroyCompartmentCallback callback)

{

rt->destroyCompartmentCallback = callback;

}

JS_PUBLIC_API(void)

JS_SetDestroyZoneCallback(JSRuntime* rt, JSZoneCallback callback)

{

rt->destroyZoneCallback = callback;

}

JS_PUBLIC_API(void)

JS_SetSweepZoneCallback(JSRuntime* rt, JSZoneCallback callback)

{

rt->sweepZoneCallback = callback;

}

JS_PUBLIC_API(void)

JS_SetCompartmentNameCallback(JSRuntime* rt, JSCompartmentNameCallback callback)

{

rt->compartmentNameCallback = callback;

}

JS_PUBLIC_API(void)

JS_SetWrapObjectCallbacks(JSRuntime* rt, const JSWrapObjectCallbacks* callbacks)

{

rt->wrapObjectCallbacks = callbacks;

}

JS_PUBLIC_API(JSCompartment*)

JS_EnterCompartment(JSContext* cx, JSObject* target)

{

AssertHeapIsIdle(cx);

CHECK_REQUEST(cx);

JSCompartment* oldCompartment = cx->compartment();

cx->enterCompartment(target->compartment());

return oldCompartment;

}

JS_PUBLIC_API(void)

JS_LeaveCompartment(JSContext* cx, JSCompartment* oldCompartment)

{

AssertHeapIsIdle(cx);

CHECK_REQUEST(cx);

cx->leaveCompartment(oldCompartment);

}

JSAutoCompartment::JSAutoCompartment(JSContext* cx, JSObject* target

MOZ_GUARD_OBJECT_NOTIFIER_PARAM_IN_IMPL)

: cx_(cx),

oldCompartment_(cx->compartment())

{

AssertHeapIsIdleOrIterating(cx_);

MOZ_GUARD_OBJECT_NOTIFIER_INIT;

cx_->enterCompartment(target->compartment());

}

JSAutoCompartment::JSAutoCompartment(JSContext* cx, JSScript* target

MOZ_GUARD_OBJECT_NOTIFIER_PARAM_IN_IMPL)

: cx_(cx),

oldCompartment_(cx->compartment())

{

AssertHeapIsIdleOrIterating(cx_);

MOZ_GUARD_OBJECT_NOTIFIER_INIT;

cx_->enterCompartment(target->compartment());

}

JSAutoCompartment::~JSAutoCompartment()

{

cx_->leaveCompartment(oldCompartment_);

}

JSAutoNullableCompartment::JSAutoNullableCompartment(JSContext* cx,

JSObject* targetOrNull

MOZ_GUARD_OBJECT_NOTIFIER_PARAM_IN_IMPL)

: cx_(cx),

oldCompartment_(cx->compartment())

{

AssertHeapIsIdleOrIterating(cx_);

MOZ_GUARD_OBJECT_NOTIFIER_INIT;

if (targetOrNull) {

cx_->enterCompartment(targetOrNull->compartment());

} else {

cx_->enterNullCompartment();

}

}

JSAutoNullableCompartment::~JSAutoNullableCompartment()

{

cx_->leaveCompartment(oldCompartment_);

}

JS_PUBLIC_API(void)

JS_SetCompartmentPrivate(JSCompartment* compartment, void* data)

{

compartment->data = data;

}

JS_PUBLIC_API(void*)

JS_GetCompartmentPrivate(JSCompartment* compartment)

{

return compartment->data;

}

JS_PUBLIC_API(JSAddonId*)

JS::NewAddonId(JSContext* cx, HandleString str)

{

return static_cast<JSAddonId*>(JS_AtomizeAndPinJSString(cx, str));

}

JS_PUBLIC_API(JSString*)

JS::StringOfAddonId(JSAddonId* id)

{

return id;

}

JS_PUBLIC_API(JSAddonId*)

JS::AddonIdOfObject(JSObject* obj)

{

return obj->compartment()->addonId;

}

JS_PUBLIC_API(void)

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

{

zone->data = data;

}

JS_PUBLIC_API(void*)

JS_GetZoneUserData(JS::Zone* zone)

{

return zone->data;

}

JS_PUBLIC_API(bool)

JS_WrapObject(JSContext* cx, MutableHandleObject objp)

{

AssertHeapIsIdle(cx);

CHECK_REQUEST(cx);

if (objp)

JS::ExposeObjectToActiveJS(objp);

return cx->compartment()->wrap(cx, objp);

}

JS_PUBLIC_API(bool)

JS_WrapValue(JSContext* cx, MutableHandleValue vp)

{

AssertHeapIsIdle(cx);

CHECK_REQUEST(cx);

JS::ExposeValueToActiveJS(vp);

return cx->compartment()->wrap(cx, vp);

}

/*

* Identity remapping. Not for casual consumers.

*

* Normally, an object's contents and its identity are inextricably linked.

* Identity is determined by the address of the JSObject* in the heap, and

* the contents are what is located at that address. Transplanting allows these

* concepts to be separated through a combination of swapping (exchanging the

* contents of two same-compartment objects) and remapping cross-compartment

* identities by altering wrappers.

*

* The |origobj| argument should be the object whose identity needs to be

* remapped, usually to another compartment. The contents of |origobj| are

* destroyed.

*

* The |target| argument serves two purposes:

*

* First, |target| serves as a hint for the new identity of the object. The new

* identity object will always be in the same compartment as |target|, but

* if that compartment already had an object representing |origobj| (either a

* cross-compartment wrapper for it, or |origobj| itself if the two arguments

* are same-compartment), the existing object is used. Otherwise, |target|

* itself is used. To avoid ambiguity, JS_TransplantObject always returns the

* new identity.

*

* Second, the new identity object's contents will be those of |target|. A swap()

* is used to make this happen if an object other than |target| is used.

*

* We don't have a good way to recover from failure in this function, so

* we intentionally crash instead.

*/

JS_PUBLIC_API(JSObject*)

JS_TransplantObject(JSContext* cx, HandleObject origobj, HandleObject target)

{

AssertHeapIsIdle(cx);

MOZ_ASSERT(origobj != target);

MOZ_ASSERT(!origobj->is<CrossCompartmentWrapperObject>());

MOZ_ASSERT(!target->is<CrossCompartmentWrapperObject>());

RootedValue origv(cx, ObjectValue(*origobj));

RootedObject newIdentity(cx);

{

AutoDisableProxyCheck adpc(cx->runtime());

JSCompartment* destination = target->compartment();

if (origobj->compartment() == destination) {

// If the original object is in the same compartment as the

// destination, then we know that we won't find a wrapper in the

// destination's cross compartment map and that the same

// object will continue to work.

if (!JSObject::swap(cx, origobj, target))

MOZ_CRASH();

newIdentity = origobj;

} else if (WrapperMap::Ptr p = destination->lookupWrapper(origv)) {

// There might already be a wrapper for the original object in

// the new compartment. If there is, we use its identity and swap

// in the contents of |target|.

newIdentity = &p->value().get().toObject();

// When we remove origv from the wrapper map, its wrapper, newIdentity,

// must immediately cease to be a cross-compartment wrapper. Neuter it.

destination->removeWrapper(p);

NukeCrossCompartmentWrapper(cx, newIdentity);

if (!JSObject::swap(cx, newIdentity, target))

MOZ_CRASH();

} else {

// Otherwise, we use |target| for the new identity object.

newIdentity = target;

}

// Now, iterate through other scopes looking for references to the

// old object, and update the relevant cross-compartment wrappers.

if (!RemapAllWrappersForObject(cx, origobj, newIdentity))

MOZ_CRASH();

// Lastly, update the original object to point to the new one.

if (origobj->compartment() != destination) {

RootedObject newIdentityWrapper(cx, newIdentity);

AutoCompartment ac(cx, origobj);

if (!JS_WrapObject(cx, &newIdentityWrapper))

MOZ_CRASH();

MOZ_ASSERT(Wrapper::wrappedObject(newIdentityWrapper) == newIdentity);

if (!JSObject::swap(cx, origobj, newIdentityWrapper))

MOZ_CRASH();

origobj->compartment()->putWrapper(cx, CrossCompartmentKey(newIdentity), origv);

}

}

// The new identity object might be one of several things. Return it to avoid

// ambiguity.

return newIdentity;

}

/*

* Recompute all cross-compartment wrappers for an object, resetting state.

* Gecko uses this to clear Xray wrappers when doing a navigation that reuses

* the inner window and global object.

*/

JS_PUBLIC_API(bool)

JS_RefreshCrossCompartmentWrappers(JSContext* cx, HandleObject obj)

{

return RemapAllWrappersForObject(cx, obj, obj);

}

JS_PUBLIC_API(bool)

JS_InitStandardClasses(JSContext* cx, HandleObject obj)

{

MOZ_ASSERT(!cx->runtime()->isAtomsCompartment(cx->compartment()));

AssertHeapIsIdle(cx);

CHECK_REQUEST(cx);

assertSameCompartment(cx, obj);

Rooted<GlobalObject*> global(cx, &obj->global());

return GlobalObject::initStandardClasses(cx, global);

}

#define EAGER_ATOM(name) NAME_OFFSET(name)

typedef struct JSStdName {

size_t atomOffset; /* offset of atom pointer in JSAtomState */

JSProtoKey key;

bool isDummy() const { return key == JSProto_Null; }

bool isSentinel() const { return key == JSProto_LIMIT; }

} JSStdName;

static const JSStdName*

LookupStdName(const JSAtomState& names, JSAtom* name, const JSStdName* table)

{

for (unsigned i = 0; !table[i].isSentinel(); i++) {

if (table[i].isDummy())

continue;

JSAtom* atom = AtomStateOffsetToName(names, table[i].atomOffset);

MOZ_ASSERT(atom);

if (name == atom)

return &table[i];