blob: d05c36922bfeeac79f28ae09183646884b79a81b [file] [log] [blame]
/* -*- 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"
#if defined(STARBOARD)
#include "starboard/file.h"
#endif
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];
}
return nullptr;
}
/*
* Table of standard classes, indexed by JSProtoKey. For entries where the
* JSProtoKey does not correspond to a class with a meaningful constructor, we
* insert a null entry into the table.
*/
#define STD_NAME_ENTRY(name, code, init, clasp) { EAGER_ATOM(name), static_cast<JSProtoKey>(code) },
#define STD_DUMMY_ENTRY(name, code, init, dummy) { 0, JSProto_Null },
static const JSStdName standard_class_names[] = {
JS_FOR_PROTOTYPES(STD_NAME_ENTRY, STD_DUMMY_ENTRY)
{ 0, JSProto_LIMIT }
};
/*
* Table of top-level function and constant names and the JSProtoKey of the
* standard class that initializes them.
*/
static const JSStdName builtin_property_names[] = {
{ EAGER_ATOM(eval), JSProto_Object },
/* Global properties and functions defined by the Number class. */
{ EAGER_ATOM(NaN), JSProto_Number },
{ EAGER_ATOM(Infinity), JSProto_Number },
{ EAGER_ATOM(isNaN), JSProto_Number },
{ EAGER_ATOM(isFinite), JSProto_Number },
{ EAGER_ATOM(parseFloat), JSProto_Number },
{ EAGER_ATOM(parseInt), JSProto_Number },
/* String global functions. */
{ EAGER_ATOM(escape), JSProto_String },
{ EAGER_ATOM(unescape), JSProto_String },
{ EAGER_ATOM(decodeURI), JSProto_String },
{ EAGER_ATOM(encodeURI), JSProto_String },
{ EAGER_ATOM(decodeURIComponent), JSProto_String },
{ EAGER_ATOM(encodeURIComponent), JSProto_String },
#if JS_HAS_UNEVAL
{ EAGER_ATOM(uneval), JSProto_String },
#endif
#ifdef ENABLE_BINARYDATA
{ EAGER_ATOM(SIMD), JSProto_SIMD },
{ EAGER_ATOM(TypedObject), JSProto_TypedObject },
#endif
#ifdef ENABLE_SHARED_ARRAY_BUFFER
{ EAGER_ATOM(Atomics), JSProto_Atomics },
#endif
{ 0, JSProto_LIMIT }
};
#undef EAGER_ATOM
JS_PUBLIC_API(bool)
JS_ResolveStandardClass(JSContext* cx, HandleObject obj, HandleId id, bool* resolved)
{
JSRuntime* rt;
const JSStdName* stdnm;
AssertHeapIsIdle(cx);
CHECK_REQUEST(cx);
assertSameCompartment(cx, obj, id);
Rooted<GlobalObject*> global(cx, &obj->as<GlobalObject>());
*resolved = false;
rt = cx->runtime();
if (!rt->hasContexts() || !JSID_IS_ATOM(id))
return true;
/* Check whether we're resolving 'undefined', and define it if so. */
JSAtom* idAtom = JSID_TO_ATOM(id);
JSAtom* undefinedAtom = cx->names().undefined;
if (idAtom == undefinedAtom) {
*resolved = true;
return DefineProperty(cx, global, id, UndefinedHandleValue, nullptr, nullptr,
JSPROP_PERMANENT | JSPROP_READONLY | JSPROP_RESOLVING);
}
/* Try for class constructors/prototypes named by well-known atoms. */
stdnm = LookupStdName(cx->names(), idAtom, standard_class_names);
/* Try less frequently used top-level functions and constants. */
if (!stdnm)
stdnm = LookupStdName(cx->names(), idAtom, builtin_property_names);
// If this class is anonymous, then it doesn't exist as a global
// property, so we won't resolve anything.
JSProtoKey key = stdnm ? stdnm->key : JSProto_Null;
if (key != JSProto_Null) {
const Class* clasp = ProtoKeyToClass(key);
if (!clasp || !(clasp->flags & JSCLASS_IS_ANONYMOUS)) {
if (!GlobalObject::ensureConstructor(cx, global, key))
return false;
*resolved = true;
return true;
}
}
// There is no such property to resolve. An ordinary resolve hook would
// just return true at this point. But the global object is special in one
// more way: its prototype chain is lazily initialized. That is,
// global->getProto() might be null right now because we haven't created
// Object.prototype yet. Force it now.
if (!global->getOrCreateObjectPrototype(cx))
return false;
return true;
}
JS_PUBLIC_API(bool)
JS_MayResolveStandardClass(const JSAtomState& names, jsid id, JSObject* maybeObj)
{
MOZ_ASSERT_IF(maybeObj, maybeObj->is<GlobalObject>());
// The global object's resolve hook is special: JS_ResolveStandardClass
// initializes the prototype chain lazily. Only attempt to optimize here
// if we know the prototype chain has been initialized.
if (!maybeObj || !maybeObj->getProto())
return true;
if (!JSID_IS_ATOM(id))
return false;
JSAtom* atom = JSID_TO_ATOM(id);
return atom == names.undefined ||
LookupStdName(names, atom, standard_class_names) ||
LookupStdName(names, atom, builtin_property_names);
}
JS_PUBLIC_API(bool)
JS_EnumerateStandardClasses(JSContext* cx, HandleObject obj)
{
AssertHeapIsIdle(cx);
CHECK_REQUEST(cx);
assertSameCompartment(cx, obj);
MOZ_ASSERT(obj->is<GlobalObject>());
Rooted<GlobalObject*> global(cx, &obj->as<GlobalObject>());
return GlobalObject::initStandardClasses(cx, global);
}
JS_PUBLIC_API(bool)
JS_GetClassObject(JSContext* cx, JSProtoKey key, MutableHandleObject objp)
{
AssertHeapIsIdle(cx);
CHECK_REQUEST(cx);
return GetBuiltinConstructor(cx, key, objp);
}
JS_PUBLIC_API(bool)
JS_GetClassPrototype(JSContext* cx, JSProtoKey key, MutableHandleObject objp)
{
AssertHeapIsIdle(cx);
CHECK_REQUEST(cx);
return GetBuiltinPrototype(cx, key, objp);
}
namespace JS {
JS_PUBLIC_API(void)
ProtoKeyToId(JSContext* cx, JSProtoKey key, MutableHandleId idp)
{
idp.set(NameToId(ClassName(key, cx)));
}
} /* namespace JS */
JS_PUBLIC_API(JSProtoKey)
JS_IdToProtoKey(JSContext* cx, HandleId id)
{
AssertHeapIsIdle(cx);
CHECK_REQUEST(cx);
if (!JSID_IS_ATOM(id))
return JSProto_Null;
JSAtom* atom = JSID_TO_ATOM(id);
const JSStdName* stdnm = LookupStdName(cx->names(), atom, standard_class_names);
if (!stdnm)
return JSProto_Null;
MOZ_ASSERT(MOZ_ARRAY_LENGTH(standard_class_names) == JSProto_LIMIT + 1);
return static_cast<JSProtoKey>(stdnm - standard_class_names);
}
JS_PUBLIC_API(JSObject*)
JS_GetObjectPrototype(JSContext* cx, HandleObject forObj)
{
CHECK_REQUEST(cx);
assertSameCompartment(cx, forObj);
return forObj->global().getOrCreateObjectPrototype(cx);
}
JS_PUBLIC_API(JSObject*)
JS_GetFunctionPrototype(JSContext* cx, HandleObject forObj)
{
CHECK_REQUEST(cx);
assertSameCompartment(cx, forObj);
return forObj->global().getOrCreateFunctionPrototype(cx);
}
JS_PUBLIC_API(JSObject*)
JS_GetArrayPrototype(JSContext* cx, HandleObject forObj)
{
CHECK_REQUEST(cx);
assertSameCompartment(cx, forObj);
Rooted<GlobalObject*> global(cx, &forObj->global());
return GlobalObject::getOrCreateArrayPrototype(cx, global);
}
JS_PUBLIC_API(JSObject*)
JS_GetErrorPrototype(JSContext* cx)
{
CHECK_REQUEST(cx);
Rooted<GlobalObject*> global(cx, cx->global());
return GlobalObject::getOrCreateCustomErrorPrototype(cx, global, JSEXN_ERR);
}
JS_PUBLIC_API(JSObject*)
JS_GetIteratorPrototype(JSContext* cx)
{
CHECK_REQUEST(cx);
Rooted<GlobalObject*> global(cx, cx->global());
return GlobalObject::getOrCreateIteratorPrototype(cx, global);
}
JS_PUBLIC_API(JSObject*)
JS_GetGlobalForObject(JSContext* cx, JSObject* obj)
{
AssertHeapIsIdle(cx);
assertSameCompartment(cx, obj);
return &obj->global();
}
extern JS_PUBLIC_API(bool)
JS_IsGlobalObject(JSObject* obj)
{
return obj->is<GlobalObject>();
}
extern JS_PUBLIC_API(JSObject*)
JS_GlobalLexicalScope(JSObject* obj)
{
return &obj->as<GlobalObject>().lexicalScope();
}
extern JS_PUBLIC_API(bool)
JS_HasExtensibleLexicalScope(JSObject* obj)
{
return obj->is<GlobalObject>() || obj->compartment()->getNonSyntacticLexicalScope(obj);
}
extern JS_PUBLIC_API(JSObject*)
JS_ExtensibleLexicalScope(JSObject* obj)
{
JSObject* lexical = nullptr;
if (obj->is<GlobalObject>())
lexical = JS_GlobalLexicalScope(obj);
else
lexical = obj->compartment()->getNonSyntacticLexicalScope(obj);
MOZ_ASSERT(lexical);
return lexical;
}
JS_PUBLIC_API(JSObject*)
JS_GetGlobalForCompartmentOrNull(JSContext* cx, JSCompartment* c)
{
AssertHeapIsIdleOrIterating(cx);
assertSameCompartment(cx, c);
return c->maybeGlobal();
}
JS_PUBLIC_API(JSObject*)
JS::CurrentGlobalOrNull(JSContext* cx)
{
AssertHeapIsIdleOrIterating(cx);
CHECK_REQUEST(cx);
if (!cx->compartment())
return nullptr;
return cx->global();
}
JS_PUBLIC_API(Value)
JS_ComputeThis(JSContext* cx, Value* vp)
{
AssertHeapIsIdle(cx);
assertSameCompartment(cx, JSValueArray(vp, 2));
CallReceiver call = CallReceiverFromVp(vp);
if (!BoxNonStrictThis(cx, call))
return NullValue();
return call.thisv();
}
JS_PUBLIC_API(void*)
JS_malloc(JSContext* cx, size_t nbytes)
{
AssertHeapIsIdle(cx);
CHECK_REQUEST(cx);
return static_cast<void*>(cx->runtime()->pod_malloc<uint8_t>(nbytes));
}
JS_PUBLIC_API(void*)
JS_realloc(JSContext* cx, void* p, size_t oldBytes, size_t newBytes)
{
AssertHeapIsIdle(cx);
CHECK_REQUEST(cx);
return static_cast<void*>(cx->zone()->pod_realloc<uint8_t>(static_cast<uint8_t*>(p), oldBytes,
newBytes));
}
JS_PUBLIC_API(void)
JS_free(JSContext* cx, void* p)
{
return js_free(p);
}
JS_PUBLIC_API(void)
JS_freeop(JSFreeOp* fop, void* p)
{
return FreeOp::get(fop)->free_(p);
}
JS_PUBLIC_API(JSFreeOp*)
JS_GetDefaultFreeOp(JSRuntime* rt)
{
return rt->defaultFreeOp();
}
JS_PUBLIC_API(void)
JS_updateMallocCounter(JSContext* cx, size_t nbytes)
{
return cx->runtime()->updateMallocCounter(cx->zone(), nbytes);
}
JS_PUBLIC_API(char*)
JS_strdup(JSContext* cx, const char* s)
{
AssertHeapIsIdle(cx);
return DuplicateString(cx, s).release();
}
JS_PUBLIC_API(char*)
JS_strdup(JSRuntime* rt, const char* s)
{
AssertHeapIsIdle(rt);
size_t n = strlen(s) + 1;
char* p = rt->pod_malloc<char>(n);
if (!p)
return nullptr;
return static_cast<char*>(js_memcpy(p, s, n));
}
#undef JS_AddRoot
JS_PUBLIC_API(bool)
JS_AddExtraGCRootsTracer(JSRuntime* rt, JSTraceDataOp traceOp, void* data)
{
return rt->gc.addBlackRootsTracer(traceOp, data);
}
JS_PUBLIC_API(void)
JS_RemoveExtraGCRootsTracer(JSRuntime* rt, JSTraceDataOp traceOp, void* data)
{
return rt->gc.removeBlackRootsTracer(traceOp, data);
}
JS_PUBLIC_API(void)
JS_GC(JSRuntime* rt)
{
AssertHeapIsIdle(rt);
JS::PrepareForFullGC(rt);
rt->gc.gc(GC_NORMAL, JS::gcreason::API);
}
JS_PUBLIC_API(void)
JS_MaybeGC(JSContext* cx)
{
GCRuntime& gc = cx->runtime()->gc;
if (!gc.maybeGC(cx->zone()))
gc.maybePeriodicFullGC();
}
JS_PUBLIC_API(void)
JS_SetGCCallback(JSRuntime* rt, JSGCCallback cb, void* data)
{
AssertHeapIsIdle(rt);
rt->gc.setGCCallback(cb, data);
}
JS_PUBLIC_API(bool)
JS_AddFinalizeCallback(JSRuntime* rt, JSFinalizeCallback cb, void* data)
{
AssertHeapIsIdle(rt);
return rt->gc.addFinalizeCallback(cb, data);
}
JS_PUBLIC_API(void)
JS_RemoveFinalizeCallback(JSRuntime* rt, JSFinalizeCallback cb)
{
rt->gc.removeFinalizeCallback(cb);
}
JS_PUBLIC_API(bool)
JS_AddWeakPointerZoneGroupCallback(JSRuntime* rt, JSWeakPointerZoneGroupCallback cb, void* data)
{
AssertHeapIsIdle(rt);
return rt->gc.addWeakPointerZoneGroupCallback(cb, data);
}
JS_PUBLIC_API(void)
JS_RemoveWeakPointerZoneGroupCallback(JSRuntime* rt, JSWeakPointerZoneGroupCallback cb)
{
rt->gc.removeWeakPointerZoneGroupCallback(cb);
}
JS_PUBLIC_API(bool)
JS_AddWeakPointerCompartmentCallback(JSRuntime* rt, JSWeakPointerCompartmentCallback cb,
void* data)
{
AssertHeapIsIdle(rt);
return rt->gc.addWeakPointerCompartmentCallback(cb, data);
}
JS_PUBLIC_API(void)
JS_RemoveWeakPointerCompartmentCallback(JSRuntime* rt, JSWeakPointerCompartmentCallback cb)
{
rt->gc.removeWeakPointerCompartmentCallback(cb);
}
JS_PUBLIC_API(void)
JS_UpdateWeakPointerAfterGC(JS::Heap<JSObject*>* objp)
{
JS_UpdateWeakPointerAfterGCUnbarriered(objp->unsafeGet());
}
JS_PUBLIC_API(void)
JS_UpdateWeakPointerAfterGCUnbarriered(JSObject** objp)
{
if (IsAboutToBeFinalizedUnbarriered(objp))
*objp = nullptr;
}
JS_PUBLIC_API(void)
JS_SetGCParameter(JSRuntime* rt, JSGCParamKey key, uint32_t value)
{
AutoLockGC lock(rt);
rt->gc.setParameter(key, value, lock);
}
JS_PUBLIC_API(uint32_t)
JS_GetGCParameter(JSRuntime* rt, JSGCParamKey key)
{
AutoLockGC lock(rt);
return rt->gc.getParameter(key, lock);
}
JS_PUBLIC_API(void)
JS_SetGCParameterForThread(JSContext* cx, JSGCParamKey key, uint32_t value)
{
MOZ_ASSERT(key == JSGC_MAX_CODE_CACHE_BYTES);
}
JS_PUBLIC_API(uint32_t)
JS_GetGCParameterForThread(JSContext* cx, JSGCParamKey key)
{
MOZ_ASSERT(key == JSGC_MAX_CODE_CACHE_BYTES);
return 0;
}
static const size_t NumGCConfigs = 14;
struct JSGCConfig {
JSGCParamKey key;
uint32_t value;
};
JS_PUBLIC_API(void)
JS_SetGCParametersBasedOnAvailableMemory(JSRuntime* rt, uint32_t availMem)
{
static const JSGCConfig minimal[NumGCConfigs] = {
{JSGC_MAX_MALLOC_BYTES, 6 * 1024 * 1024},
{JSGC_SLICE_TIME_BUDGET, 30},
{JSGC_HIGH_FREQUENCY_TIME_LIMIT, 1500},
{JSGC_HIGH_FREQUENCY_HIGH_LIMIT, 40},
{JSGC_HIGH_FREQUENCY_LOW_LIMIT, 0},
{JSGC_HIGH_FREQUENCY_HEAP_GROWTH_MAX, 300},
{JSGC_HIGH_FREQUENCY_HEAP_GROWTH_MIN, 120},
{JSGC_LOW_FREQUENCY_HEAP_GROWTH, 120},
{JSGC_HIGH_FREQUENCY_TIME_LIMIT, 1500},
{JSGC_HIGH_FREQUENCY_TIME_LIMIT, 1500},
{JSGC_HIGH_FREQUENCY_TIME_LIMIT, 1500},
{JSGC_ALLOCATION_THRESHOLD, 1},
{JSGC_DECOMMIT_THRESHOLD, 1},
{JSGC_MODE, JSGC_MODE_INCREMENTAL}
};
const JSGCConfig* config = minimal;
if (availMem > 512) {
static const JSGCConfig nominal[NumGCConfigs] = {
{JSGC_MAX_MALLOC_BYTES, 6 * 1024 * 1024},
{JSGC_SLICE_TIME_BUDGET, 30},
{JSGC_HIGH_FREQUENCY_TIME_LIMIT, 1000},
{JSGC_HIGH_FREQUENCY_HIGH_LIMIT, 500},
{JSGC_HIGH_FREQUENCY_LOW_LIMIT, 100},
{JSGC_HIGH_FREQUENCY_HEAP_GROWTH_MAX, 300},
{JSGC_HIGH_FREQUENCY_HEAP_GROWTH_MIN, 150},
{JSGC_LOW_FREQUENCY_HEAP_GROWTH, 150},
{JSGC_HIGH_FREQUENCY_TIME_LIMIT, 1500},
{JSGC_HIGH_FREQUENCY_TIME_LIMIT, 1500},
{JSGC_HIGH_FREQUENCY_TIME_LIMIT, 1500},
{JSGC_ALLOCATION_THRESHOLD, 30},
{JSGC_DECOMMIT_THRESHOLD, 32},
{JSGC_MODE, JSGC_MODE_COMPARTMENT}
};
config = nominal;
}
for (size_t i = 0; i < NumGCConfigs; i++)
JS_SetGCParameter(rt, config[i].key, config[i].value);
}
JS_PUBLIC_API(JSString*)
JS_NewExternalString(JSContext* cx, const char16_t* chars, size_t length,
const JSStringFinalizer* fin)
{
AssertHeapIsIdle(cx);
CHECK_REQUEST(cx);
JSString* s = JSExternalString::new_(cx, chars, length, fin);
return s;
}
extern JS_PUBLIC_API(bool)
JS_IsExternalString(JSString* str)
{
return str->isExternal();
}
extern JS_PUBLIC_API(const JSStringFinalizer*)
JS_GetExternalStringFinalizer(JSString* str)
{
return str->asExternal().externalFinalizer();
}
static void
SetNativeStackQuotaAndLimit(JSRuntime* rt, StackKind kind, size_t stackSize)
{
rt->nativeStackQuota[kind] = stackSize;
#if JS_STACK_GROWTH_DIRECTION > 0
if (stackSize == 0) {
rt->mainThread.nativeStackLimit[kind] = UINTPTR_MAX;
} else {
MOZ_ASSERT(rt->nativeStackBase <= size_t(-1) - stackSize);
rt->mainThread.nativeStackLimit[kind] = rt->nativeStackBase + stackSize - 1;
}
#else
if (stackSize == 0) {
rt->mainThread.nativeStackLimit[kind] = 0;
} else {
MOZ_ASSERT(rt->nativeStackBase >= stackSize);
rt->mainThread.nativeStackLimit[kind] = rt->nativeStackBase - (stackSize - 1);
}
#endif
}
JS_PUBLIC_API(void)
JS_SetNativeStackQuota(JSRuntime* rt, size_t systemCodeStackSize, size_t trustedScriptStackSize,
size_t untrustedScriptStackSize)
{
MOZ_ASSERT(rt->requestDepth == 0);
if (!trustedScriptStackSize)
trustedScriptStackSize = systemCodeStackSize;
else
MOZ_ASSERT(trustedScriptStackSize < systemCodeStackSize);
if (!untrustedScriptStackSize)
untrustedScriptStackSize = trustedScriptStackSize;
else
MOZ_ASSERT(untrustedScriptStackSize < trustedScriptStackSize);
SetNativeStackQuotaAndLimit(rt, StackForSystemCode, systemCodeStackSize);
SetNativeStackQuotaAndLimit(rt, StackForTrustedScript, trustedScriptStackSize);
SetNativeStackQuotaAndLimit(rt, StackForUntrustedScript, untrustedScriptStackSize);
rt->initJitStackLimit();
}
/************************************************************************/
JS_PUBLIC_API(bool)
JS_ValueToId(JSContext* cx, HandleValue value, MutableHandleId idp)
{
AssertHeapIsIdle(cx);
CHECK_REQUEST(cx);
assertSameCompartment(cx, value);
return ValueToId<CanGC>(cx, value, idp);
}
JS_PUBLIC_API(bool)
JS_StringToId(JSContext* cx, HandleString string, MutableHandleId idp)
{
AssertHeapIsIdle(cx);
CHECK_REQUEST(cx);
assertSameCompartment(cx, string);
RootedValue value(cx, StringValue(string));
return ValueToId<CanGC>(cx, value, idp);
}
JS_PUBLIC_API(bool)
JS_IdToValue(JSContext* cx, jsid id, MutableHandleValue vp)
{
AssertHeapIsIdle(cx);
CHECK_REQUEST(cx);
vp.set(IdToValue(id));
assertSameCompartment(cx, vp);
return true;
}
JS_PUBLIC_API(bool)
JS::ToPrimitive(JSContext* cx, HandleObject obj, JSType hint, MutableHandleValue vp)
{
AssertHeapIsIdle(cx);
CHECK_REQUEST(cx);
MOZ_ASSERT(obj != nullptr);
MOZ_ASSERT(hint == JSTYPE_VOID || hint == JSTYPE_STRING || hint == JSTYPE_NUMBER);
vp.setObject(*obj);
return ToPrimitiveSlow(cx, hint, vp);
}
JS_PUBLIC_API(bool)
JS::GetFirstArgumentAsTypeHint(JSContext* cx, CallArgs args, JSType *result)
{
if (!args.get(0).isString()) {
JS_ReportErrorNumber(cx, GetErrorMessage, nullptr, JSMSG_NOT_EXPECTED_TYPE,
"Symbol.toPrimitive",
"\"string\", \"number\", or \"default\"",
InformalValueTypeName(args.get(0)));
return false;
}
RootedString str(cx, args.get(0).toString());
bool match;
if (!EqualStrings(cx, str, cx->names().default_, &match))
return false;
if (match) {
*result = JSTYPE_VOID;
return true;
}
if (!EqualStrings(cx, str, cx->names().string, &match))
return false;
if (match) {
*result = JSTYPE_STRING;
return true;
}
if (!EqualStrings(cx, str, cx->names().number, &match))
return false;
if (match) {
*result = JSTYPE_NUMBER;
return true;
}
JSAutoByteString bytes;
JS_ReportErrorNumber(cx, GetErrorMessage, nullptr, JSMSG_NOT_EXPECTED_TYPE,
"Symbol.toPrimitive",
"\"string\", \"number\", or \"default\"",
ValueToSourceForError(cx, args.get(0), bytes));
return false;
}
JS_PUBLIC_API(bool)
JS_PropertyStub(JSContext* cx, HandleObject obj, HandleId id, MutableHandleValue vp)
{
return true;
}
JS_PUBLIC_API(bool)
JS_StrictPropertyStub(JSContext* cx, HandleObject obj, HandleId id, MutableHandleValue vp,
ObjectOpResult& result)
{
return result.succeed();
}
JS_PUBLIC_API(JSObject*)
JS_InitClass(JSContext* cx, HandleObject obj, HandleObject parent_proto,
const JSClass* clasp, JSNative constructor, unsigned nargs,
const JSPropertySpec* ps, const JSFunctionSpec* fs,
const JSPropertySpec* static_ps, const JSFunctionSpec* static_fs)
{
AssertHeapIsIdle(cx);
CHECK_REQUEST(cx);
assertSameCompartment(cx, obj, parent_proto);
return InitClass(cx, obj, parent_proto, Valueify(clasp), constructor,
nargs, ps, fs, static_ps, static_fs);
}
JS_PUBLIC_API(bool)
JS_LinkConstructorAndPrototype(JSContext* cx, HandleObject ctor, HandleObject proto)
{
return LinkConstructorAndPrototype(cx, ctor, proto);
}
JS_PUBLIC_API(const JSClass*)
JS_GetClass(JSObject* obj)
{
return obj->getJSClass();
}
JS_PUBLIC_API(bool)
JS_InstanceOf(JSContext* cx, HandleObject obj, const JSClass* clasp, CallArgs* args)
{
AssertHeapIsIdle(cx);
CHECK_REQUEST(cx);
#ifdef DEBUG
if (args) {
assertSameCompartment(cx, obj);
assertSameCompartment(cx, args->thisv(), args->calleev());
}
#endif
if (!obj || obj->getJSClass() != clasp) {
if (args)
ReportIncompatibleMethod(cx, *args, Valueify(clasp));
return false;
}
return true;
}
JS_PUBLIC_API(bool)
JS_HasInstance(JSContext* cx, HandleObject obj, HandleValue value, bool* bp)
{
AssertHeapIsIdle(cx);
assertSameCompartment(cx, obj, value);
return HasInstance(cx, obj, value, bp);
}
JS_PUBLIC_API(void*)
JS_GetPrivate(JSObject* obj)
{
/* This function can be called by a finalizer. */
return obj->as<NativeObject>().getPrivate();
}
JS_PUBLIC_API(void)
JS_SetPrivate(JSObject* obj, void* data)
{
/* This function can be called by a finalizer. */
obj->as<NativeObject>().setPrivate(data);
}
JS_PUBLIC_API(void*)
JS_GetInstancePrivate(JSContext* cx, HandleObject obj, const JSClass* clasp, CallArgs* args)
{
if (!JS_InstanceOf(cx, obj, clasp, args))
return nullptr;
return obj->as<NativeObject>().getPrivate();
}
JS_PUBLIC_API(JSObject*)
JS_GetConstructor(JSContext* cx, HandleObject proto)
{
AssertHeapIsIdle(cx);
CHECK_REQUEST(cx);
assertSameCompartment(cx, proto);
RootedValue cval(cx);
if (!GetProperty(cx, proto, proto, cx->names().constructor, &cval))
return nullptr;
if (!IsFunctionObject(cval)) {
JS_ReportErrorNumber(cx, GetErrorMessage, nullptr, JSMSG_NO_CONSTRUCTOR,
proto->getClass()->name);
return nullptr;
}
return &cval.toObject();
}
bool
JS::CompartmentOptions::extraWarnings(JSRuntime* rt) const
{
return extraWarningsOverride_.get(rt->options().extraWarnings());
}
bool
JS::CompartmentOptions::extraWarnings(JSContext* cx) const
{
return extraWarnings(cx->runtime());
}
JS::CompartmentOptions&
JS::CompartmentOptions::setZone(ZoneSpecifier spec)
{
zone_.spec = spec;
return *this;
}
JS::CompartmentOptions&
JS::CompartmentOptions::setSameZoneAs(JSObject* obj)
{
zone_.pointer = static_cast<void*>(obj->zone());
return *this;
}
JS::CompartmentOptions&
JS::CompartmentOptionsRef(JSCompartment* compartment)
{
return compartment->options();
}
JS::CompartmentOptions&
JS::CompartmentOptionsRef(JSObject* obj)
{
return obj->compartment()->options();
}
JS::CompartmentOptions&
JS::CompartmentOptionsRef(JSContext* cx)
{
return cx->compartment()->options();
}
JS_PUBLIC_API(JSObject*)
JS_NewGlobalObject(JSContext* cx, const JSClass* clasp, JSPrincipals* principals,
JS::OnNewGlobalHookOption hookOption,
const JS::CompartmentOptions& options /* = JS::CompartmentOptions() */)
{
AssertHeapIsIdle(cx);
CHECK_REQUEST(cx);
return GlobalObject::new_(cx, Valueify(clasp), principals, hookOption, options);
}
JS_PUBLIC_API(void)
JS_GlobalObjectTraceHook(JSTracer* trc, JSObject* global)
{
MOZ_ASSERT(global->is<GlobalObject>());
// Off thread parsing and compilation tasks create a dummy global which is then
// merged back into the host compartment. Since it used to be a global, it will still
// have this trace hook, but it does not have a meaning relative to its new compartment.
// We can safely skip it.
if (!global->isOwnGlobal())
return;
// Trace the compartment for any GC things that should only stick around if we know the
// compartment is live.
global->compartment()->trace(trc);
JSTraceOp trace = global->compartment()->options().getTrace();
if (trace)
trace(trc, global);
}
JS_PUBLIC_API(void)
JS_FireOnNewGlobalObject(JSContext* cx, JS::HandleObject global)
{
// This hook is infallible, because we don't really want arbitrary script
// to be able to throw errors during delicate global creation routines.
// This infallibility will eat OOM and slow script, but if that happens
// we'll likely run up into them again soon in a fallible context.
Rooted<js::GlobalObject*> globalObject(cx, &global->as<GlobalObject>());
Debugger::onNewGlobalObject(cx, globalObject);
}
JS_PUBLIC_API(JSObject*)
JS_NewObject(JSContext* cx, const JSClass* jsclasp)
{
MOZ_ASSERT(!cx->runtime()->isAtomsCompartment(cx->compartment()));
AssertHeapIsIdle(cx);
CHECK_REQUEST(cx);
const Class* clasp = Valueify(jsclasp);
if (!clasp)
clasp = &PlainObject::class_; /* default class is Object */
MOZ_ASSERT(clasp != &JSFunction::class_);
MOZ_ASSERT(!(clasp->flags & JSCLASS_IS_GLOBAL));
return NewObjectWithClassProto(cx, clasp, nullptr);
}
JS_PUBLIC_API(JSObject*)
JS_NewObjectWithGivenProto(JSContext* cx, const JSClass* jsclasp, HandleObject proto)
{
MOZ_ASSERT(!cx->runtime()->isAtomsCompartment(cx->compartment()));
AssertHeapIsIdle(cx);
CHECK_REQUEST(cx);
assertSameCompartment(cx, proto);
const Class* clasp = Valueify(jsclasp);
if (!clasp)
clasp = &PlainObject::class_; /* default class is Object */
MOZ_ASSERT(clasp != &JSFunction::class_);
MOZ_ASSERT(!(clasp->flags & JSCLASS_IS_GLOBAL));
return NewObjectWithGivenProto(cx, clasp, proto);
}
JS_PUBLIC_API(JSObject*)
JS_NewPlainObject(JSContext* cx)
{
MOZ_ASSERT(!cx->runtime()->isAtomsCompartment(cx->compartment()));
AssertHeapIsIdle(cx);
CHECK_REQUEST(cx);
return NewBuiltinClassInstance<PlainObject>(cx);
}
JS_PUBLIC_API(JSObject*)
JS_NewObjectForConstructor(JSContext* cx, const JSClass* clasp, const CallArgs& args)
{
AssertHeapIsIdle(cx);
CHECK_REQUEST(cx);
Value callee = args.calleev();
assertSameCompartment(cx, callee);
RootedObject obj(cx, &callee.toObject());
return CreateThis(cx, Valueify(clasp), obj);
}
JS_PUBLIC_API(bool)
JS_IsNative(JSObject* obj)
{
return obj->isNative();
}
JS_PUBLIC_API(JSRuntime*)
JS_GetObjectRuntime(JSObject* obj)
{
return obj->compartment()->runtimeFromMainThread();
}
/*** Standard internal methods *******************************************************************/
JS_PUBLIC_API(bool)
JS_GetPrototype(JSContext* cx, HandleObject obj, MutableHandleObject result)
{
return GetPrototype(cx, obj, result);
}
JS_PUBLIC_API(bool)
JS_SetPrototype(JSContext* cx, HandleObject obj, HandleObject proto)
{
AssertHeapIsIdle(cx);
CHECK_REQUEST(cx);
assertSameCompartment(cx, obj, proto);
return SetPrototype(cx, obj, proto);
}
JS_PUBLIC_API(bool)
JS_IsExtensible(JSContext* cx, HandleObject obj, bool* extensible)
{
return IsExtensible(cx, obj, extensible);
}
JS_PUBLIC_API(bool)
JS_PreventExtensions(JSContext* cx, JS::HandleObject obj, ObjectOpResult& result)
{
return PreventExtensions(cx, obj, result);
}
JS_PUBLIC_API(bool)
JS_SetImmutablePrototype(JSContext *cx, JS::HandleObject obj, bool *succeeded)
{
return SetImmutablePrototype(cx, obj, succeeded);
}
JS_PUBLIC_API(bool)
JS_GetOwnPropertyDescriptorById(JSContext* cx, HandleObject obj, HandleId id,
MutableHandle<JSPropertyDescriptor> desc)
{
AssertHeapIsIdle(cx);
CHECK_REQUEST(cx);
return GetOwnPropertyDescriptor(cx, obj, id, desc);
}
JS_PUBLIC_API(bool)
JS_GetOwnPropertyDescriptor(JSContext* cx, HandleObject obj, const char* name,
MutableHandle<JSPropertyDescriptor> desc)
{
JSAtom* atom = Atomize(cx, name, strlen(name));
if (!atom)
return false;
RootedId id(cx, AtomToId(atom));
return JS_GetOwnPropertyDescriptorById(cx, obj, id, desc);
}
JS_PUBLIC_API(bool)
JS_GetOwnUCPropertyDescriptor(JSContext* cx, HandleObject obj, const char16_t* name,
MutableHandle<JSPropertyDescriptor> desc)
{
JSAtom* atom = AtomizeChars(cx, name, js_strlen(name));
if (!atom)
return false;
RootedId id(cx, AtomToId(atom));
return JS_GetOwnPropertyDescriptorById(cx, obj, id, desc);
}
JS_PUBLIC_API(bool)
JS_GetPropertyDescriptorById(JSContext* cx, HandleObject obj, HandleId id,
MutableHandle<JSPropertyDescriptor> desc)
{
return GetPropertyDescriptor(cx, obj, id, desc);
}
JS_PUBLIC_API(bool)
JS_GetPropertyDescriptor(JSContext* cx, HandleObject obj, const char* name,
MutableHandle<JSPropertyDescriptor> desc)
{
JSAtom* atom = Atomize(cx, name, strlen(name));
if (!atom)
return false;
RootedId id(cx, AtomToId(atom));
return atom && JS_GetPropertyDescriptorById(cx, obj, id, desc);
}
static bool
DefinePropertyByDescriptor(JSContext* cx, HandleObject obj, HandleId id,
Handle<JSPropertyDescriptor> desc, ObjectOpResult& result)
{
AssertHeapIsIdle(cx);
CHECK_REQUEST(cx);
assertSameCompartment(cx, obj, id, desc);
return DefineProperty(cx, obj, id, desc.value(), desc.getter(), desc.setter(),
desc.attributes(), result);
}
JS_PUBLIC_API(bool)
JS_DefinePropertyById(JSContext* cx, HandleObject obj, HandleId id,
Handle<JSPropertyDescriptor> desc, ObjectOpResult& result)
{
return DefinePropertyByDescriptor(cx, obj, id, desc, result);
}
JS_PUBLIC_API(bool)
JS_DefinePropertyById(JSContext* cx, HandleObject obj, HandleId id,
Handle<JSPropertyDescriptor> desc)
{
ObjectOpResult result;
return DefinePropertyByDescriptor(cx, obj, id, desc, result) &&
result.checkStrict(cx, obj, id);
}
static bool
DefinePropertyById(JSContext* cx, HandleObject obj, HandleId id, HandleValue value,
const JSNativeWrapper& get, const JSNativeWrapper& set,
unsigned attrs, unsigned flags)
{
JSGetterOp getter = JS_CAST_NATIVE_TO(get.op, JSGetterOp);
JSSetterOp setter = JS_CAST_NATIVE_TO(set.op, JSSetterOp);
// JSPROP_READONLY has no meaning when accessors are involved. Ideally we'd
// throw if this happens, but we've accepted it for long enough that it's
// not worth trying to make callers change their ways. Just flip it off on
// its way through the API layer so that we can enforce this internally.
if (attrs & (JSPROP_GETTER | JSPROP_SETTER))
attrs &= ~JSPROP_READONLY;
// When we use DefineProperty, we need full scriptable Function objects rather
// than JSNatives. However, we might be pulling this property descriptor off
// of something with JSNative property descriptors. If we are, wrap them in
// JS Function objects.
//
// But skip doing this if our accessors are the well-known stub
// accessors, since those are known to be JSGetterOps. Assert
// some sanity about it, though.
MOZ_ASSERT_IF(getter == JS_PropertyStub,
setter == JS_StrictPropertyStub || (attrs & JSPROP_PROPOP_ACCESSORS));
MOZ_ASSERT_IF(setter == JS_StrictPropertyStub,
getter == JS_PropertyStub || (attrs & JSPROP_PROPOP_ACCESSORS));
// If !(attrs & JSPROP_PROPOP_ACCESSORS), then either getter/setter are both
// possibly-null JSNatives (or possibly-null JSFunction* if JSPROP_GETTER or
// JSPROP_SETTER is appropriately set), or both are the well-known property
// stubs. The subsequent block must handle only the first of these cases,
// so carefully exclude the latter case.
if (!(attrs & JSPROP_PROPOP_ACCESSORS) &&
getter != JS_PropertyStub && setter != JS_StrictPropertyStub)
{
RootedAtom atom(cx, JSID_IS_ATOM(id) ? JSID_TO_ATOM(id) : nullptr);
if (getter && !(attrs & JSPROP_GETTER)) {
JSFunction* getobj = NewNativeFunction(cx, (Native) getter, 0, atom);
if (!getobj)
return false;
if (get.info)
getobj->setJitInfo(get.info);
getter = JS_DATA_TO_FUNC_PTR(GetterOp, getobj);
attrs |= JSPROP_GETTER;
}
if (setter && !(attrs & JSPROP_SETTER)) {
// Root just the getter, since the setter is not yet a JSObject.
AutoRooterGetterSetter getRoot(cx, JSPROP_GETTER, &getter, nullptr);
JSFunction* setobj = NewNativeFunction(cx, (Native) setter, 1, atom);
if (!setobj)
return false;
if (set.info)
setobj->setJitInfo(set.info);
setter = JS_DATA_TO_FUNC_PTR(SetterOp, setobj);
attrs |= JSPROP_SETTER;
}
} else {
attrs &= ~JSPROP_PROPOP_ACCESSORS;
}
AssertHeapIsIdle(cx);
CHECK_REQUEST(cx);
assertSameCompartment(cx, obj, id, value,
(attrs & JSPROP_GETTER)
? JS_FUNC_TO_DATA_PTR(JSObject*, getter)
: nullptr,
(attrs & JSPROP_SETTER)
? JS_FUNC_TO_DATA_PTR(JSObject*, setter)
: nullptr);
// In most places throughout the engine, a property with null getter and
// not JSPROP_GETTER/SETTER/SHARED has no getter, and the same for setters:
// it's just a plain old data property. However the JS_Define* APIs use
// null getter and setter to mean "default to the Class getProperty and
// setProperty ops".
if (!(attrs & (JSPROP_GETTER | JSPROP_SETTER))) {
if (!getter)
getter = obj->getClass()->getProperty;
if (!setter)
setter = obj->getClass()->setProperty;
}
if (getter == JS_PropertyStub)
getter = nullptr;
if (setter == JS_StrictPropertyStub)
setter = nullptr;
return DefineProperty(cx, obj, id, value, getter, setter, attrs);
}
/*
* Wrapper functions to create wrappers with no corresponding JSJitInfo from API
* function arguments.
*/
static JSNativeWrapper
NativeOpWrapper(Native native)
{
JSNativeWrapper ret;
ret.op = native;
ret.info = nullptr;
return ret;
}
JS_PUBLIC_API(bool)
JS_DefinePropertyById(JSContext* cx, HandleObject obj, HandleId id, HandleValue value,
unsigned attrs, Native getter, Native setter)
{
return DefinePropertyById(cx, obj, id, value,
NativeOpWrapper(getter), NativeOpWrapper(setter),
attrs, 0);
}
JS_PUBLIC_API(bool)
JS_DefinePropertyById(JSContext* cx, HandleObject obj, HandleId id, HandleObject valueArg,
unsigned attrs, Native getter, Native setter)
{
RootedValue value(cx, ObjectValue(*valueArg));
return DefinePropertyById(cx, obj, id, value,
NativeOpWrapper(getter), NativeOpWrapper(setter),
attrs, 0);
}
JS_PUBLIC_API(bool)
JS_DefinePropertyById(JSContext* cx, HandleObject obj, HandleId id, HandleString valueArg,
unsigned attrs, Native getter, Native setter)
{
RootedValue value(cx, StringValue(valueArg));
return DefinePropertyById(cx, obj, id, value,
NativeOpWrapper(getter), NativeOpWrapper(setter),
attrs, 0);
}
JS_PUBLIC_API(bool)
JS_DefinePropertyById(JSContext* cx, HandleObject obj, HandleId id, int32_t valueArg,
unsigned attrs, Native getter, Native setter)
{
Value value = Int32Value(valueArg);
return DefinePropertyById(cx, obj, id, HandleValue::fromMarkedLocation(&value),
NativeOpWrapper(getter), NativeOpWrapper(setter), attrs, 0);
}
JS_PUBLIC_API(bool)
JS_DefinePropertyById(JSContext* cx, HandleObject obj, HandleId id, uint32_t valueArg,
unsigned attrs, Native getter, Native setter)
{
Value value = NumberValue(valueArg);
return DefinePropertyById(cx, obj, id, HandleValue::fromMarkedLocation(&value),
NativeOpWrapper(getter), NativeOpWrapper(setter), attrs, 0);
}
JS_PUBLIC_API(bool)
JS_DefinePropertyById(JSContext* cx, HandleObject obj, HandleId id, double valueArg,
unsigned attrs, Native getter, Native setter)
{
Value value = NumberValue(valueArg);
return DefinePropertyById(cx, obj, id, HandleValue::fromMarkedLocation(&value),
NativeOpWrapper(getter), NativeOpWrapper(setter), attrs, 0);
}
static bool
DefineProperty(JSContext* cx, HandleObject obj, const char* name, HandleValue value,
const JSNativeWrapper& getter, const JSNativeWrapper& setter,
unsigned attrs, unsigned flags)
{
AutoRooterGetterSetter gsRoot(cx, attrs, const_cast<JSNative*>(&getter.op),
const_cast<JSNative*>(&setter.op));
JSAtom* atom = Atomize(cx, name, strlen(name));
if (!atom)
return false;
RootedId id(cx, AtomToId(atom));
return DefinePropertyById(cx, obj, id, value, getter, setter, attrs, flags);
}
JS_PUBLIC_API(bool)
JS_DefineProperty(JSContext* cx, HandleObject obj, const char* name, HandleValue value,
unsigned attrs,
Native getter /* = nullptr */, Native setter /* = nullptr */)
{
return DefineProperty(cx, obj, name, value, NativeOpWrapper(getter), NativeOpWrapper(setter),
attrs, 0);
}
JS_PUBLIC_API(bool)
JS_DefineProperty(JSContext* cx, HandleObject obj, const char* name, HandleObject valueArg,
unsigned attrs,
Native getter /* = nullptr */, Native setter /* = nullptr */)
{
RootedValue value(cx, ObjectValue(*valueArg));
return DefineProperty(cx, obj, name, value, NativeOpWrapper(getter), NativeOpWrapper(setter),
attrs, 0);
}
JS_PUBLIC_API(bool)
JS_DefineProperty(JSContext* cx, HandleObject obj, const char* name, HandleString valueArg,
unsigned attrs,
Native getter /* = nullptr */, Native setter /* = nullptr */)
{
RootedValue value(cx, StringValue(valueArg));
return DefineProperty(cx, obj, name, value, NativeOpWrapper(getter), NativeOpWrapper(setter),
attrs, 0);
}
JS_PUBLIC_API(bool)
JS_DefineProperty(JSContext* cx, HandleObject obj, const char* name, int32_t valueArg,
unsigned attrs,
Native getter /* = nullptr */, Native setter /* = nullptr */)
{
Value value = Int32Value(valueArg);
return DefineProperty(cx, obj, name, HandleValue::fromMarkedLocation(&value),
NativeOpWrapper(getter), NativeOpWrapper(setter), attrs, 0);
}
JS_PUBLIC_API(bool)
JS_DefineProperty(JSContext* cx, HandleObject obj, const char* name, uint32_t valueArg,
unsigned attrs,
Native getter /* = nullptr */, Native setter /* = nullptr */)
{
Value value = NumberValue(valueArg);
return DefineProperty(cx, obj, name, HandleValue::fromMarkedLocation(&value),
NativeOpWrapper(getter), NativeOpWrapper(setter), attrs, 0);
}
JS_PUBLIC_API(bool)
JS_DefineProperty(JSContext* cx, HandleObject obj, const char* name, double valueArg,
unsigned attrs,
Native getter /* = nullptr */, Native setter /* = nullptr */)
{
Value value = NumberValue(valueArg);
return DefineProperty(cx, obj, name, HandleValue::fromMarkedLocation(&value),
NativeOpWrapper(getter), NativeOpWrapper(setter), attrs, 0);
}
#define AUTO_NAMELEN(s,n) (((n) == (size_t)-1) ? js_strlen(s) : (n))
JS_PUBLIC_API(bool)
JS_DefineUCProperty(JSContext* cx, HandleObject obj, const char16_t* name, size_t namelen,
Handle<JSPropertyDescriptor> desc,
ObjectOpResult& result)
{
JSAtom* atom = AtomizeChars(cx, name, AUTO_NAMELEN(name, namelen));
if (!atom)
return false;
RootedId id(cx, AtomToId(atom));
return DefinePropertyByDescriptor(cx, obj, id, desc, result);
}
JS_PUBLIC_API(bool)
JS_DefineUCProperty(JSContext* cx, HandleObject obj, const char16_t* name, size_t namelen,
Handle<JSPropertyDescriptor> desc)
{
JSAtom* atom = AtomizeChars(cx, name, AUTO_NAMELEN(name, namelen));
if (!atom)
return false;
RootedId id(cx, AtomToId(atom));
ObjectOpResult result;
return DefinePropertyByDescriptor(cx, obj, id, desc, result) &&
result.checkStrict(cx, obj, id);
}
static bool
DefineUCProperty(JSContext* cx, HandleObject obj, const char16_t* name, size_t namelen,
const Value& value_, Native getter, Native setter, unsigned attrs,
unsigned flags)
{
RootedValue value(cx, value_);
AutoRooterGetterSetter gsRoot(cx, attrs, &getter, &setter);
JSAtom* atom = AtomizeChars(cx, name, AUTO_NAMELEN(name, namelen));
if (!atom)
return false;
RootedId id(cx, AtomToId(atom));
return DefinePropertyById(cx, obj, id, value, NativeOpWrapper(getter), NativeOpWrapper(setter),
attrs, flags);
}
JS_PUBLIC_API(bool)
JS_DefineUCProperty(JSContext* cx, HandleObject obj, const char16_t* name, size_t namelen,
HandleValue value, unsigned attrs, Native getter, Native setter)
{
return DefineUCProperty(cx, obj, name, namelen, value, getter, setter, attrs, 0);
}
JS_PUBLIC_API(bool)
JS_DefineUCProperty(JSContext* cx, HandleObject obj, const char16_t* name, size_t namelen,
HandleObject valueArg, unsigned attrs, Native getter, Native setter)
{
RootedValue value(cx, ObjectValue(*valueArg));
return DefineUCProperty(cx, obj, name, namelen, value, getter, setter, attrs, 0);
}
JS_PUBLIC_API(bool)
JS_DefineUCProperty(JSContext* cx, HandleObject obj, const char16_t* name, size_t namelen,
HandleString valueArg, unsigned attrs, Native getter, Native setter)
{
RootedValue value(cx, StringValue(valueArg));
return DefineUCProperty(cx, obj, name, namelen, value, getter, setter, attrs, 0);
}
JS_PUBLIC_API(bool)
JS_DefineUCProperty(JSContext* cx, HandleObject obj, const char16_t* name, size_t namelen,
int32_t valueArg, unsigned attrs, Native getter, Native setter)
{
Value value = Int32Value(valueArg);
return DefineUCProperty(cx, obj, name, namelen, HandleValue::fromMarkedLocation(&value),
getter, setter, attrs, 0);
}
JS_PUBLIC_API(bool)
JS_DefineUCProperty(JSContext* cx, HandleObject obj, const char16_t* name, size_t namelen,
uint32_t valueArg, unsigned attrs, Native getter, Native setter)
{
Value value = NumberValue(valueArg);
return DefineUCProperty(cx, obj, name, namelen, HandleValue::fromMarkedLocation(&value),
getter, setter, attrs, 0);
}
JS_PUBLIC_API(bool)
JS_DefineUCProperty(JSContext* cx, HandleObject obj, const char16_t* name, size_t namelen,
double valueArg, unsigned attrs, Native getter, Native setter)
{
Value value = NumberValue(valueArg);
return DefineUCProperty(cx, obj, name, namelen, HandleValue::fromMarkedLocation(&value),
getter, setter, attrs, 0);
}
static bool
DefineElement(JSContext* cx, HandleObject obj, uint32_t index, HandleValue value,
unsigned attrs, Native getter, Native setter)
{
AutoRooterGetterSetter gsRoot(cx, attrs, &getter, &setter);
AssertHeapIsIdle(cx);
CHECK_REQUEST(cx);
RootedId id(cx);
if (!IndexToId(cx, index, &id))
return false;
return DefinePropertyById(cx, obj, id, value,
NativeOpWrapper(getter), NativeOpWrapper(setter),
attrs, 0);
}
JS_PUBLIC_API(bool)
JS_DefineElement(JSContext* cx, HandleObject obj, uint32_t index, HandleValue value,
unsigned attrs, Native getter, Native setter)
{
return DefineElement(cx, obj, index, value, attrs, getter, setter);
}
JS_PUBLIC_API(bool)
JS_DefineElement(JSContext* cx, HandleObject obj, uint32_t index, HandleObject valueArg,
unsigned attrs, Native getter, Native setter)
{
RootedValue value(cx, ObjectValue(*valueArg));
return DefineElement(cx, obj, index, value, attrs, getter, setter);
}
JS_PUBLIC_API(bool)
JS_DefineElement(JSContext* cx, HandleObject obj, uint32_t index, HandleString valueArg,
unsigned attrs, Native getter, Native setter)
{
RootedValue value(cx, StringValue(valueArg));
return DefineElement(cx, obj, index, value, attrs, getter, setter);
}
JS_PUBLIC_API(bool)
JS_DefineElement(JSContext* cx, HandleObject obj, uint32_t index, int32_t valueArg,
unsigned attrs, Native getter, Native setter)
{
Value value = Int32Value(valueArg);
return DefineElement(cx, obj, index, HandleValue::fromMarkedLocation(&value),
attrs, getter, setter);
}
JS_PUBLIC_API(bool)
JS_DefineElement(JSContext* cx, HandleObject obj, uint32_t index, uint32_t valueArg,
unsigned attrs, Native getter, Native setter)
{
Value value = NumberValue(valueArg);
return DefineElement(cx, obj, index, HandleValue::fromMarkedLocation(&value),
attrs, getter, setter);
}
JS_PUBLIC_API(bool)
JS_DefineElement(JSContext* cx, HandleObject obj, uint32_t index, double valueArg,
unsigned attrs, Native getter, Native setter)
{
Value value = NumberValue(valueArg);
return DefineElement(cx, obj, index, HandleValue::fromMarkedLocation(&value),
attrs, getter, setter);
}
JS_PUBLIC_API(bool)
JS_HasPropertyById(JSContext* cx, HandleObject obj, HandleId id, bool* foundp)
{
AssertHeapIsIdle(cx);
CHECK_REQUEST(cx);
return HasProperty(cx, obj, id, foundp);
}
JS_PUBLIC_API(bool)
JS_HasProperty(JSContext* cx, HandleObject obj, const char* name, bool* foundp)
{
JSAtom* atom = Atomize(cx, name, strlen(name));
if (!atom)
return false;
RootedId id(cx, AtomToId(atom));
return JS_HasPropertyById(cx, obj, id, foundp);
}
JS_PUBLIC_API(bool)
JS_HasUCProperty(JSContext* cx, HandleObject obj, const char16_t* name, size_t namelen, bool* foundp)
{
JSAtom* atom = AtomizeChars(cx, name, AUTO_NAMELEN(name, namelen));
if (!atom)
return false;
RootedId id(cx, AtomToId(atom));
return JS_HasPropertyById(cx, obj, id, foundp);
}
JS_PUBLIC_API(bool)
JS_HasElement(JSContext* cx, HandleObject obj, uint32_t index, bool* foundp)
{
AssertHeapIsIdle(cx);
CHECK_REQUEST(cx);
RootedId id(cx);
if (!IndexToId(cx, index, &id))
return false;
return JS_HasPropertyById(cx, obj, id, foundp);
}
JS_PUBLIC_API(bool)
JS_HasOwnPropertyById(JSContext* cx, HandleObject obj, HandleId id, bool* foundp)
{
AssertHeapIsIdle(cx);
CHECK_REQUEST(cx);
assertSameCompartment(cx, obj, id);
return HasOwnProperty(cx, obj, id, foundp);
}
JS_PUBLIC_API(bool)
JS_HasOwnProperty(JSContext* cx, HandleObject obj, const char* name, bool* foundp)
{
JSAtom* atom = Atomize(cx, name, strlen(name));
if (!atom)
return false;
RootedId id(cx, AtomToId(atom));
return JS_HasOwnPropertyById(cx, obj, id, foundp);
}
JS_PUBLIC_API(bool)
JS_ForwardGetPropertyTo(JSContext* cx, HandleObject obj, HandleId id, HandleValue receiver,
MutableHandleValue vp)
{
AssertHeapIsIdle(cx);
CHECK_REQUEST(cx);
assertSameCompartment(cx, obj, id, receiver);
return GetProperty(cx, obj, receiver, id, vp);
}
JS_PUBLIC_API(bool)
JS_ForwardGetElementTo(JSContext* cx, HandleObject obj, uint32_t index, HandleObject receiver,
MutableHandleValue vp)
{
AssertHeapIsIdle(cx);
CHECK_REQUEST(cx);
assertSameCompartment(cx, obj);
return GetElement(cx, obj, receiver, index, vp);
}
JS_PUBLIC_API(bool)
JS_GetPropertyById(JSContext* cx, HandleObject obj, HandleId id, MutableHandleValue vp)
{
RootedValue receiver(cx, ObjectValue(*obj));
return JS_ForwardGetPropertyTo(cx, obj, id, receiver, vp);
}
JS_PUBLIC_API(bool)
JS_GetProperty(JSContext* cx, HandleObject obj, const char* name, MutableHandleValue vp)
{
JSAtom* atom = Atomize(cx, name, strlen(name));
if (!atom)
return false;
RootedId id(cx, AtomToId(atom));
return JS_GetPropertyById(cx, obj, id, vp);
}
JS_PUBLIC_API(bool)
JS_GetUCProperty(JSContext* cx, HandleObject obj, const char16_t* name, size_t namelen,
MutableHandleValue vp)
{
JSAtom* atom = AtomizeChars(cx, name, AUTO_NAMELEN(name, namelen));
if (!atom)
return false;
RootedId id(cx, AtomToId(atom));
return JS_GetPropertyById(cx, obj, id, vp);
}
JS_PUBLIC_API(bool)
JS_GetElement(JSContext* cx, HandleObject objArg, uint32_t index, MutableHandleValue vp)
{
return JS_ForwardGetElementTo(cx, objArg, index, objArg, vp);
}
JS_PUBLIC_API(bool)
JS_ForwardSetPropertyTo(JSContext* cx, HandleObject obj, HandleId id, HandleValue v,
HandleValue receiver, ObjectOpResult& result)
{
AssertHeapIsIdle(cx);
CHECK_REQUEST(cx);
assertSameCompartment(cx, obj, id, receiver);
return SetProperty(cx, obj, id, v, receiver, result);
}
JS_PUBLIC_API(bool)
JS_SetPropertyById(JSContext* cx, HandleObject obj, HandleId id, HandleValue v)
{
AssertHeapIsIdle(cx);
CHECK_REQUEST(cx);
assertSameCompartment(cx, obj, id);
RootedValue receiver(cx, ObjectValue(*obj));
ObjectOpResult ignored;
return SetProperty(cx, obj, id, v, receiver, ignored);
}
JS_PUBLIC_API(bool)
JS_SetProperty(JSContext* cx, HandleObject obj, const char* name, HandleValue v)
{
JSAtom* atom = Atomize(cx, name, strlen(name));
if (!atom)
return false;
RootedId id(cx, AtomToId(atom));
return JS_SetPropertyById(cx, obj, id, v);
}
JS_PUBLIC_API(bool)
JS_SetUCProperty(JSContext* cx, HandleObject obj, const char16_t* name, size_t namelen,
HandleValue v)
{
JSAtom* atom = AtomizeChars(cx, name, AUTO_NAMELEN(name, namelen));
if (!atom)
return false;
RootedId id(cx, AtomToId(atom));
return JS_SetPropertyById(cx, obj, id, v);
}
static bool
SetElement(JSContext* cx, HandleObject obj, uint32_t index, HandleValue v)
{
AssertHeapIsIdle(cx);
CHECK_REQUEST(cx);
assertSameCompartment(cx, obj, v);
RootedValue receiver(cx, ObjectValue(*obj));
ObjectOpResult ignored;
return SetElement(cx, obj, index, v, receiver, ignored);
}
JS_PUBLIC_API(bool)
JS_SetElement(JSContext* cx, HandleObject obj, uint32_t index, HandleValue v)
{
return SetElement(cx, obj, index, v);
}
JS_PUBLIC_API(bool)
JS_SetElement(JSContext* cx, HandleObject obj, uint32_t index, HandleObject v)
{
RootedValue value(cx, ObjectOrNullValue(v));
return SetElement(cx, obj, index, value);
}
JS_PUBLIC_API(bool)
JS_SetElement(JSContext* cx, HandleObject obj, uint32_t index, HandleString v)
{
RootedValue value(cx, StringValue(v));
return SetElement(cx, obj, index, value);
}
JS_PUBLIC_API(bool)
JS_SetElement(JSContext* cx, HandleObject obj, uint32_t index, int32_t v)
{
RootedValue value(cx, NumberValue(v));
return SetElement(cx, obj, index, value);
}
JS_PUBLIC_API(bool)
JS_SetElement(JSContext* cx, HandleObject obj, uint32_t index, uint32_t v)
{
RootedValue value(cx, NumberValue(v));
return SetElement(cx, obj, index, value);
}
JS_PUBLIC_API(bool)
JS_SetElement(JSContext* cx, HandleObject obj, uint32_t index, double v)
{
RootedValue value(cx, NumberValue(v));
return SetElement(cx, obj, index, value);
}
JS_PUBLIC_API(bool)
JS_DeletePropertyById(JSContext* cx, HandleObject obj, HandleId id, ObjectOpResult& result)
{
AssertHeapIsIdle(cx);
CHECK_REQUEST(cx);
assertSameCompartment(cx, obj, id);
return DeleteProperty(cx, obj, id, result);
}
JS_PUBLIC_API(bool)
JS_DeleteProperty(JSContext* cx, HandleObject obj, const char* name, ObjectOpResult& result)
{
CHECK_REQUEST(cx);
assertSameCompartment(cx, obj);
JSAtom* atom = Atomize(cx, name, strlen(name));
if (!atom)
return false;
RootedId id(cx, AtomToId(atom));
return DeleteProperty(cx, obj, id, result);
}
JS_PUBLIC_API(bool)
JS_DeleteUCProperty(JSContext* cx, HandleObject obj, const char16_t* name, size_t namelen