/* -*- 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/Maybe.h" #include "mozilla/PodOperations.h" #include "mozilla/Sprintf.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 "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 "jsweakmap.h" #include "jswrapper.h" #include "builtin/AtomicsObject.h" #include "builtin/Eval.h" #include "builtin/Intl.h" #include "builtin/MapObject.h" #include "builtin/Promise.h" #include "builtin/RegExp.h" #include "builtin/SymbolObject.h" #ifdef ENABLE_SIMD # include "builtin/SIMD.h" #endif #ifdef ENABLE_BINARYDATA # 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 "gc/Policy.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 "js/Utility.h" #include "vm/AsyncFunction.h" #include "vm/DateObject.h" #include "vm/Debugger.h" #include "vm/EnvironmentObject.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/SelfHosting.h" #include "vm/Shape.h" #include "vm/StopIterationObject.h" #include "vm/String.h" #include "vm/StringBuffer.h" #include "vm/Symbol.h" #include "vm/TypedArrayCommon.h" #include "vm/WrapperObject.h" #include "vm/Xdr.h" #include "wasm/AsmJS.h" #include "wasm/WasmModule.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::Some; using JS::AutoGCRooter; using JS::ToInt32; using JS::ToInteger; using JS::ToUint32; #ifdef HAVE_VA_LIST_AS_ARRAY #define JS_ADDRESSOF_VA_LIST(ap) ((va_list*)(ap)) #else #define JS_ADDRESSOF_VA_LIST(ap) (&(ap)) #endif JS_PUBLIC_API(bool) JS::CallArgs::requireAtLeast(JSContext* cx, const char* fnname, unsigned required) const { if (length() < required) { char numArgsStr[40]; SprintfLiteral(numArgsStr, "%u", required - 1); JS_ReportErrorNumberASCII(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; if (!propName.encodeUtf8(cx, str)) return false; if (ErrorTakesObjectArgument(code_)) { return JS_ReportErrorFlagsAndNumberUTF8(cx, flags, GetErrorMessage, nullptr, code_, obj->getClass()->name, propName.ptr()); } return JS_ReportErrorFlagsAndNumberUTF8(cx, flags, GetErrorMessage, nullptr, code_, propName.ptr()); } return JS_ReportErrorFlagsAndNumberASCII(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_ReportErrorFlagsAndNumberASCII(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(JSContext* cx) { MOZ_ASSERT(cx->emptyString()); return cx->emptyString(); } namespace js { void AssertHeapIsIdle(JSRuntime* rt) { MOZ_ASSERT(!rt->isHeapBusy()); } } // namespace js static void AssertHeapIsIdleOrIterating(JSRuntime* rt) { MOZ_ASSERT(!rt->isHeapCollecting()); } 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(); } JS_PUBLIC_API(bool) JS_IsFunctionBound(JSFunction* fun) { return fun->isBoundFunction(); } JS_PUBLIC_API(JSObject*) JS_GetBoundFunctionTarget(JSFunction* fun) { return fun->isBoundFunction() ? fun->getBoundFunctionTarget() : nullptr; } /************************************************************************/ #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(JSContext*) JS_NewContext(uint32_t maxbytes, uint32_t maxNurseryBytes, JSContext* parentContext) { MOZ_ASSERT(JS::detail::libraryInitState == JS::detail::InitState::Running, "must call JS_Init prior to creating any JSContexts"); // Make sure that all parent runtimes are the topmost parent. JSRuntime* parentRuntime = nullptr; if (parentContext) { parentRuntime = parentContext->runtime(); while (parentRuntime && parentRuntime->parentRuntime) parentRuntime = parentRuntime->parentRuntime; } return NewContext(maxbytes, maxNurseryBytes, parentRuntime); } JS_PUBLIC_API(void) JS_DestroyContext(JSContext* cx) { DestroyContext(cx); } 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_GetContextPrivate(JSContext* cx) { return cx->data; } JS_PUBLIC_API(void) JS_SetContextPrivate(JSContext* cx, void* data) { cx->data = data; } JS_PUBLIC_API(void) JS_SetFutexCanWait(JSContext* cx) { cx->fx.setCanWait(true); } 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(JSContext*) JS_GetParentContext(JSContext* cx) { return cx->parentRuntime ? cx->parentRuntime->unsafeContextFromAnyThread() : cx; } JS_PUBLIC_API(JSVersion) JS_GetVersion(JSContext* cx) { return VersionNumber(cx->findVersion()); } JS_PUBLIC_API(void) JS_SetVersionForCompartment(JSCompartment* compartment, JSVersion version) { compartment->behaviors().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::ContextOptions&) JS::ContextOptionsRef(JSContext* cx) { return cx->options(); } JS_PUBLIC_API(bool) JS::InitSelfHostedCode(JSContext* cx) { MOZ_RELEASE_ASSERT(!cx->runtime()->hasInitializedSelfHosting(), "JS::InitSelfHostedCode() called more than once"); JSRuntime* rt = cx->runtime(); JSAutoRequest ar(cx); if (!rt->initializeAtoms(cx)) return false; if (!cx->cycleDetectorSet.init()) return false; if (!rt->initSelfHosting(cx)) return false; if (!rt->parentRuntime && !rt->transformToPermanentAtoms(cx)) return false; return true; } JS_PUBLIC_API(const char*) JS_GetImplementationVersion(void) { return "JavaScript-C" MOZILLA_VERSION; } JS_PUBLIC_API(void) JS_SetDestroyCompartmentCallback(JSContext* cx, JSDestroyCompartmentCallback callback) { cx->destroyCompartmentCallback = callback; } JS_PUBLIC_API(void) JS_SetSizeOfIncludingThisCompartmentCallback(JSContext* cx, JSSizeOfIncludingThisCompartmentCallback callback) { cx->sizeOfIncludingThisCompartmentCallback = callback; } JS_PUBLIC_API(void) JS_SetDestroyZoneCallback(JSContext* cx, JSZoneCallback callback) { cx->destroyZoneCallback = callback; } JS_PUBLIC_API(void) JS_SetSweepZoneCallback(JSContext* cx, JSZoneCallback callback) { cx->sweepZoneCallback = callback; } JS_PUBLIC_API(void) JS_SetCompartmentNameCallback(JSContext* cx, JSCompartmentNameCallback callback) { cx->compartmentNameCallback = callback; } JS_PUBLIC_API(void) JS_SetWrapObjectCallbacks(JSContext* cx, const JSWrapObjectCallbacks* callbacks) { cx->wrapObjectCallbacks = callbacks; } JS_PUBLIC_API(JSCompartment*) JS_EnterCompartment(JSContext* cx, JSObject* target) { AssertHeapIsIdle(cx); CHECK_REQUEST(cx); MOZ_ASSERT(!JS::ObjectIsMarkedGray(target)); 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; MOZ_ASSERT(!JS::ObjectIsMarkedGray(target)); 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; MOZ_ASSERT(!JS::ScriptIsMarkedGray(target)); 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) { MOZ_ASSERT(!JS::ObjectIsMarkedGray(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()->creationOptions().addonIdOrNull(); } 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); // Don't allow a compacting GC to observe any intermediate state. AutoDisableCompactingGC nocgc(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. Nuke 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(); if (!origobj->compartment()->putWrapper(cx, CrossCompartmentKey(newIdentity), origv)) MOZ_CRASH(); } // 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 { 0, JSProto_LIMIT } }; #undef EAGER_ATOM JS_PUBLIC_API(bool) JS_ResolveStandardClass(JSContext* cx, HandleObject obj, HandleId id, bool* resolved) { const JSStdName* stdnm; AssertHeapIsIdle(cx); CHECK_REQUEST(cx); assertSameCompartment(cx, obj, id); Handle<GlobalObject*> global = obj.as<GlobalObject>(); *resolved = false; if (!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 (stdnm && GlobalObject::skipDeselectedConstructor(cx, stdnm->key)) stdnm = nullptr; // 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. return GlobalObject::getOrCreateObjectPrototype(cx, global); } 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->staticPrototype()) return true; if (!JSID_IS_ATOM(id)) return false; JSAtom* atom = JSID_TO_ATOM(id); // This will return true even for deselected constructors. (To do // better, we need a JSContext here; it's fine as it is.) 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); Handle<GlobalObject*> global = 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; if (GlobalObject::skipDeselectedConstructor(cx, stdnm->key)) 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); Rooted<GlobalObject*> global(cx, &forObj->global()); return GlobalObject::getOrCreateObjectPrototype(cx, global); } JS_PUBLIC_API(JSObject*) JS_GetFunctionPrototype(JSContext* cx, HandleObject forObj) { CHECK_REQUEST(cx); assertSameCompartment(cx, forObj); Rooted<GlobalObject*> global(cx, &forObj->global()); return GlobalObject::getOrCreateFunctionPrototype(cx, global); } 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_GlobalLexicalEnvironment(JSObject* obj) { return &obj->as<GlobalObject>().lexicalEnvironment(); } extern JS_PUBLIC_API(bool) JS_HasExtensibleLexicalEnvironment(JSObject* obj) { return obj->is<GlobalObject>() || obj->compartment()->getNonSyntacticLexicalEnvironment(obj); } extern JS_PUBLIC_API(JSObject*) JS_ExtensibleLexicalEnvironment(JSObject* obj) { JSObject* lexical = nullptr; if (obj->is<GlobalObject>()) lexical = JS_GlobalLexicalEnvironment(obj); else lexical = obj->compartment()->getNonSyntacticLexicalEnvironment(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::detail::ComputeThis(JSContext* cx, Value* vp) { AssertHeapIsIdle(cx); assertSameCompartment(cx, JSValueArray(vp, 2)); MutableHandleValue thisv = MutableHandleValue::fromMarkedLocation(&vp[1]); if (!BoxNonStrictThis(cx, thisv, thisv)) return NullValue(); return 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(void) JS_updateMallocCounter(JSContext* cx, size_t nbytes) { return cx->updateMallocCounter(nbytes); } JS_PUBLIC_API(char*) JS_strdup(JSContext* cx, const char* s) { AssertHeapIsIdle(cx); return DuplicateString(cx, s).release(); } #undef JS_AddRoot JS_PUBLIC_API(bool) JS_AddExtraGCRootsTracer(JSContext* cx, JSTraceDataOp traceOp, void* data) { return cx->gc.addBlackRootsTracer(traceOp, data); } JS_PUBLIC_API(void) JS_RemoveExtraGCRootsTracer(JSContext* cx, JSTraceDataOp traceOp, void* data) { return cx->gc.removeBlackRootsTracer(traceOp, data); } JS_PUBLIC_API(void) JS_GC(JSContext* cx) { AssertHeapIsIdle(cx); JS::PrepareForFullGC(cx); cx->gc.gc(GC_NORMAL, JS::gcreason::API); } JS_PUBLIC_API(void) JS_MaybeGC(JSContext* cx) { GCRuntime& gc = cx->runtime()->gc; gc.maybeGC(cx->zone()); } JS_PUBLIC_API(void) JS_SetGCCallback(JSContext* cx, JSGCCallback cb, void* data) { AssertHeapIsIdle(cx); cx->gc.setGCCallback(cb, data); } JS_PUBLIC_API(void) JS_SetObjectsTenuredCallback(JSContext* cx, JSObjectsTenuredCallback cb, void* data) { AssertHeapIsIdle(cx); cx->gc.setObjectsTenuredCallback(cb, data); } JS_PUBLIC_API(bool) JS_AddFinalizeCallback(JSContext* cx, JSFinalizeCallback cb, void* data) { AssertHeapIsIdle(cx); return cx->gc.addFinalizeCallback(cb, data); } JS_PUBLIC_API(void) JS_RemoveFinalizeCallback(JSContext* cx, JSFinalizeCallback cb) { cx->gc.removeFinalizeCallback(cb); } JS_PUBLIC_API(bool) JS_AddWeakPointerZoneGroupCallback(JSContext* cx, JSWeakPointerZoneGroupCallback cb, void* data) { AssertHeapIsIdle(cx); return cx->gc.addWeakPointerZoneGroupCallback(cb, data); } JS_PUBLIC_API(void) JS_RemoveWeakPointerZoneGroupCallback(JSContext* cx, JSWeakPointerZoneGroupCallback cb) { cx->gc.removeWeakPointerZoneGroupCallback(cb); } JS_PUBLIC_API(bool) JS_AddWeakPointerCompartmentCallback(JSContext* cx, JSWeakPointerCompartmentCallback cb, void* data) { AssertHeapIsIdle(cx); return cx->gc.addWeakPointerCompartmentCallback(cb, data); } JS_PUBLIC_API(void) JS_RemoveWeakPointerCompartmentCallback(JSContext* cx, JSWeakPointerCompartmentCallback cb) { cx->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(JSContext* cx, JSGCParamKey key, uint32_t value) { cx->gc.waitBackgroundSweepEnd(); AutoLockGC lock(cx); MOZ_ALWAYS_TRUE(cx->gc.setParameter(key, value, lock)); } JS_PUBLIC_API(void) JS_SetGGCMode(JSContext* cx, bool enabled) { // Control GGC if (enabled && !cx->gc.isGenerationalGCEnabled()) { cx->gc.enableGenerationalGC(); } else if (!enabled && cx->gc.isGenerationalGCEnabled()) { cx->gc.disableGenerationalGC(); } } JS_PUBLIC_API(uint32_t) JS_GetGCParameter(JSContext* cx, JSGCParamKey key) { AutoLockGC lock(cx); return cx->gc.getParameter(key, lock); } static const size_t NumGCConfigs = 14; struct JSGCConfig { JSGCParamKey key; uint32_t value; }; JS_PUBLIC_API(void) JS_SetGCParametersBasedOnAvailableMemory(JSContext* cx, 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_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_MODE, JSGC_MODE_ZONE} }; config = nominal; } for (size_t i = 0; i < NumGCConfigs; i++) JS_SetGCParameter(cx, 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(JSContext* cx, StackKind kind, size_t stackSize) { cx->nativeStackQuota[kind] = stackSize; #if JS_STACK_GROWTH_DIRECTION > 0 if (stackSize == 0) { cx->nativeStackLimit[kind] = UINTPTR_MAX; } else { MOZ_ASSERT(cx->nativeStackBase <= size_t(-1) - stackSize); cx->nativeStackLimit[kind] = cx->nativeStackBase + stackSize - 1; } #else if (stackSize == 0) { cx->nativeStackLimit[kind] = 0; } else { MOZ_ASSERT(cx->nativeStackBase >= stackSize); cx->nativeStackLimit[kind] = cx->nativeStackBase - (stackSize - 1); } #endif } JS_PUBLIC_API(void) JS_SetNativeStackQuota(JSContext* cx, size_t systemCodeStackSize, size_t trustedScriptStackSize, size_t untrustedScriptStackSize) { MOZ_ASSERT(cx->requestDepth == 0); if (!trustedScriptStackSize) trustedScriptStackSize = systemCodeStackSize; else MOZ_ASSERT(trustedScriptStackSize < systemCodeStackSize); if (!untrustedScriptStackSize) untrustedScriptStackSize = trustedScriptStackSize; else MOZ_ASSERT(untrustedScriptStackSize < trustedScriptStackSize); SetNativeStackQuotaAndLimit(cx, StackForSystemCode, systemCodeStackSize); SetNativeStackQuotaAndLimit(cx, StackForTrustedScript, trustedScriptStackSize); SetNativeStackQuotaAndLimit(cx, StackForUntrustedScript, untrustedScriptStackSize); cx->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_ReportErrorNumberASCII(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; const char* source = ValueToSourceForError(cx, args.get(0), bytes); if (!source) { ReportOutOfMemory(cx); return false; } JS_ReportErrorNumberLatin1(cx, GetErrorMessage, nullptr, JSMSG_NOT_EXPECTED_TYPE, "Symbol.toPrimitive", "\"string\", \"number\", or \"default\"", source); 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_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_NO_CONSTRUCTOR, proto->getClass()->name); return nullptr; } return &cval.toObject(); } bool JS::CompartmentBehaviors::extraWarnings(JSContext* cx) const { return extraWarningsOverride_.get(cx->options().extraWarnings()); } JS::CompartmentCreationOptions& JS::CompartmentCreationOptions::setZone(ZoneSpecifier spec) { zone_.spec = spec; return *this; } JS::CompartmentCreationOptions& JS::CompartmentCreationOptions::setSameZoneAs(JSObject* obj) { zone_.pointer = static_cast<void*>(obj->zone()); return *this; } const JS::CompartmentCreationOptions& JS::CompartmentCreationOptionsRef(JSCompartment* compartment) { return compartment->creationOptions(); } const JS::CompartmentCreationOptions& JS::CompartmentCreationOptionsRef(JSObject* obj) { return obj->compartment()->creationOptions(); } const JS::CompartmentCreationOptions& JS::CompartmentCreationOptionsRef(JSContext* cx) { return cx->compartment()->creationOptions(); } bool JS::CompartmentCreationOptions::getSharedMemoryAndAtomicsEnabled() const { #if defined(ENABLE_SHARED_ARRAY_BUFFER) return sharedMemoryAndAtomics_; #else return false; #endif } JS::CompartmentCreationOptions& JS::CompartmentCreationOptions::setSharedMemoryAndAtomicsEnabled(bool flag) { #if defined(ENABLE_SHARED_ARRAY_BUFFER) sharedMemoryAndAtomics_ = flag; #endif return *this; } JS::CompartmentBehaviors& JS::CompartmentBehaviorsRef(JSCompartment* compartment) { return compartment->behaviors(); } JS::CompartmentBehaviors& JS::CompartmentBehaviorsRef(JSObject* obj) { return obj->compartment()->behaviors(); } JS::CompartmentBehaviors& JS::CompartmentBehaviorsRef(JSContext* cx) { return cx->compartment()->behaviors(); } JS_PUBLIC_API(JSObject*) JS_NewGlobalObject(JSContext* cx, const JSClass* clasp, JSPrincipals* principals, JS::OnNewGlobalHookOption hookOption, const JS::CompartmentOptions& options) { MOZ_RELEASE_ASSERT(cx->runtime()->hasInitializedSelfHosting(), "Must call JS::InitSelfHostedCode() before creating a global"); 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. // // Similarly, if we GC when creating the global, we may not have set that // global's compartment's global pointer yet. In this case, the compartment // will not yet contain anything that needs to be traced. if (!global->isOwnGlobal(trc)) return; // Trace the compartment for any GC things that should only stick around if // we know the compartment is live. global->compartment()->trace(trc); if (JSTraceOp trace = global->compartment()->creationOptions().getTrace()) 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(void) JS::AssertObjectBelongsToCurrentThread(JSObject* obj) { JSRuntime* rt = obj->compartment()->runtimeFromAnyThread(); MOZ_RELEASE_ASSERT(CurrentThreadCanAccessRuntime(rt)); } /*** 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_GetPrototypeIfOrdinary(JSContext* cx, HandleObject obj, bool* isOrdinary, MutableHandleObject result) { return GetPrototypeIfOrdinary(cx, obj, isOrdinary, result); } 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<PropertyDescriptor> 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<PropertyDescriptor> 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, size_t namelen, MutableHandle<PropertyDescriptor> desc) { JSAtom* atom = AtomizeChars(cx, name, namelen); if (!atom) return false; RootedId id(cx, AtomToId(atom)); return JS_GetOwnPropertyDescriptorById(cx, obj, id, desc); } JS_PUBLIC_API(bool) JS_GetOwnElement(JSContext* cx, JS::HandleObject obj, uint32_t index, JS::MutableHandleValue vp) { RootedId id(cx); if (!IndexToId(cx, index, &id)) { return false; } Rooted<PropertyDescriptor> desc(cx); if (!JS_GetOwnPropertyDescriptorById(cx, obj, id, &desc)) { return false; } if (desc.object() && desc.isDataDescriptor()) { vp.set(desc.value()); } else { vp.setUndefined(); } return true; } JS_PUBLIC_API(bool) JS_GetPropertyDescriptorById(JSContext* cx, HandleObject obj, HandleId id, MutableHandle<PropertyDescriptor> desc) { return GetPropertyDescriptor(cx, obj, id, desc); } JS_PUBLIC_API(bool) JS_GetPropertyDescriptor(JSContext* cx, HandleObject obj, const char* name, MutableHandle<PropertyDescriptor> desc) { JSAtom* atom = Atomize(cx, name, strlen(name)); if (!atom) return false; RootedId id(cx, AtomToId(atom)); return JS_GetPropertyDescriptorById(cx, obj, id, desc); } JS_PUBLIC_API(bool) JS_GetUCPropertyDescriptor(JSContext* cx, HandleObject obj, const char16_t* name, size_t namelen, MutableHandle<PropertyDescriptor> desc) { JSAtom* atom = AtomizeChars(cx, name, namelen); if (!atom) { return false; } RootedId id(cx, AtomToId(atom)); return JS_GetPropertyDescriptorById(cx, obj, id, desc); } static bool DefinePropertyByDescriptor(JSContext* cx, HandleObject obj, HandleId id, Handle<PropertyDescriptor> 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<PropertyDescriptor> desc, ObjectOpResult& result) { return DefinePropertyByDescriptor(cx, obj, id, desc, result); } JS_PUBLIC_API(bool) JS_DefinePropertyById(JSContext* cx, HandleObject obj, HandleId id, Handle<PropertyDescriptor> 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) { if (getter && !(attrs & JSPROP_GETTER)) { RootedAtom atom(cx, IdToFunctionName(cx, id, FunctionPrefixKind::Get)); if (!atom) return false; 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); RootedAtom atom(cx, IdToFunctionName(cx, id, FunctionPrefixKind::Set)); if (!atom) return false; 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()->getGetProperty(); if (!setter) setter = obj->getClass()->getSetProperty(); } 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<PropertyDescriptor> 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<PropertyDescriptor> 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, ObjectOpResult& result) { CHECK_REQUEST(cx); assertSameCompartment(cx, obj); JSAtom* atom = AtomizeChars(cx, name, AUTO_NAMELEN(name, namelen)); if (!atom) return false; RootedId id(cx, AtomToId(atom)); return DeleteProperty(cx, obj, id, result); } JS_PUBLIC_API(bool) JS_DeleteElement(JSContext* cx, HandleObject obj, uint32_t index, ObjectOpResult& result) { AssertHeapIsIdle(cx); CHECK_REQUEST(cx); assertSameCompartment(cx, obj); return DeleteElement(cx, obj, index, result); } JS_PUBLIC_API(bool) JS_DeletePropertyById(JSContext* cx, HandleObject obj, HandleId id) { ObjectOpResult ignored; return JS_DeletePropertyById(cx, obj, id, ignored); } JS_PUBLIC_API(bool) JS_DeleteProperty(JSContext* cx, HandleObject obj, const char* name) { ObjectOpResult ignored; return JS_DeleteProperty(cx, obj, name, ignored); } JS_PUBLIC_API(bool) JS_DeleteElement(JSContext* cx, HandleObject obj, uint32_t index) { ObjectOpResult ignored; return JS_DeleteElement(cx, obj, index, ignored); } JS_PUBLIC_API(bool) JS_Enumerate(JSContext* cx, HandleObject obj, JS::MutableHandle<IdVector> props) { AssertHeapIsIdle(cx); CHECK_REQUEST(cx); assertSameCompartment(cx, obj); MOZ_ASSERT(props.empty()); AutoIdVector ids(cx); if (!GetPropertyKeys(cx, obj, JSITER_OWNONLY, &ids)) return false; return props.append(ids.begin(), ids.end()); } JS_PUBLIC_API(bool) JS::IsCallable(JSObject* obj) { return obj->isCallable(); } JS_PUBLIC_API(bool) JS::IsConstructor(JSObject* obj) { return obj->isConstructor(); } JS_PUBLIC_API(bool) JS_CallFunctionValue(JSContext* cx, HandleObject obj, HandleValue fval, const HandleValueArray& args, MutableHandleValue rval) { MOZ_ASSERT(!cx->runtime()->isAtomsCompartment(cx->compartment())); AssertHeapIsIdle(cx); CHECK_REQUEST(cx); assertSameCompartment(cx, obj, fval, args); InvokeArgs iargs(cx); if (!FillArgumentsFromArraylike(cx, iargs, args)) return false; RootedValue thisv(cx, ObjectOrNullValue(obj)); return Call(cx, fval, thisv, iargs, rval); } JS_PUBLIC_API(bool) JS_CallFunction(JSContext* cx, HandleObject obj, HandleFunction fun, const HandleValueArray& args, MutableHandleValue rval) { MOZ_ASSERT(!cx->runtime()->isAtomsCompartment(cx->compartment())); AssertHeapIsIdle(cx); CHECK_REQUEST(cx); assertSameCompartment(cx, obj, fun, args); InvokeArgs iargs(cx); if (!FillArgumentsFromArraylike(cx, iargs, args)) return false; RootedValue fval(cx, ObjectValue(*fun)); RootedValue thisv(cx, ObjectOrNullValue(obj)); return Call(cx, fval, thisv, iargs, rval); } JS_PUBLIC_API(bool) JS_CallFunctionName(JSContext* cx, HandleObject obj, const char* name, const HandleValueArray& args, MutableHandleValue rval) { MOZ_ASSERT(!cx->runtime()->isAtomsCompartment(cx->compartment())); AssertHeapIsIdle(cx); CHECK_REQUEST(cx); assertSameCompartment(cx, obj, args); JSAtom* atom = Atomize(cx, name, strlen(name)); if (!atom) return false; RootedValue fval(cx); RootedId id(cx, AtomToId(atom)); if (!GetProperty(cx, obj, obj, id, &fval)) return false; InvokeArgs iargs(cx); if (!FillArgumentsFromArraylike(cx, iargs, args)) return false; RootedValue thisv(cx, ObjectOrNullValue(obj)); return Call(cx, fval, thisv, iargs, rval); } JS_PUBLIC_API(bool) JS::Call(JSContext* cx, HandleValue thisv, HandleValue fval, const JS::HandleValueArray& args, MutableHandleValue rval) { AssertHeapIsIdle(cx); CHECK_REQUEST(cx); assertSameCompartment(cx, thisv, fval, args); InvokeArgs iargs(cx); if (!FillArgumentsFromArraylike(cx, iargs, args)) return false; return Call(cx, fval, thisv, iargs, rval); } JS_PUBLIC_API(bool) JS::Construct(JSContext* cx, HandleValue fval, HandleObject newTarget, const JS::HandleValueArray& args, MutableHandleObject objp) { AssertHeapIsIdle(cx); CHECK_REQUEST(cx); assertSameCompartment(cx, fval, newTarget, args); if (!IsConstructor(fval)) { ReportValueError(cx, JSMSG_NOT_CONSTRUCTOR, JSDVG_IGNORE_STACK, fval, nullptr); return false; } RootedValue newTargetVal(cx, ObjectValue(*newTarget)); if (!IsConstructor(newTargetVal)) { ReportValueError(cx, JSMSG_NOT_CONSTRUCTOR, JSDVG_IGNORE_STACK, newTargetVal, nullptr); return false; } ConstructArgs cargs(cx); if (!FillArgumentsFromArraylike(cx, cargs, args)) return false; return js::Construct(cx, fval, cargs, newTargetVal, objp); } JS_PUBLIC_API(bool) JS::Construct(JSContext* cx, HandleValue fval, const JS::HandleValueArray& args, MutableHandleObject objp) { AssertHeapIsIdle(cx); CHECK_REQUEST(cx); assertSameCompartment(cx, fval, args); if (!IsConstructor(fval)) { ReportValueError(cx, JSMSG_NOT_CONSTRUCTOR, JSDVG_IGNORE_STACK, fval, nullptr); return false; } ConstructArgs cargs(cx); if (!FillArgumentsFromArraylike(cx, cargs, args)) return false; return js::Construct(cx, fval, cargs, fval, objp); } /* * */ JS_PUBLIC_API(bool) JS_AlreadyHasOwnPropertyById(JSContext* cx, HandleObject obj, HandleId id, bool* foundp) { AssertHeapIsIdle(cx); CHECK_REQUEST(cx); assertSameCompartment(cx, obj, id); if (!obj->isNative()) return js::HasOwnProperty(cx, obj, id, foundp); RootedNativeObject nativeObj(cx, &obj->as<NativeObject>()); RootedShape prop(cx); NativeLookupOwnPropertyNoResolve(cx, nativeObj, id, &prop); *foundp = !!prop; return true; } JS_PUBLIC_API(bool) JS_AlreadyHasOwnProperty(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_AlreadyHasOwnPropertyById(cx, obj, id, foundp); } JS_PUBLIC_API(bool) JS_AlreadyHasOwnUCProperty(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_AlreadyHasOwnPropertyById(cx, obj, id, foundp); } JS_PUBLIC_API(bool) JS_AlreadyHasOwnElement(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_AlreadyHasOwnPropertyById(cx, obj, id, foundp); } JS_PUBLIC_API(bool) JS_FreezeObject(JSContext* cx, HandleObject obj) { AssertHeapIsIdle(cx); CHECK_REQUEST(cx); assertSameCompartment(cx, obj); return FreezeObject(cx, obj); } static bool DeepFreezeSlot(JSContext* cx, const Value& v) { if (v.isPrimitive()) return true; RootedObject obj(cx, &v.toObject()); return JS_DeepFreezeObject(cx, obj); } JS_PUBLIC_API(bool) JS_DeepFreezeObject(JSContext* cx, HandleObject obj) { AssertHeapIsIdle(cx); CHECK_REQUEST(cx); assertSameCompartment(cx, obj); /* Assume that non-extensible objects are already deep-frozen, to avoid divergence. */ bool extensible; if (!IsExtensible(cx, obj, &extensible)) return false; if (!extensible) return true; if (!FreezeObject(cx, obj)) return false; /* Walk slots in obj and if any value is a non-null object, seal it. */ if (obj->isNative()) { RootedNativeObject nobj(cx, &obj->as<NativeObject>()); for (uint32_t i = 0, n = nobj->slotSpan(); i < n; ++i) { if (!DeepFreezeSlot(cx, nobj->getSlot(i))) return false; } for (uint32_t i = 0, n = nobj->getDenseInitializedLength(); i < n; ++i) { if (!DeepFreezeSlot(cx, nobj->getDenseElement(i))) return false; } } return true; } static bool DefineSelfHostedProperty(JSContext* cx, HandleObject obj, HandleId id, const char* getterName, const char* setterName, unsigned attrs, unsigned flags) { JSAtom* getterNameAtom = Atomize(cx, getterName, strlen(getterName)); if (!getterNameAtom) return false; RootedPropertyName getterNameName(cx, getterNameAtom->asPropertyName()); RootedAtom name(cx, IdToFunctionName(cx, id)); if (!name) return false; RootedValue getterValue(cx); if (!GlobalObject::getSelfHostedFunction(cx, cx->global(), getterNameName, name, 0, &getterValue)) { return false; } MOZ_ASSERT(getterValue.isObject() && getterValue.toObject().is<JSFunction>()); RootedFunction getterFunc(cx, &getterValue.toObject().as<JSFunction>()); JSNative getterOp = JS_DATA_TO_FUNC_PTR(JSNative, getterFunc.get()); RootedFunction setterFunc(cx); if (setterName) { JSAtom* setterNameAtom = Atomize(cx, setterName, strlen(setterName)); if (!setterNameAtom) return false; RootedPropertyName setterNameName(cx, setterNameAtom->asPropertyName()); RootedValue setterValue(cx); if (!GlobalObject::getSelfHostedFunction(cx, cx->global(), setterNameName, name, 0, &setterValue)) { return false; } MOZ_ASSERT(setterValue.isObject() && setterValue.toObject().is<JSFunction>()); setterFunc = &setterValue.toObject().as<JSFunction>(); } JSNative setterOp = JS_DATA_TO_FUNC_PTR(JSNative, setterFunc.get()); return DefinePropertyById(cx, obj, id, JS::UndefinedHandleValue, NativeOpWrapper(getterOp), NativeOpWrapper(setterOp), attrs, flags); } JS_PUBLIC_API(JSObject*) JS_DefineObject(JSContext* cx, HandleObject obj, const char* name, const JSClass* jsclasp, unsigned attrs) { AssertHeapIsIdle(cx); CHECK_REQUEST(cx); assertSameCompartment(cx, obj); const Class* clasp = Valueify(jsclasp); if (!clasp) clasp = &PlainObject::class_; /* default class is Object */ RootedObject nobj(cx, NewObjectWithClassProto(cx, clasp, nullptr)); if (!nobj) return nullptr; RootedValue nobjValue(cx, ObjectValue(*nobj)); if (!DefineProperty(cx, obj, name, nobjValue, NativeOpWrapper(nullptr), NativeOpWrapper(nullptr), attrs, 0)) { return nullptr; } return nobj; } static inline Value ValueFromScalar(double x) { return DoubleValue(x); } static inline Value ValueFromScalar(int32_t x) { return Int32Value(x); } template<typename T> static bool DefineConstScalar(JSContext* cx, HandleObject obj, const JSConstScalarSpec<T>* cds) { AssertHeapIsIdle(cx); CHECK_REQUEST(cx); JSNativeWrapper noget = NativeOpWrapper(nullptr); JSNativeWrapper noset = NativeOpWrapper(nullptr); unsigned attrs = JSPROP_READONLY | JSPROP_PERMANENT; for (; cds->name; cds++) { RootedValue value(cx, ValueFromScalar(cds->val)); if (!DefineProperty(cx, obj, cds->name, value, noget, noset, attrs, 0)) return false; } return true; } JS_PUBLIC_API(bool) JS_DefineConstDoubles(JSContext* cx, HandleObject obj, const JSConstDoubleSpec* cds) { return DefineConstScalar(cx, obj, cds); } JS_PUBLIC_API(bool) JS_DefineConstIntegers(JSContext* cx, HandleObject obj, const JSConstIntegerSpec* cis) { return DefineConstScalar(cx, obj, cis); } JS_PUBLIC_API(bool) JSPropertySpec::getValue(JSContext* cx, MutableHandleValue vp) const { MOZ_ASSERT(!isAccessor()); if (value.type == JSVAL_TYPE_STRING) { RootedAtom atom(cx, Atomize(cx, value.string, strlen(value.string))); if (!atom) return false; vp.setString(atom); } else { MOZ_ASSERT(value.type == JSVAL_TYPE_INT32); vp.setInt32(value.int32); } return true; } static JS::SymbolCode PropertySpecNameToSymbolCode(const char* name) { MOZ_ASSERT(JS::PropertySpecNameIsSymbol(name)); uintptr_t u = reinterpret_cast<uintptr_t>(name); return JS::SymbolCode(u - 1); } bool PropertySpecNameToId(JSContext* cx, const char* name, MutableHandleId id, js::PinningBehavior pin = js::DoNotPinAtom) { if (JS::PropertySpecNameIsSymbol(name)) { JS::SymbolCode which = PropertySpecNameToSymbolCode(name); id.set(SYMBOL_TO_JSID(cx->wellKnownSymbols().get(which))); } else { JSAtom* atom = Atomize(cx, name, strlen(name), pin); if (!atom) return false; id.set(AtomToId(atom)); } return true; } JS_PUBLIC_API(bool) JS::PropertySpecNameToPermanentId(JSContext* cx, const char* name, jsid* idp) { // We are calling fromMarkedLocation(idp) even though idp points to a // location that will never be marked. This is OK because the whole point // of this API is to populate *idp with a jsid that does not need to be // marked. return PropertySpecNameToId(cx, name, MutableHandleId::fromMarkedLocation(idp), js::PinAtom); } JS_PUBLIC_API(bool) JS_DefineProperties(JSContext* cx, HandleObject obj, const JSPropertySpec* ps) { RootedId id(cx); for (; ps->name; ps++) { if (!PropertySpecNameToId(cx, ps->name, &id)) return false; if (ps->isAccessor()) { if (ps->isSelfHosted()) { if (!DefineSelfHostedProperty(cx, obj, id, ps->accessors.getter.selfHosted.funname, ps->accessors.setter.selfHosted.funname, ps->flags, 0)) { return false; } } else { if (!DefinePropertyById(cx, obj, id, JS::UndefinedHandleValue, ps->accessors.getter.native, ps->accessors.setter.native, ps->flags, 0)) { return false; } } } else { RootedValue v(cx); if (!ps->getValue(cx, &v)) return false; if (!DefinePropertyById(cx, obj, id, v, NativeOpWrapper(nullptr), NativeOpWrapper(nullptr), ps->flags & ~JSPROP_INTERNAL_USE_BIT, 0)) { return false; } } } return true; } JS_PUBLIC_API(bool) JS::ObjectToCompletePropertyDescriptor(JSContext* cx, HandleObject obj, HandleValue descObj, MutableHandle<PropertyDescriptor> desc) { if (!ToPropertyDescriptor(cx, descObj, true, desc)) return false; CompletePropertyDescriptor(desc); desc.object().set(obj); return true; } JS_PUBLIC_API(void) JS_SetAllNonReservedSlotsToUndefined(JSContext* cx, JSObject* objArg) { RootedObject obj(cx, objArg); AssertHeapIsIdle(cx); CHECK_REQUEST(cx); assertSameCompartment(cx, obj); if (!obj->isNative()) return; const Class* clasp = obj->getClass(); unsigned numReserved = JSCLASS_RESERVED_SLOTS(clasp); unsigned numSlots = obj->as<NativeObject>().slotSpan(); for (unsigned i = numReserved; i < numSlots; i++) obj->as<NativeObject>().setSlot(i, UndefinedValue()); } JS_PUBLIC_API(Value) JS_GetReservedSlot(JSObject* obj, uint32_t index) { return obj->as<NativeObject>().getReservedSlot(index); } JS_PUBLIC_API(void) JS_SetReservedSlot(JSObject* obj, uint32_t index, const Value& value) { obj->as<NativeObject>().setReservedSlot(index, value); } JS_PUBLIC_API(JSObject*) JS_NewArrayObject(JSContext* cx, const JS::HandleValueArray& contents) { MOZ_ASSERT(!cx->runtime()->isAtomsCompartment(cx->compartment())); AssertHeapIsIdle(cx); CHECK_REQUEST(cx); assertSameCompartment(cx, contents); return NewDenseCopiedArray(cx, contents.length(), contents.begin()); } JS_PUBLIC_API(JSObject*) JS_NewArrayObject(JSContext* cx, size_t length) { MOZ_ASSERT(!cx->runtime()->isAtomsCompartment(cx->compartment())); AssertHeapIsIdle(cx); CHECK_REQUEST(cx); return NewDenseFullyAllocatedArray(cx, length); } inline bool IsGivenTypeObject(JSContext* cx, JS::HandleObject obj, const ESClass& typeClass, bool* isType) { assertSameCompartment(cx, obj); ESClass cls; if (!GetBuiltinClass(cx, obj, &cls)) return false; *isType = cls == typeClass; return true; } JS_PUBLIC_API(bool) JS_IsArrayObject(JSContext* cx, JS::HandleObject obj, bool* isArray) { return IsGivenTypeObject(cx, obj, ESClass::Array, isArray); } JS_PUBLIC_API(bool) JS_IsArrayObject(JSContext* cx, JS::HandleValue value, bool* isArray) { if (!value.isObject()) { *isArray = false; return true; } RootedObject obj(cx, &value.toObject()); return JS_IsArrayObject(cx, obj, isArray); } JS_PUBLIC_API(bool) JS_GetArrayLength(JSContext* cx, HandleObject obj, uint32_t* lengthp) { AssertHeapIsIdle(cx); CHECK_REQUEST(cx); assertSameCompartment(cx, obj); return GetLengthProperty(cx, obj, lengthp); } JS_PUBLIC_API(bool) JS_SetArrayLength(JSContext* cx, HandleObject obj, uint32_t length) { AssertHeapIsIdle(cx); CHECK_REQUEST(cx); assertSameCompartment(cx, obj); return SetLengthProperty(cx, obj, length); } JS_PUBLIC_API(bool) JS::IsMapObject(JSContext* cx, JS::HandleObject obj, bool* isMap) { return IsGivenTypeObject(cx, obj, ESClass::Map, isMap); } JS_PUBLIC_API(bool) JS::IsSetObject(JSContext* cx, JS::HandleObject obj, bool* isSet) { return IsGivenTypeObject(cx, obj, ESClass::Set, isSet); } JS_PUBLIC_API(void) JS_HoldPrincipals(JSPrincipals* principals) { ++principals->refcount; } JS_PUBLIC_API(void) JS_DropPrincipals(JSContext* cx, JSPrincipals* principals) { int rc = --principals->refcount; if (rc == 0) cx->destroyPrincipals(principals); } JS_PUBLIC_API(void) JS_SetSecurityCallbacks(JSContext* cx, const JSSecurityCallbacks* scb) { MOZ_ASSERT(scb != &NullSecurityCallbacks); cx->securityCallbacks = scb ? scb : &NullSecurityCallbacks; } JS_PUBLIC_API(const JSSecurityCallbacks*) JS_GetSecurityCallbacks(JSContext* cx) { return (cx->securityCallbacks != &NullSecurityCallbacks) ? cx->securityCallbacks : nullptr; } JS_PUBLIC_API(void) JS_SetTrustedPrincipals(JSContext* cx, JSPrincipals* prin) { cx->setTrustedPrincipals(prin); } extern JS_PUBLIC_API(void) JS_InitDestroyPrincipalsCallback(JSContext* cx, JSDestroyPrincipalsOp destroyPrincipals) { MOZ_ASSERT(destroyPrincipals); MOZ_ASSERT(!cx->destroyPrincipals); cx->destroyPrincipals = destroyPrincipals; } extern JS_PUBLIC_API(void) JS_InitReadPrincipalsCallback(JSContext* cx, JSReadPrincipalsOp read) { MOZ_ASSERT(read); MOZ_ASSERT(!cx->readPrincipals); cx->readPrincipals = read; } JS_PUBLIC_API(JSFunction*) JS_NewFunction(JSContext* cx, JSNative native, unsigned nargs, unsigned flags, const char* name) { MOZ_ASSERT(!cx->runtime()->isAtomsCompartment(cx->compartment())); AssertHeapIsIdle(cx); CHECK_REQUEST(cx); RootedAtom atom(cx); if (name) { atom = Atomize(cx, name, strlen(name)); if (!atom) return nullptr; } return (flags & JSFUN_CONSTRUCTOR) ? NewNativeConstructor(cx, native, nargs, atom) : NewNativeFunction(cx, native, nargs, atom); } JS_PUBLIC_API(JSFunction*) JS::GetSelfHostedFunction(JSContext* cx, const char* selfHostedName, HandleId id, unsigned nargs) { MOZ_ASSERT(!cx->runtime()->isAtomsCompartment(cx->compartment())); AssertHeapIsIdle(cx); CHECK_REQUEST(cx); RootedAtom name(cx, IdToFunctionName(cx, id)); if (!name) return nullptr; JSAtom* shAtom = Atomize(cx, selfHostedName, strlen(selfHostedName)); if (!shAtom) return nullptr; RootedPropertyName shName(cx, shAtom->asPropertyName()); RootedValue funVal(cx); if (!GlobalObject::getSelfHostedFunction(cx, cx->global(), shName, name, nargs, &funVal)) return nullptr; return &funVal.toObject().as<JSFunction>(); } JS_PUBLIC_API(JSFunction*) JS::NewFunctionFromSpec(JSContext* cx, const JSFunctionSpec* fs, HandleId id) { // Delay cloning self-hosted functions until they are called. This is // achieved by passing DefineFunction a nullptr JSNative which produces an // interpreted JSFunction where !hasScript. Interpreted call paths then // call InitializeLazyFunctionScript if !hasScript. if (fs->selfHostedName) { MOZ_ASSERT(!fs->call.op); MOZ_ASSERT(!fs->call.info); JSAtom* shAtom = Atomize(cx, fs->selfHostedName, strlen(fs->selfHostedName)); if (!shAtom) return nullptr; RootedPropertyName shName(cx, shAtom->asPropertyName()); RootedAtom name(cx, IdToFunctionName(cx, id)); if (!name) return nullptr; RootedValue funVal(cx); if (!GlobalObject::getSelfHostedFunction(cx, cx->global(), shName, name, fs->nargs, &funVal)) { return nullptr; } return &funVal.toObject().as<JSFunction>(); } RootedAtom atom(cx, IdToFunctionName(cx, id)); if (!atom) return nullptr; JSFunction* fun; if (!fs->call.op) fun = NewScriptedFunction(cx, fs->nargs, JSFunction::INTERPRETED_LAZY, atom); else if (fs->flags & JSFUN_CONSTRUCTOR) fun = NewNativeConstructor(cx, fs->call.op, fs->nargs, atom); else fun = NewNativeFunction(cx, fs->call.op, fs->nargs, atom); if (!fun) return nullptr; if (fs->call.info) fun->setJitInfo(fs->call.info); return fun; } static bool CreateNonSyntacticEnvironmentChain(JSContext* cx, AutoObjectVector& envChain, MutableHandleObject env, MutableHandleScope scope) { RootedObject globalLexical(cx, &cx->global()->lexicalEnvironment()); if (!js::CreateObjectsForEnvironmentChain(cx, envChain, globalLexical, env)) return false; if (!envChain.empty()) { scope.set(GlobalScope::createEmpty(cx, ScopeKind::NonSyntactic)); if (!scope) return false; // The XPConnect subscript loader, which may pass in its own // environments to load scripts in, expects the environment chain to // be the holder of "var" declarations. In SpiderMonkey, such objects // are called "qualified varobjs", the "qualified" part meaning the // declaration was qualified by "var". There is only sadness. // // See JSObject::isQualifiedVarObj. if (!JSObject::setQualifiedVarObj(cx, env)) return false; // Also get a non-syntactic lexical environment to capture 'let' and // 'const' bindings. To persist lexical bindings, we have a 1-1 // mapping with the final unwrapped environment object (the // environment that stores the 'var' bindings) and the lexical // environment. // // TODOshu: disallow the subscript loader from using non-distinguished // objects as dynamic scopes. env.set(cx->compartment()->getOrCreateNonSyntacticLexicalEnvironment(cx, env)); if (!env) return false; } else { scope.set(&cx->global()->emptyGlobalScope()); } return true; } static bool IsFunctionCloneable(HandleFunction fun) { if (!fun->isInterpreted()) return true; // If a function was compiled with non-global syntactic environments on // the environment chain, we could have baked in EnvironmentCoordinates // into the script. We cannot clone it without breaking the compiler's // assumptions. for (ScopeIter si(fun->nonLazyScript()->enclosingScope()); si; si++) { if (si.scope()->is<GlobalScope>()) return true; if (si.hasSyntacticEnvironment()) return false; } return true; } static JSObject* CloneFunctionObject(JSContext* cx, HandleObject funobj, HandleObject env, HandleScope scope) { AssertHeapIsIdle(cx); CHECK_REQUEST(cx); assertSameCompartment(cx, env); MOZ_ASSERT(env); // Note that funobj can be in a different compartment. if (!funobj->is<JSFunction>()) { AutoCompartment ac(cx, funobj); RootedValue v(cx, ObjectValue(*funobj)); ReportIsNotFunction(cx, v); return nullptr; } RootedFunction fun(cx, &funobj->as<JSFunction>()); if (fun->isInterpretedLazy()) { AutoCompartment ac(cx, funobj); if (!JSFunction::getOrCreateScript(cx, fun)) return nullptr; } if (!IsFunctionCloneable(fun)) { JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_BAD_CLONE_FUNOBJ_SCOPE); return nullptr; } if (fun->isBoundFunction()) { JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_CANT_CLONE_OBJECT); return nullptr; } if (IsAsmJSModule(fun)) { JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_CANT_CLONE_OBJECT); return nullptr; } if (IsWrappedAsyncFunction(fun)) { JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_CANT_CLONE_OBJECT); return nullptr; } if (CanReuseScriptForClone(cx->compartment(), fun, env)) { // If the script is to be reused, either the script can already handle // non-syntactic scopes, or there is only the standard global lexical // scope. #ifdef DEBUG // Fail here if we OOM during debug asserting. // CloneFunctionReuseScript will delazify the script anyways, so we // are not creating an extra failure condition for DEBUG builds. if (!JSFunction::getOrCreateScript(cx, fun)) return nullptr; MOZ_ASSERT(scope->as<GlobalScope>().isSyntactic() || fun->nonLazyScript()->hasNonSyntacticScope()); #endif return CloneFunctionReuseScript(cx, fun, env, fun->getAllocKind()); } JSFunction* clone = CloneFunctionAndScript(cx, fun, env, scope, fun->getAllocKind()); #ifdef DEBUG // The cloned function should itself be cloneable. RootedFunction cloneRoot(cx, clone); MOZ_ASSERT_IF(cloneRoot, IsFunctionCloneable(cloneRoot)); #endif return clone; } JS_PUBLIC_API(JSObject*) JS::CloneFunctionObject(JSContext* cx, HandleObject funobj) { RootedObject globalLexical(cx, &cx->global()->lexicalEnvironment()); RootedScope emptyGlobalScope(cx, &cx->global()->emptyGlobalScope()); return CloneFunctionObject(cx, funobj, globalLexical, emptyGlobalScope); } extern JS_PUBLIC_API(JSObject*) JS::CloneFunctionObject(JSContext* cx, HandleObject funobj, AutoObjectVector& envChain) { RootedObject env(cx); RootedScope scope(cx); if (!CreateNonSyntacticEnvironmentChain(cx, envChain, &env, &scope)) return nullptr; return CloneFunctionObject(cx, funobj, env, scope); } JS_PUBLIC_API(JSObject*) JS_GetFunctionObject(JSFunction* fun) { return fun; } JS_PUBLIC_API(JSString*) JS_GetFunctionId(JSFunction* fun) { return fun->explicitName(); } JS_PUBLIC_API(JSString*) JS_GetFunctionDisplayId(JSFunction* fun) { return fun->displayAtom(); } JS_PUBLIC_API(uint16_t) JS_GetFunctionArity(JSFunction* fun) { return fun->nargs(); } JS_PUBLIC_API(bool) JS_ObjectIsFunction(JSContext* cx, JSObject* obj) { return obj->is<JSFunction>(); } JS_PUBLIC_API(bool) JS_IsNativeFunction(JSObject* funobj, JSNative call) { if (!funobj->is<JSFunction>()) return false; JSFunction* fun = &funobj->as<JSFunction>(); return fun->isNative() && fun->native() == call; } extern JS_PUBLIC_API(bool) JS_IsConstructor(JSFunction* fun) { return fun->isConstructor(); } JS_PUBLIC_API(bool) JS_DefineFunctions(JSContext* cx, HandleObject obj, const JSFunctionSpec* fs) { MOZ_ASSERT(!cx->runtime()->isAtomsCompartment(cx->compartment())); AssertHeapIsIdle(cx); CHECK_REQUEST(cx); assertSameCompartment(cx, obj); return DefineFunctions(cx, obj, fs, NotIntrinsic); } JS_PUBLIC_API(JSFunction*) JS_DefineFunction(JSContext* cx, HandleObject obj, const char* name, JSNative call, unsigned nargs, unsigned attrs) { MOZ_ASSERT(!cx->runtime()->isAtomsCompartment(cx->compartment())); AssertHeapIsIdle(cx); CHECK_REQUEST(cx); assertSameCompartment(cx, obj); JSAtom* atom = Atomize(cx, name, strlen(name)); if (!atom) return nullptr; Rooted<jsid> id(cx, AtomToId(atom)); return DefineFunction(cx, obj, id, call, nargs, attrs); } JS_PUBLIC_API(JSFunction*) JS_DefineUCFunction(JSContext* cx, HandleObject obj, const char16_t* name, size_t namelen, JSNative call, unsigned nargs, unsigned attrs) { MOZ_ASSERT(!cx->runtime()->isAtomsCompartment(cx->compartment())); AssertHeapIsIdle(cx); CHECK_REQUEST(cx); assertSameCompartment(cx, obj); JSAtom* atom = AtomizeChars(cx, name, AUTO_NAMELEN(name, namelen)); if (!atom) return nullptr; Rooted<jsid> id(cx, AtomToId(atom)); return DefineFunction(cx, obj, id, call, nargs, attrs); } extern JS_PUBLIC_API(JSFunction*) JS_DefineFunctionById(JSContext* cx, HandleObject obj, HandleId id, JSNative call, unsigned nargs, unsigned attrs) { MOZ_ASSERT(!cx->runtime()->isAtomsCompartment(cx->compartment())); AssertHeapIsIdle(cx); CHECK_REQUEST(cx); assertSameCompartment(cx, obj); return DefineFunction(cx, obj, id, call, nargs, attrs); } /* Use the fastest available getc. */ #if defined(HAVE_GETC_UNLOCKED) # define fast_getc getc_unlocked #elif defined(HAVE__GETC_NOLOCK) # define fast_getc _getc_nolock #else # define fast_getc getc #endif typedef Vector<char, 8, TempAllocPolicy> FileContents; static bool ReadCompleteFile(JSContext* cx, FILE* fp, FileContents& buffer) { /* Get the complete length of the file, if possible. */ struct stat st; int ok = fstat(fileno(fp), &st); if (ok != 0) return false; if (st.st_size > 0) { if (!buffer.reserve(st.st_size)) return false; } // Read in the whole file. Note that we can't assume the data's length // is actually st.st_size, because 1) some files lie about their size // (/dev/zero and /dev/random), and 2) reading files in text mode on // Windows collapses "\r\n" pairs to single \n characters. for (;;) { int c = fast_getc(fp); if (c == EOF) break; if (!buffer.append(c)) return false; } return true; } namespace { class AutoFile { FILE* fp_; public: AutoFile() : fp_(nullptr) {} ~AutoFile() { if (fp_ && fp_ != stdin) fclose(fp_); } FILE* fp() const { return fp_; } bool open(JSContext* cx, const char* filename); bool readAll(JSContext* cx, FileContents& buffer) { MOZ_ASSERT(fp_); return ReadCompleteFile(cx, fp_, buffer); } }; } /* anonymous namespace */ /* * Open a source file for reading. Supports "-" and nullptr to mean stdin. The * return value must be fclosed unless it is stdin. */ bool AutoFile::open(JSContext* cx, const char* filename) { if (!filename || strcmp(filename, "-") == 0) { fp_ = stdin; } else { fp_ = fopen(filename, "r"); if (!fp_) { /* * Use Latin1 variant here because the encoding of filename is * platform dependent. */ JS_ReportErrorNumberLatin1(cx, GetErrorMessage, nullptr, JSMSG_CANT_OPEN, filename, "No such file or directory"); return false; } } return true; } void JS::TransitiveCompileOptions::copyPODTransitiveOptions(const TransitiveCompileOptions& rhs) { mutedErrors_ = rhs.mutedErrors_; version = rhs.version; versionSet = rhs.versionSet; utf8 = rhs.utf8; selfHostingMode = rhs.selfHostingMode; canLazilyParse = rhs.canLazilyParse; strictOption = rhs.strictOption; extraWarningsOption = rhs.extraWarningsOption; werrorOption = rhs.werrorOption; asmJSOption = rhs.asmJSOption; throwOnAsmJSValidationFailureOption = rhs.throwOnAsmJSValidationFailureOption; forceAsync = rhs.forceAsync; installedFile = rhs.installedFile; sourceIsLazy = rhs.sourceIsLazy; introductionType = rhs.introductionType; introductionLineno = rhs.introductionLineno; introductionOffset = rhs.introductionOffset; hasIntroductionInfo = rhs.hasIntroductionInfo; }; void JS::ReadOnlyCompileOptions::copyPODOptions(const ReadOnlyCompileOptions& rhs) { copyPODTransitiveOptions(rhs); lineno = rhs.lineno; column = rhs.column; isRunOnce = rhs.isRunOnce; noScriptRval = rhs.noScriptRval; } JS::OwningCompileOptions::OwningCompileOptions(JSContext* cx) : ReadOnlyCompileOptions(), elementRoot(cx), elementAttributeNameRoot(cx), introductionScriptRoot(cx) { } JS::OwningCompileOptions::~OwningCompileOptions() { // OwningCompileOptions always owns these, so these casts are okay. js_free(const_cast<char*>(filename_)); js_free(const_cast<char16_t*>(sourceMapURL_)); js_free(const_cast<char*>(introducerFilename_)); } bool JS::OwningCompileOptions::copy(JSContext* cx, const ReadOnlyCompileOptions& rhs) { copyPODOptions(rhs); setElement(rhs.element()); setElementAttributeName(rhs.elementAttributeName()); setIntroductionScript(rhs.introductionScript()); return setFileAndLine(cx, rhs.filename(), rhs.lineno) && setSourceMapURL(cx, rhs.sourceMapURL()) && setIntroducerFilename(cx, rhs.introducerFilename()); } bool JS::OwningCompileOptions::setFile(JSContext* cx, const char* f) { char* copy = nullptr; if (f) { copy = JS_strdup(cx, f); if (!copy) return false; } // OwningCompileOptions always owns filename_, so this cast is okay. js_free(const_cast<char*>(filename_)); filename_ = copy; return true; } bool JS::OwningCompileOptions::setFileAndLine(JSContext* cx, const char* f, unsigned l) { if (!setFile(cx, f)) return false; lineno = l; return true; } bool JS::OwningCompileOptions::setSourceMapURL(JSContext* cx, const char16_t* s) { UniqueTwoByteChars copy; if (s) { copy = DuplicateString(cx, s); if (!copy) return false; } // OwningCompileOptions always owns sourceMapURL_, so this cast is okay. js_free(const_cast<char16_t*>(sourceMapURL_)); sourceMapURL_ = copy.release(); return true; } bool JS::OwningCompileOptions::setIntroducerFilename(JSContext* cx, const char* s) { char* copy = nullptr; if (s) { copy = JS_strdup(cx, s); if (!copy) return false; } // OwningCompileOptions always owns introducerFilename_, so this cast is okay. js_free(const_cast<char*>(introducerFilename_)); introducerFilename_ = copy; return true; } JS::CompileOptions::CompileOptions(JSContext* cx, JSVersion version) : ReadOnlyCompileOptions(), elementRoot(cx), elementAttributeNameRoot(cx), introductionScriptRoot(cx) { this->version = (version != JSVERSION_UNKNOWN) ? version : cx->findVersion(); strictOption = cx->options().strictMode(); extraWarningsOption = cx->compartment()->behaviors().extraWarnings(cx); werrorOption = cx->options().werror(); if (!cx->options().asmJS()) asmJSOption = AsmJSOption::Disabled; else if (cx->compartment()->debuggerObservesAsmJS()) asmJSOption = AsmJSOption::DisabledByDebugger; else asmJSOption = AsmJSOption::Enabled; throwOnAsmJSValidationFailureOption = cx->options().throwOnAsmJSValidationFailure(); } static bool Compile(JSContext* cx, const ReadOnlyCompileOptions& options, ScopeKind scopeKind, SourceBufferHolder& srcBuf, MutableHandleScript script) { MOZ_ASSERT(scopeKind == ScopeKind::Global || scopeKind == ScopeKind::NonSyntactic); MOZ_ASSERT(!cx->runtime()->isAtomsCompartment(cx->compartment())); AssertHeapIsIdle(cx); CHECK_REQUEST(cx); script.set(frontend::CompileGlobalScript(cx, cx->tempLifoAlloc(), scopeKind, options, srcBuf)); return !!script; } static bool Compile(JSContext* cx, const ReadOnlyCompileOptions& options, ScopeKind scopeKind, const char16_t* chars, size_t length, MutableHandleScript script) { SourceBufferHolder srcBuf(chars, length, SourceBufferHolder::NoOwnership); return ::Compile(cx, options, scopeKind, srcBuf, script); } static bool Compile(JSContext* cx, const ReadOnlyCompileOptions& options, ScopeKind scopeKind, const char* bytes, size_t length, MutableHandleScript script) { UniqueTwoByteChars chars; if (options.utf8) chars.reset(UTF8CharsToNewTwoByteCharsZ(cx, UTF8Chars(bytes, length), &length).get()); else chars.reset(InflateString(cx, bytes, &length)); if (!chars) return false; return ::Compile(cx, options, scopeKind, chars.get(), length, script); } static bool Compile(JSContext* cx, const ReadOnlyCompileOptions& options, ScopeKind scopeKind, FILE* fp, MutableHandleScript script) { FileContents buffer(cx); if (!ReadCompleteFile(cx, fp, buffer)) return false; return ::Compile(cx, options, scopeKind, buffer.begin(), buffer.length(), script); } static bool Compile(JSContext* cx, const ReadOnlyCompileOptions& optionsArg, ScopeKind scopeKind, const char* filename, MutableHandleScript script) { AutoFile file; if (!file.open(cx, filename)) return false; CompileOptions options(cx, optionsArg); options.setFileAndLine(filename, 1); return ::Compile(cx, options, scopeKind, file.fp(), script); } bool JS::Compile(JSContext* cx, const ReadOnlyCompileOptions& options, SourceBufferHolder& srcBuf, JS::MutableHandleScript script) { return ::Compile(cx, options, ScopeKind::Global, srcBuf, script); } bool JS::Compile(JSContext* cx, const ReadOnlyCompileOptions& options, const char* bytes, size_t length, JS::MutableHandleScript script) { return ::Compile(cx, options, ScopeKind::Global, bytes, length, script); } bool JS::Compile(JSContext* cx, const ReadOnlyCompileOptions& options, const char16_t* chars, size_t length, JS::MutableHandleScript script) { return ::Compile(cx, options, ScopeKind::Global, chars, length, script); } bool JS::Compile(JSContext* cx, const ReadOnlyCompileOptions& options, FILE* file, JS::MutableHandleScript script) { return ::Compile(cx, options, ScopeKind::Global, file, script); } bool JS::Compile(JSContext* cx, const ReadOnlyCompileOptions& options, const char* filename, JS::MutableHandleScript script) { return ::Compile(cx, options, ScopeKind::Global, filename, script); } bool JS::CompileForNonSyntacticScope(JSContext* cx, const ReadOnlyCompileOptions& options, SourceBufferHolder& srcBuf, JS::MutableHandleScript script) { return ::Compile(cx, options, ScopeKind::NonSyntactic, srcBuf, script); } bool JS::CompileForNonSyntacticScope(JSContext* cx, const ReadOnlyCompileOptions& options, const char* bytes, size_t length, JS::MutableHandleScript script) { return ::Compile(cx, options, ScopeKind::NonSyntactic, bytes, length, script); } bool JS::CompileForNonSyntacticScope(JSContext* cx, const ReadOnlyCompileOptions& options, const char16_t* chars, size_t length, JS::MutableHandleScript script) { return ::Compile(cx, options, ScopeKind::NonSyntactic, chars, length, script); } bool JS::CompileForNonSyntacticScope(JSContext* cx, const ReadOnlyCompileOptions& options, FILE* file, JS::MutableHandleScript script) { return ::Compile(cx, options, ScopeKind::NonSyntactic, file, script); } bool JS::CompileForNonSyntacticScope(JSContext* cx, const ReadOnlyCompileOptions& options, const char* filename, JS::MutableHandleScript script) { return ::Compile(cx, options, ScopeKind::NonSyntactic, filename, script); } JS_PUBLIC_API(bool) JS::CanCompileOffThread(JSContext* cx, const ReadOnlyCompileOptions& options, size_t length) { static const size_t TINY_LENGTH = 5 * 1000; static const size_t HUGE_LENGTH = 100 * 1000; // These are heuristics which the caller may choose to ignore (e.g., for // testing purposes). if (!options.forceAsync) { // Compiling off the main thread inolves creating a new Zone and other // significant overheads. Don't bother if the script is tiny. if (length < TINY_LENGTH) return false; // If the parsing task would have to wait for GC to complete, it'll probably // be faster to just start it synchronously on the main thread unless the // script is huge. if (OffThreadParsingMustWaitForGC(cx->runtime()) && length < HUGE_LENGTH) return false; } return cx->runtime()->canUseParallelParsing() && CanUseExtraThreads(); } JS_PUBLIC_API(bool) JS::CompileOffThread(JSContext* cx, const ReadOnlyCompileOptions& options, const char16_t* chars, size_t length, OffThreadCompileCallback callback, void* callbackData) { MOZ_ASSERT(CanCompileOffThread(cx, options, length)); return StartOffThreadParseScript(cx, options, chars, length, callback, callbackData); } JS_PUBLIC_API(JSScript*) JS::FinishOffThreadScript(JSContext* cx, void* token) { MOZ_ASSERT(cx); MOZ_ASSERT(CurrentThreadCanAccessRuntime(cx)); return HelperThreadState().finishScriptParseTask(cx, token); } JS_PUBLIC_API(void) JS::CancelOffThreadScript(JSContext* cx, void* token) { MOZ_ASSERT(cx); MOZ_ASSERT(CurrentThreadCanAccessRuntime(cx)); HelperThreadState().cancelParseTask(cx, ParseTaskKind::Script, token); } JS_PUBLIC_API(bool) JS::CompileOffThreadModule(JSContext* cx, const ReadOnlyCompileOptions& options, const char16_t* chars, size_t length, OffThreadCompileCallback callback, void* callbackData) { MOZ_ASSERT(CanCompileOffThread(cx, options, length)); return StartOffThreadParseModule(cx, options, chars, length, callback, callbackData); } JS_PUBLIC_API(JSObject*) JS::FinishOffThreadModule(JSContext* cx, void* token) { MOZ_ASSERT(cx); MOZ_ASSERT(CurrentThreadCanAccessRuntime(cx)); return HelperThreadState().finishModuleParseTask(cx, token); } JS_PUBLIC_API(void) JS::CancelOffThreadModule(JSContext* cx, void* token) { MOZ_ASSERT(cx); MOZ_ASSERT(CurrentThreadCanAccessRuntime(cx)); HelperThreadState().cancelParseTask(cx, ParseTaskKind::Module, token); } JS_PUBLIC_API(bool) JS_CompileScript(JSContext* cx, const char* ascii, size_t length, const JS::CompileOptions& options, MutableHandleScript script) { return Compile(cx, options, ascii, length, script); } JS_PUBLIC_API(bool) JS_CompileUCScript(JSContext* cx, const char16_t* chars, size_t length, const JS::CompileOptions& options, MutableHandleScript script) { return Compile(cx, options, chars, length, script); } JS_PUBLIC_API(bool) JS_BufferIsCompilableUnit(JSContext* cx, HandleObject obj, const char* utf8, size_t length) { AssertHeapIsIdle(cx); CHECK_REQUEST(cx); assertSameCompartment(cx, obj); cx->clearPendingException(); char16_t* chars = JS::UTF8CharsToNewTwoByteCharsZ(cx, JS::UTF8Chars(utf8, length), &length).get(); if (!chars) return true; // Return true on any out-of-memory error or non-EOF-related syntax error, so our // caller doesn't try to collect more buffered source. bool result = true; CompileOptions options(cx); frontend::UsedNameTracker usedNames(cx); if (!usedNames.init()) return false; frontend::Parser<frontend::FullParseHandler> parser(cx, cx->tempLifoAlloc(), options, chars, length, /* foldConstants = */ true, usedNames, nullptr, nullptr); JS::WarningReporter older = JS::SetWarningReporter(cx, nullptr); if (!parser.checkOptions() || !parser.parse()) { // We ran into an error. If it was because we ran out of source, we // return false so our caller knows to try to collect more buffered // source. if (parser.isUnexpectedEOF()) result = false; cx->clearPendingException(); } JS::SetWarningReporter(cx, older); js_free(chars); return result; } JS_PUBLIC_API(JSObject*) JS_GetGlobalFromScript(JSScript* script) { MOZ_ASSERT(!script->isCachedEval()); return &script->global(); } JS_PUBLIC_API(const char*) JS_GetScriptFilename(JSScript* script) { // This is called from ThreadStackHelper which can be called from another // thread or inside a signal hander, so we need to be careful in case a // copmacting GC is currently moving things around. return script->maybeForwardedFilename(); } JS_PUBLIC_API(unsigned) JS_GetScriptBaseLineNumber(JSContext* cx, JSScript* script) { return script->lineno(); } JS_PUBLIC_API(JSScript*) JS_GetFunctionScript(JSContext* cx, HandleFunction fun) { if (fun->isNative()) return nullptr; if (fun->isInterpretedLazy()) { AutoCompartment funCompartment(cx, fun); JSScript* script = JSFunction::getOrCreateScript(cx, fun); if (!script) MOZ_CRASH(); return script; } return fun->nonLazyScript(); } /* * enclosingScope is a scope, if any (e.g. a WithScope). If the scope is the * global scope, this must be null. * * enclosingEnv is an environment to use, if it's not the global. */ static bool CompileFunction(JSContext* cx, const ReadOnlyCompileOptions& optionsArg, HandleAtom name, bool isInvalidName, SourceBufferHolder& srcBuf, uint32_t parameterListEnd, HandleObject enclosingEnv, HandleScope enclosingScope, MutableHandleFunction fun) { MOZ_ASSERT(!cx->runtime()->isAtomsCompartment(cx->compartment())); AssertHeapIsIdle(cx); CHECK_REQUEST(cx); assertSameCompartment(cx, enclosingEnv); RootedAtom funAtom(cx); fun.set(NewScriptedFunction(cx, 0, JSFunction::INTERPRETED_NORMAL, isInvalidName ? nullptr : name, /* proto = */ nullptr, gc::AllocKind::FUNCTION, TenuredObject, enclosingEnv)); if (!fun) return false; // Make sure the static scope chain matches up when we have a // non-syntactic scope. MOZ_ASSERT_IF(!IsGlobalLexicalEnvironment(enclosingEnv), enclosingScope->hasOnChain(ScopeKind::NonSyntactic)); if (!frontend::CompileStandaloneFunction(cx, fun, optionsArg, srcBuf, Some(parameterListEnd), enclosingScope)) { return false; } // When function name is not a valid identifier, the generated function // source in srcBuf doesn't have a function name. Set it here. if (isInvalidName) fun->setAtom(name); return true; } static MOZ_MUST_USE bool BuildFunctionString(const char* name, size_t nameLen, unsigned nargs, const char* const* argnames, const SourceBufferHolder& srcBuf, StringBuffer* out, uint32_t* parameterListEnd) { MOZ_ASSERT(out); MOZ_ASSERT(parameterListEnd); if (!out->ensureTwoByteChars()) return false; if (!out->append("function ")) return false; if (name) { if (!out->append(name, nameLen)) return false; } if (!out->append("(")) return false; for (unsigned i = 0; i < nargs; i++) { if (i != 0) { if (!out->append(", ")) return false; } if (!out->append(argnames[i], strlen(argnames[i]))) return false; } // Remember the position of ")". *parameterListEnd = out->length(); MOZ_ASSERT(FunctionConstructorMedialSigils[0] == ')'); if (!out->append(FunctionConstructorMedialSigils)) return false; if (!out->append(srcBuf.get(), srcBuf.length())) return false; if (!out->append(FunctionConstructorFinalBrace)) return false; return true; } JS_PUBLIC_API(bool) JS::CompileFunction(JSContext* cx, AutoObjectVector& envChain, const ReadOnlyCompileOptions& options, const char* name, unsigned nargs, const char* const* argnames, SourceBufferHolder& srcBuf, MutableHandleFunction fun) { RootedObject env(cx); RootedScope scope(cx); if (!CreateNonSyntacticEnvironmentChain(cx, envChain, &env, &scope)) return false; size_t nameLen = 0; bool isInvalidName = false; RootedAtom nameAtom(cx); if (name) { nameLen = strlen(name); nameAtom = Atomize(cx, name, nameLen); if (!nameAtom) return false; // If name is not valid identifier if (!js::frontend::IsIdentifier(name, nameLen)) isInvalidName = true; } uint32_t parameterListEnd; StringBuffer funStr(cx); if (!BuildFunctionString(isInvalidName ? nullptr : name, nameLen, nargs, argnames, srcBuf, &funStr, ¶meterListEnd)) { return false; } size_t newLen = funStr.length(); SourceBufferHolder newSrcBuf(funStr.stealChars(), newLen, SourceBufferHolder::GiveOwnership); return CompileFunction(cx, options, nameAtom, isInvalidName, newSrcBuf, parameterListEnd, env, scope, fun); } JS_PUBLIC_API(bool) JS::CompileFunction(JSContext* cx, AutoObjectVector& envChain, const ReadOnlyCompileOptions& options, const char* name, unsigned nargs, const char* const* argnames, const char16_t* chars, size_t length, MutableHandleFunction fun) { SourceBufferHolder srcBuf(chars, length, SourceBufferHolder::NoOwnership); return CompileFunction(cx, envChain, options, name, nargs, argnames, srcBuf, fun); } JS_PUBLIC_API(bool) JS::CompileFunction(JSContext* cx, AutoObjectVector& envChain, const ReadOnlyCompileOptions& options, const char* name, unsigned nargs, const char* const* argnames, const char* bytes, size_t length, MutableHandleFunction fun) { UniqueTwoByteChars chars; if (options.utf8) chars.reset(UTF8CharsToNewTwoByteCharsZ(cx, UTF8Chars(bytes, length), &length).get()); else chars.reset(InflateString(cx, bytes, &length)); if (!chars) return false; return CompileFunction(cx, envChain, options, name, nargs, argnames, chars.get(), length, fun); } JS_PUBLIC_API(JSString*) JS_DecompileScript(JSContext* cx, HandleScript script, const char* name, unsigned indent) { MOZ_ASSERT(!cx->runtime()->isAtomsCompartment(cx->compartment())); AssertHeapIsIdle(cx); CHECK_REQUEST(cx); script->ensureNonLazyCanonicalFunction(); RootedFunction fun(cx, script->functionNonDelazifying()); if (fun) return JS_DecompileFunction(cx, fun, indent); bool haveSource = script->scriptSource()->hasSourceData(); if (!haveSource && !JSScript::loadSource(cx, script->scriptSource(), &haveSource)) return nullptr; return haveSource ? JSScript::sourceData(cx, script) : NewStringCopyZ<CanGC>(cx, "[no source]"); } JS_PUBLIC_API(JSString*) JS_DecompileFunction(JSContext* cx, HandleFunction fun, unsigned indent) { MOZ_ASSERT(!cx->runtime()->isAtomsCompartment(cx->compartment())); AssertHeapIsIdle(cx); CHECK_REQUEST(cx); assertSameCompartment(cx, fun); return FunctionToString(cx, fun, !(indent & JS_DONT_PRETTY_PRINT)); } MOZ_NEVER_INLINE static bool ExecuteScript(JSContext* cx, HandleObject scope, HandleScript script, Value* rval) { MOZ_ASSERT(!cx->runtime()->isAtomsCompartment(cx->compartment())); AssertHeapIsIdle(cx); CHECK_REQUEST(cx); assertSameCompartment(cx, scope, script); MOZ_ASSERT_IF(!IsGlobalLexicalEnvironment(scope), script->hasNonSyntacticScope()); return Execute(cx, script, *scope, rval); } static bool ExecuteScript(JSContext* cx, AutoObjectVector& envChain, HandleScript scriptArg, Value* rval) { RootedObject env(cx); RootedScope dummy(cx); if (!CreateNonSyntacticEnvironmentChain(cx, envChain, &env, &dummy)) return false; RootedScript script(cx, scriptArg); if (!script->hasNonSyntacticScope() && !IsGlobalLexicalEnvironment(env)) { script = CloneGlobalScript(cx, ScopeKind::NonSyntactic, script); if (!script) return false; js::Debugger::onNewScript(cx, script); } return ExecuteScript(cx, env, script, rval); } MOZ_NEVER_INLINE JS_PUBLIC_API(bool) JS_ExecuteScript(JSContext* cx, HandleScript scriptArg, MutableHandleValue rval) { RootedObject globalLexical(cx, &cx->global()->lexicalEnvironment()); return ExecuteScript(cx, globalLexical, scriptArg, rval.address()); } MOZ_NEVER_INLINE JS_PUBLIC_API(bool) JS_ExecuteScript(JSContext* cx, HandleScript scriptArg) { RootedObject globalLexical(cx, &cx->global()->lexicalEnvironment()); return ExecuteScript(cx, globalLexical, scriptArg, nullptr); } MOZ_NEVER_INLINE JS_PUBLIC_API(bool) JS_ExecuteScript(JSContext* cx, AutoObjectVector& envChain, HandleScript scriptArg, MutableHandleValue rval) { return ExecuteScript(cx, envChain, scriptArg, rval.address()); } MOZ_NEVER_INLINE JS_PUBLIC_API(bool) JS_ExecuteScript(JSContext* cx, AutoObjectVector& envChain, HandleScript scriptArg) { return ExecuteScript(cx, envChain, scriptArg, nullptr); } JS_PUBLIC_API(bool) JS::CloneAndExecuteScript(JSContext* cx, HandleScript scriptArg, JS::MutableHandleValue rval) { CHECK_REQUEST(cx); RootedScript script(cx, scriptArg); RootedObject globalLexical(cx, &cx->global()->lexicalEnvironment()); if (script->compartment() != cx->compartment()) { script = CloneGlobalScript(cx, ScopeKind::Global, script); if (!script) return false; js::Debugger::onNewScript(cx, script); } return ExecuteScript(cx, globalLexical, script, rval.address()); } static const unsigned LARGE_SCRIPT_LENGTH = 500*1024; static bool Evaluate(JSContext* cx, ScopeKind scopeKind, HandleObject env, const ReadOnlyCompileOptions& optionsArg, SourceBufferHolder& srcBuf, MutableHandleValue rval) { CompileOptions options(cx, optionsArg); MOZ_ASSERT(!cx->runtime()->isAtomsCompartment(cx->compartment())); AssertHeapIsIdle(cx); CHECK_REQUEST(cx); assertSameCompartment(cx, env); MOZ_ASSERT_IF(!IsGlobalLexicalEnvironment(env), scopeKind == ScopeKind::NonSyntactic); options.setIsRunOnce(true); SourceCompressionTask sct(cx); RootedScript script(cx, frontend::CompileGlobalScript(cx, cx->tempLifoAlloc(), scopeKind, options, srcBuf, &sct)); if (!script) return false; MOZ_ASSERT(script->getVersion() == options.version); bool result = Execute(cx, script, *env, options.noScriptRval ? nullptr : rval.address()); if (!sct.complete()) result = false; // After evaluation, the compiled script will not be run again. // script->ensureRanAnalysis allocated 1 analyze::Bytecode for every opcode // which for large scripts means significant memory. Perform a GC eagerly // to clear out this analysis data before anything happens to inhibit the // flushing of this memory (such as setting requestAnimationFrame). if (script->length() > LARGE_SCRIPT_LENGTH) { script = nullptr; PrepareZoneForGC(cx->zone()); cx->runtime()->gc.gc(GC_NORMAL, JS::gcreason::FINISH_LARGE_EVALUATE); } return result; } static bool Evaluate(JSContext* cx, AutoObjectVector& envChain, const ReadOnlyCompileOptions& optionsArg, SourceBufferHolder& srcBuf, MutableHandleValue rval) { RootedObject env(cx); RootedScope scope(cx); if (!CreateNonSyntacticEnvironmentChain(cx, envChain, &env, &scope)) return false; return ::Evaluate(cx, scope->kind(), env, optionsArg, srcBuf, rval); } static bool Evaluate(JSContext* cx, const ReadOnlyCompileOptions& optionsArg, const char16_t* chars, size_t length, MutableHandleValue rval) { SourceBufferHolder srcBuf(chars, length, SourceBufferHolder::NoOwnership); RootedObject globalLexical(cx, &cx->global()->lexicalEnvironment()); return ::Evaluate(cx, ScopeKind::Global, globalLexical, optionsArg, srcBuf, rval); } extern JS_PUBLIC_API(bool) JS::Evaluate(JSContext* cx, const ReadOnlyCompileOptions& options, const char* bytes, size_t length, MutableHandleValue rval) { char16_t* chars; if (options.utf8) chars = UTF8CharsToNewTwoByteCharsZ(cx, JS::UTF8Chars(bytes, length), &length).get(); else chars = InflateString(cx, bytes, &length); if (!chars) return false; SourceBufferHolder srcBuf(chars, length, SourceBufferHolder::GiveOwnership); RootedObject globalLexical(cx, &cx->global()->lexicalEnvironment()); bool ok = ::Evaluate(cx, ScopeKind::Global, globalLexical, options, srcBuf, rval); return ok; } static bool Evaluate(JSContext* cx, const ReadOnlyCompileOptions& optionsArg, const char* filename, MutableHandleValue rval) { FileContents buffer(cx); { AutoFile file; if (!file.open(cx, filename) || !file.readAll(cx, buffer)) return false; } CompileOptions options(cx, optionsArg); options.setFileAndLine(filename, 1); return Evaluate(cx, options, buffer.begin(), buffer.length(), rval); } JS_PUBLIC_API(bool) JS::Evaluate(JSContext* cx, const ReadOnlyCompileOptions& optionsArg, SourceBufferHolder& srcBuf, MutableHandleValue rval) { RootedObject globalLexical(cx, &cx->global()->lexicalEnvironment()); return ::Evaluate(cx, ScopeKind::Global, globalLexical, optionsArg, srcBuf, rval); } JS_PUBLIC_API(bool) JS::Evaluate(JSContext* cx, AutoObjectVector& envChain, const ReadOnlyCompileOptions& optionsArg, SourceBufferHolder& srcBuf, MutableHandleValue rval) { return ::Evaluate(cx, envChain, optionsArg, srcBuf, rval); } JS_PUBLIC_API(bool) JS::Evaluate(JSContext* cx, const ReadOnlyCompileOptions& optionsArg, const char16_t* chars, size_t length, MutableHandleValue rval) { return ::Evaluate(cx, optionsArg, chars, length, rval); } JS_PUBLIC_API(bool) JS::Evaluate(JSContext* cx, AutoObjectVector& envChain, const ReadOnlyCompileOptions& optionsArg, const char16_t* chars, size_t length, MutableHandleValue rval) { SourceBufferHolder srcBuf(chars, length, SourceBufferHolder::NoOwnership); return ::Evaluate(cx, envChain, optionsArg, srcBuf, rval); } JS_PUBLIC_API(bool) JS::Evaluate(JSContext* cx, const ReadOnlyCompileOptions& optionsArg, const char* filename, MutableHandleValue rval) { return ::Evaluate(cx, optionsArg, filename, rval); } JS_PUBLIC_API(JSFunction*) JS::GetModuleResolveHook(JSContext* cx) { AssertHeapIsIdle(cx); CHECK_REQUEST(cx); return cx->global()->moduleResolveHook(); } JS_PUBLIC_API(void) JS::SetModuleResolveHook(JSContext* cx, HandleFunction func) { AssertHeapIsIdle(cx); CHECK_REQUEST(cx); assertSameCompartment(cx, func); cx->global()->setModuleResolveHook(func); } JS_PUBLIC_API(bool) JS::CompileModule(JSContext* cx, const ReadOnlyCompileOptions& options, SourceBufferHolder& srcBuf, JS::MutableHandleObject module) { MOZ_ASSERT(!cx->runtime()->isAtomsCompartment(cx->compartment())); AssertHeapIsIdle(cx); CHECK_REQUEST(cx); module.set(frontend::CompileModule(cx, options, srcBuf)); return !!module; } JS_PUBLIC_API(void) JS::SetModuleHostDefinedField(JSObject* module, const JS::Value& value) { module->as<ModuleObject>().setHostDefinedField(value); } JS_PUBLIC_API(JS::Value) JS::GetModuleHostDefinedField(JSObject* module) { return module->as<ModuleObject>().hostDefinedField(); } JS_PUBLIC_API(bool) JS::ModuleDeclarationInstantiation(JSContext* cx, JS::HandleObject moduleArg) { AssertHeapIsIdle(cx); CHECK_REQUEST(cx); assertSameCompartment(cx, moduleArg); return ModuleObject::DeclarationInstantiation(cx, moduleArg.as<ModuleObject>()); } JS_PUBLIC_API(bool) JS::ModuleEvaluation(JSContext* cx, JS::HandleObject moduleArg) { AssertHeapIsIdle(cx); CHECK_REQUEST(cx); assertSameCompartment(cx, moduleArg); return ModuleObject::Evaluation(cx, moduleArg.as<ModuleObject>()); } JS_PUBLIC_API(JSObject*) JS::GetRequestedModules(JSContext* cx, JS::HandleObject moduleArg) { AssertHeapIsIdle(cx); CHECK_REQUEST(cx); assertSameCompartment(cx, moduleArg); return &moduleArg->as<ModuleObject>().requestedModules(); } JS_PUBLIC_API(JSScript*) JS::GetModuleScript(JSContext* cx, JS::HandleObject moduleArg) { AssertHeapIsIdle(cx); CHECK_REQUEST(cx); assertSameCompartment(cx, moduleArg); return moduleArg->as<ModuleObject>().script(); } JS_PUBLIC_API(JSObject*) JS_New(JSContext* cx, HandleObject ctor, const JS::HandleValueArray& inputArgs) { AssertHeapIsIdle(cx); CHECK_REQUEST(cx); assertSameCompartment(cx, ctor, inputArgs); RootedValue ctorVal(cx, ObjectValue(*ctor)); if (!IsConstructor(ctorVal)) { ReportValueError(cx, JSMSG_NOT_CONSTRUCTOR, JSDVG_IGNORE_STACK, ctorVal, nullptr); return nullptr; } ConstructArgs args(cx); if (!FillArgumentsFromArraylike(cx, args, inputArgs)) return nullptr; RootedObject obj(cx); if (!js::Construct(cx, ctorVal, args, ctorVal, &obj)) return nullptr; return obj; } JS_PUBLIC_API(bool) JS_CheckForInterrupt(JSContext* cx) { return js::CheckForInterrupt(cx); } JS_PUBLIC_API(bool) JS_AddInterruptCallback(JSContext* cx, JSInterruptCallback callback) { return cx->interruptCallbacks.append(callback); } JS_PUBLIC_API(bool) JS_DisableInterruptCallback(JSContext* cx) { bool result = cx->interruptCallbackDisabled; cx->interruptCallbackDisabled = true; return result; } JS_PUBLIC_API(void) JS_ResetInterruptCallback(JSContext* cx, bool enable) { cx->interruptCallbackDisabled = enable; } /************************************************************************/ /* * Promises. */ JS_PUBLIC_API(void) JS::SetGetIncumbentGlobalCallback(JSContext* cx, JSGetIncumbentGlobalCallback callback) { cx->getIncumbentGlobalCallback = callback; } JS_PUBLIC_API(void) JS::SetEnqueuePromiseJobCallback(JSContext* cx, JSEnqueuePromiseJobCallback callback, void* data /* = nullptr */) { cx->enqueuePromiseJobCallback = callback; cx->enqueuePromiseJobCallbackData = data; } extern JS_PUBLIC_API(void) JS::SetPromiseRejectionTrackerCallback(JSContext* cx, JSPromiseRejectionTrackerCallback callback, void* data /* = nullptr */) { cx->promiseRejectionTrackerCallback = callback; cx->promiseRejectionTrackerCallbackData = data; } JS_PUBLIC_API(JSObject*) JS::NewPromiseObject(JSContext* cx, HandleObject executor, HandleObject proto /* = nullptr */) { MOZ_ASSERT(!cx->runtime()->isAtomsCompartment(cx->compartment())); MOZ_ASSERT(IsCallable(executor)); AssertHeapIsIdle(cx); CHECK_REQUEST(cx); assertSameCompartment(cx, executor, proto); return PromiseObject::create(cx, executor, proto); } JS_PUBLIC_API(bool) JS::IsPromiseObject(JS::HandleObject obj) { return obj->is<PromiseObject>(); } JS_PUBLIC_API(JSObject*) JS::GetPromiseConstructor(JSContext* cx) { CHECK_REQUEST(cx); Rooted<GlobalObject*> global(cx, cx->global()); return GlobalObject::getOrCreatePromiseConstructor(cx, global); } JS_PUBLIC_API(JSObject*) JS::GetPromisePrototype(JSContext* cx) { CHECK_REQUEST(cx); Rooted<GlobalObject*> global(cx, cx->global()); return GlobalObject::getOrCreatePromisePrototype(cx, global); } JS_PUBLIC_API(JS::PromiseState) JS::GetPromiseState(JS::HandleObject promiseObj_) { JSObject* promiseObj = CheckedUnwrap(promiseObj_); if (!promiseObj || !promiseObj->is<PromiseObject>()) return JS::PromiseState::Pending; return promiseObj->as<PromiseObject>().state(); } JS_PUBLIC_API(uint64_t) JS::GetPromiseID(JS::HandleObject promise) { return promise->as<PromiseObject>().getID(); } JS_PUBLIC_API(JS::Value) JS::GetPromiseResult(JS::HandleObject promiseObj) { PromiseObject* promise = &promiseObj->as<PromiseObject>(); MOZ_ASSERT(promise->state() != JS::PromiseState::Pending); return promise->state() == JS::PromiseState::Fulfilled ? promise->value() : promise->reason(); } JS_PUBLIC_API(JSObject*) JS::GetPromiseAllocationSite(JS::HandleObject promise) { return promise->as<PromiseObject>().allocationSite(); } JS_PUBLIC_API(JSObject*) JS::GetPromiseResolutionSite(JS::HandleObject promise) { return promise->as<PromiseObject>().resolutionSite(); } #ifdef DEBUG JS_PUBLIC_API(void) JS::DumpPromiseAllocationSite(JSContext* cx, JS::HandleObject promise) { RootedObject stack(cx, promise->as<PromiseObject>().allocationSite()); UniqueChars stackStr(reinterpret_cast<char*>(BuildUTF8StackString(cx, stack).get())); if (stackStr.get()) fputs(stackStr.get(), stderr); } JS_PUBLIC_API(void) JS::DumpPromiseResolutionSite(JSContext* cx, JS::HandleObject promise) { RootedObject stack(cx, promise->as<PromiseObject>().resolutionSite()); UniqueChars stackStr(reinterpret_cast<char*>(BuildUTF8StackString(cx, stack).get())); if (stackStr.get()) fputs(stackStr.get(), stderr); } #endif JS_PUBLIC_API(JSObject*) JS::CallOriginalPromiseResolve(JSContext* cx, JS::HandleValue resolutionValue) { AssertHeapIsIdle(cx); CHECK_REQUEST(cx); assertSameCompartment(cx, resolutionValue); RootedObject promise(cx, PromiseObject::unforgeableResolve(cx, resolutionValue)); MOZ_ASSERT_IF(promise, CheckedUnwrap(promise)->is<PromiseObject>()); return promise; } JS_PUBLIC_API(JSObject*) JS::CallOriginalPromiseReject(JSContext* cx, JS::HandleValue rejectionValue) { AssertHeapIsIdle(cx); CHECK_REQUEST(cx); assertSameCompartment(cx, rejectionValue); RootedObject promise(cx, PromiseObject::unforgeableReject(cx, rejectionValue)); MOZ_ASSERT_IF(promise, CheckedUnwrap(promise)->is<PromiseObject>()); return promise; } static bool ResolveOrRejectPromise(JSContext* cx, JS::HandleObject promiseObj, JS::HandleValue resultOrReason_, bool reject) { AssertHeapIsIdle(cx); CHECK_REQUEST(cx); assertSameCompartment(cx, promiseObj, resultOrReason_); mozilla::Maybe<AutoCompartment> ac; Rooted<PromiseObject*> promise(cx); RootedValue resultOrReason(cx, resultOrReason_); if (IsWrapper(promiseObj)) { JSObject* unwrappedPromiseObj = CheckedUnwrap(promiseObj); if (!unwrappedPromiseObj) { JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_OBJECT_ACCESS_DENIED); return false; } promise = &unwrappedPromiseObj->as<PromiseObject>(); ac.emplace(cx, promise); if (!cx->compartment()->wrap(cx, &resultOrReason)) return false; } else { promise = promiseObj.as<PromiseObject>(); } return reject ? PromiseObject::reject(cx, promise, resultOrReason) : PromiseObject::resolve(cx, promise, resultOrReason); } JS_PUBLIC_API(bool) JS::ResolvePromise(JSContext* cx, JS::HandleObject promiseObj, JS::HandleValue resolutionValue) { return ResolveOrRejectPromise(cx, promiseObj, resolutionValue, false); } JS_PUBLIC_API(bool) JS::RejectPromise(JSContext* cx, JS::HandleObject promiseObj, JS::HandleValue rejectionValue) { return ResolveOrRejectPromise(cx, promiseObj, rejectionValue, true); } static bool CallOriginalPromiseThenImpl(JSContext* cx, JS::HandleObject promiseObj, JS::HandleObject onResolvedObj_, JS::HandleObject onRejectedObj_, JS::MutableHandleObject resultObj, bool createDependent) { AssertHeapIsIdle(cx); CHECK_REQUEST(cx); assertSameCompartment(cx, promiseObj, onResolvedObj_, onRejectedObj_); MOZ_ASSERT_IF(onResolvedObj_, IsCallable(onResolvedObj_)); MOZ_ASSERT_IF(onRejectedObj_, IsCallable(onRejectedObj_)); { mozilla::Maybe<AutoCompartment> ac; Rooted<PromiseObject*> promise(cx); RootedObject onResolvedObj(cx, onResolvedObj_); RootedObject onRejectedObj(cx, onRejectedObj_); if (IsWrapper(promiseObj)) { JSObject* unwrappedPromiseObj = CheckedUnwrap(promiseObj); if (!unwrappedPromiseObj) { JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_OBJECT_ACCESS_DENIED); return false; } promise = &unwrappedPromiseObj->as<PromiseObject>(); ac.emplace(cx, promise); if (!cx->compartment()->wrap(cx, &onResolvedObj) || !cx->compartment()->wrap(cx, &onRejectedObj)) { return false; } } else { promise = promiseObj.as<PromiseObject>(); } RootedValue onFulfilled(cx, ObjectOrNullValue(onResolvedObj)); RootedValue onRejected(cx, ObjectOrNullValue(onRejectedObj)); if (!OriginalPromiseThen(cx, promise, onFulfilled, onRejected, resultObj, createDependent)) return false; } if (resultObj) { if (!cx->compartment()->wrap(cx, resultObj)) return false; } return true; } JS_PUBLIC_API(JSObject*) JS::CallOriginalPromiseThen(JSContext* cx, JS::HandleObject promiseObj, JS::HandleObject onResolvedObj, JS::HandleObject onRejectedObj) { RootedObject resultPromise(cx); if (!CallOriginalPromiseThenImpl(cx, promiseObj, onResolvedObj, onRejectedObj, &resultPromise, true)) return nullptr; return resultPromise; } JS_PUBLIC_API(bool) JS::AddPromiseReactions(JSContext* cx, JS::HandleObject promiseObj, JS::HandleObject onResolvedObj, JS::HandleObject onRejectedObj) { RootedObject resultPromise(cx); bool result = CallOriginalPromiseThenImpl(cx, promiseObj, onResolvedObj, onRejectedObj, &resultPromise, false); MOZ_ASSERT(!resultPromise); return result; } /** * Unforgeable version of Promise.all for internal use. * * Takes a dense array of Promise objects and returns a promise that's * resolved with an array of resolution values when all those promises ahve * been resolved, or rejected with the rejection value of the first rejected * promise. * * Asserts that the array is dense and all entries are Promise objects. */ JS_PUBLIC_API(JSObject*) JS::GetWaitForAllPromise(JSContext* cx, const JS::AutoObjectVector& promises) { AssertHeapIsIdle(cx); CHECK_REQUEST(cx); return js::GetWaitForAllPromise(cx, promises); } JS_PUBLIC_API(void) JS::SetAsyncTaskCallbacks(JSContext* cx, JS::StartAsyncTaskCallback start, JS::FinishAsyncTaskCallback finish) { cx->startAsyncTaskCallback = start; cx->finishAsyncTaskCallback = finish; } JS_PUBLIC_API(void) JS_RequestInterruptCallback(JSContext* cx) { cx->requestInterrupt(JSRuntime::RequestInterruptUrgent); } JS_PUBLIC_API(bool) JS_IsRunning(JSContext* cx) { return cx->currentlyRunning(); } JS::AutoSetAsyncStackForNewCalls::AutoSetAsyncStackForNewCalls( JSContext* cx, HandleObject stack, const char* asyncCause, JS::AutoSetAsyncStackForNewCalls::AsyncCallKind kind) : cx(cx), oldAsyncStack(cx, cx->asyncStackForNewActivations), oldAsyncCause(cx->asyncCauseForNewActivations), oldAsyncCallIsExplicit(cx->asyncCallIsExplicit) { CHECK_REQUEST(cx); // The option determines whether we actually use the new values at this // point. It will not affect restoring the previous values when the object // is destroyed, so if the option changes it won't cause consistency issues. if (!cx->options().asyncStack()) return; SavedFrame* asyncStack = &stack->as<SavedFrame>(); cx->asyncStackForNewActivations = asyncStack; cx->asyncCauseForNewActivations = asyncCause; cx->asyncCallIsExplicit = kind == AsyncCallKind::EXPLICIT; } JS::AutoSetAsyncStackForNewCalls::~AutoSetAsyncStackForNewCalls() { cx->asyncCauseForNewActivations = oldAsyncCause; cx->asyncStackForNewActivations = oldAsyncStack ? &oldAsyncStack->as<SavedFrame>() : nullptr; cx->asyncCallIsExplicit = oldAsyncCallIsExplicit; } /************************************************************************/ JS_PUBLIC_API(JSString*) JS_NewStringCopyN(JSContext* cx, const char* s, size_t n) { AssertHeapIsIdle(cx); CHECK_REQUEST(cx); return NewStringCopyN<CanGC>(cx, s, n); } JS_PUBLIC_API(JSString*) JS_NewStringCopyZ(JSContext* cx, const char* s) { AssertHeapIsIdle(cx); CHECK_REQUEST(cx); if (!s) return cx->runtime()->emptyString; return NewStringCopyZ<CanGC>(cx, s); } JS_PUBLIC_API(JSString*) JS_NewStringCopyUTF8Z(JSContext* cx, const JS::ConstUTF8CharsZ s) { AssertHeapIsIdle(cx); CHECK_REQUEST(cx); return NewStringCopyUTF8Z<CanGC>(cx, s); } JS_PUBLIC_API(JSString*) JS_NewStringCopyUTF8N(JSContext* cx, const JS::UTF8Chars s) { AssertHeapIsIdle(cx); CHECK_REQUEST(cx); return NewStringCopyUTF8N<CanGC>(cx, s); } JS_PUBLIC_API(bool) JS_StringHasBeenPinned(JSContext* cx, JSString* str) { AssertHeapIsIdle(cx); CHECK_REQUEST(cx); if (!str->isAtom()) return false; return AtomIsPinned(cx, &str->asAtom()); } JS_PUBLIC_API(jsid) INTERNED_STRING_TO_JSID(JSContext* cx, JSString* str) { MOZ_ASSERT(str); MOZ_ASSERT(((size_t)str & JSID_TYPE_MASK) == 0); MOZ_ASSERT_IF(cx, JS_StringHasBeenPinned(cx, str)); return AtomToId(&str->asAtom()); } JS_PUBLIC_API(JSString*) JS_AtomizeAndPinJSString(JSContext* cx, HandleString str) { AssertHeapIsIdle(cx); CHECK_REQUEST(cx); JSAtom* atom = AtomizeString(cx, str, PinAtom); MOZ_ASSERT_IF(atom, JS_StringHasBeenPinned(cx, atom)); return atom; } JS_PUBLIC_API(JSString*) JS_AtomizeString(JSContext* cx, const char* s) { return JS_AtomizeStringN(cx, s, strlen(s)); } JS_PUBLIC_API(JSString*) JS_AtomizeStringN(JSContext* cx, const char* s, size_t length) { AssertHeapIsIdle(cx); CHECK_REQUEST(cx); return Atomize(cx, s, length, DoNotPinAtom); } JS_PUBLIC_API(JSString*) JS_AtomizeAndPinString(JSContext* cx, const char* s) { return JS_AtomizeAndPinStringN(cx, s, strlen(s)); } JS_PUBLIC_API(JSString*) JS_AtomizeAndPinStringN(JSContext* cx, const char* s, size_t length) { AssertHeapIsIdle(cx); CHECK_REQUEST(cx); JSAtom* atom = Atomize(cx, s, length, PinAtom); MOZ_ASSERT_IF(atom, JS_StringHasBeenPinned(cx, atom)); return atom; } JS_PUBLIC_API(JSString*) JS_NewUCString(JSContext* cx, char16_t* chars, size_t length) { AssertHeapIsIdle(cx); CHECK_REQUEST(cx); return NewString<CanGC>(cx, chars, length); } JS_PUBLIC_API(JSString*) JS_NewUCStringCopyN(JSContext* cx, const char16_t* s, size_t n) { AssertHeapIsIdle(cx); CHECK_REQUEST(cx); if (!n) return cx->names().empty; return NewStringCopyN<CanGC>(cx, s, n); } JS_PUBLIC_API(JSString*) JS_NewUCStringCopyZ(JSContext* cx, const char16_t* s) { AssertHeapIsIdle(cx); CHECK_REQUEST(cx); if (!s) return cx->runtime()->emptyString; return NewStringCopyZ<CanGC>(cx, s); } JS_PUBLIC_API(JSString*) JS_AtomizeUCString(JSContext* cx, const char16_t* s) { return JS_AtomizeUCStringN(cx, s, js_strlen(s)); } JS_PUBLIC_API(JSString*) JS_AtomizeUCStringN(JSContext* cx, const char16_t* s, size_t length) { AssertHeapIsIdle(cx); CHECK_REQUEST(cx); return AtomizeChars(cx, s, length, DoNotPinAtom); } JS_PUBLIC_API(JSString*) JS_AtomizeAndPinUCStringN(JSContext* cx, const char16_t* s, size_t length) { AssertHeapIsIdle(cx); CHECK_REQUEST(cx); JSAtom* atom = AtomizeChars(cx, s, length, PinAtom); MOZ_ASSERT_IF(atom, JS_StringHasBeenPinned(cx, atom)); return atom; } JS_PUBLIC_API(JSString*) JS_AtomizeAndPinUCString(JSContext* cx, const char16_t* s) { return JS_AtomizeAndPinUCStringN(cx, s, js_strlen(s)); } JS_PUBLIC_API(size_t) JS_GetStringLength(JSString* str) { return str->length(); } JS_PUBLIC_API(bool) JS_StringIsFlat(JSString* str) { return str->isFlat(); } JS_PUBLIC_API(bool) JS_StringHasLatin1Chars(JSString* str) { return str->hasLatin1Chars(); } JS_PUBLIC_API(const JS::Latin1Char*) JS_GetLatin1StringCharsAndLength(JSContext* cx, const JS::AutoCheckCannotGC& nogc, JSString* str, size_t* plength) { MOZ_ASSERT(plength); AssertHeapIsIdleOrStringIsFlat(cx, str); CHECK_REQUEST(cx); assertSameCompartment(cx, str); JSLinearString* linear = str->ensureLinear(cx); if (!linear) return nullptr; *plength = linear->length(); return linear->latin1Chars(nogc); } JS_PUBLIC_API(const char16_t*) JS_GetTwoByteStringCharsAndLength(JSContext* cx, const JS::AutoCheckCannotGC& nogc, JSString* str, size_t* plength) { MOZ_ASSERT(plength); AssertHeapIsIdleOrStringIsFlat(cx, str); CHECK_REQUEST(cx); assertSameCompartment(cx, str); JSLinearString* linear = str->ensureLinear(cx); if (!linear) return nullptr; *plength = linear->length(); return linear->twoByteChars(nogc); } JS_PUBLIC_API(const char16_t*) JS_GetTwoByteExternalStringChars(JSString* str) { return str->asExternal().twoByteChars(); } JS_PUBLIC_API(bool) JS_GetStringCharAt(JSContext* cx, JSString* str, size_t index, char16_t* res) { AssertHeapIsIdleOrStringIsFlat(cx, str); CHECK_REQUEST(cx); assertSameCompartment(cx, str); JSLinearString* linear = str->ensureLinear(cx); if (!linear) return false; *res = linear->latin1OrTwoByteChar(index); return true; } JS_PUBLIC_API(char16_t) JS_GetFlatStringCharAt(JSFlatString* str, size_t index) { return str->latin1OrTwoByteChar(index); } JS_PUBLIC_API(bool) JS_CopyStringChars(JSContext* cx, mozilla::Range<char16_t> dest, JSString* str) { AssertHeapIsIdleOrStringIsFlat(cx, str); CHECK_REQUEST(cx); assertSameCompartment(cx, str); JSLinearString* linear = str->ensureLinear(cx); if (!linear) return false; MOZ_ASSERT(linear->length() <= dest.length()); CopyChars(dest.begin().get(), *linear); return true; } JS_PUBLIC_API(const Latin1Char*) JS_GetLatin1InternedStringChars(const JS::AutoCheckCannotGC& nogc, JSString* str) { MOZ_ASSERT(str->isAtom()); JSFlatString* flat = str->ensureFlat(nullptr); if (!flat) return nullptr; return flat->latin1Chars(nogc); } JS_PUBLIC_API(const char16_t*) JS_GetTwoByteInternedStringChars(const JS::AutoCheckCannotGC& nogc, JSString* str) { MOZ_ASSERT(str->isAtom()); JSFlatString* flat = str->ensureFlat(nullptr); if (!flat) return nullptr; return flat->twoByteChars(nogc); } extern JS_PUBLIC_API(JSFlatString*) JS_FlattenString(JSContext* cx, JSString* str) { AssertHeapIsIdle(cx); CHECK_REQUEST(cx); assertSameCompartment(cx, str); JSFlatString* flat = str->ensureFlat(cx); if (!flat) return nullptr; return flat; } extern JS_PUBLIC_API(const Latin1Char*) JS_GetLatin1FlatStringChars(const JS::AutoCheckCannotGC& nogc, JSFlatString* str) { return str->latin1Chars(nogc); } extern JS_PUBLIC_API(const char16_t*) JS_GetTwoByteFlatStringChars(const JS::AutoCheckCannotGC& nogc, JSFlatString* str) { return str->twoByteChars(nogc); } JS_PUBLIC_API(bool) JS_CompareStrings(JSContext* cx, JSString* str1, JSString* str2, int32_t* result) { AssertHeapIsIdle(cx); CHECK_REQUEST(cx); return CompareStrings(cx, str1, str2, result); } JS_PUBLIC_API(bool) JS_StringEqualsAscii(JSContext* cx, JSString* str, const char* asciiBytes, bool* match) { AssertHeapIsIdle(cx); CHECK_REQUEST(cx); JSLinearString* linearStr = str->ensureLinear(cx); if (!linearStr) return false; *match = StringEqualsAscii(linearStr, asciiBytes); return true; } JS_PUBLIC_API(bool) JS_FlatStringEqualsAscii(JSFlatString* str, const char* asciiBytes) { return StringEqualsAscii(str, asciiBytes); } JS_PUBLIC_API(size_t) JS_PutEscapedFlatString(char* buffer, size_t size, JSFlatString* str, char quote) { return PutEscapedString(buffer, size, str, quote); } JS_PUBLIC_API(size_t) JS_PutEscapedString(JSContext* cx, char* buffer, size_t size, JSString* str, char quote) { AssertHeapIsIdle(cx); JSLinearString* linearStr = str->ensureLinear(cx); if (!linearStr) return size_t(-1); return PutEscapedString(buffer, size, linearStr, quote); } JS_PUBLIC_API(bool) JS_FileEscapedString(FILE* fp, JSString* str, char quote) { JSLinearString* linearStr = str->ensureLinear(nullptr); return linearStr && FileEscapedString(fp, linearStr, quote); } JS_PUBLIC_API(JSString*) JS_NewDependentString(JSContext* cx, HandleString str, size_t start, size_t length) { AssertHeapIsIdle(cx); CHECK_REQUEST(cx); return NewDependentString(cx, str, start, length); } JS_PUBLIC_API(JSString*) JS_ConcatStrings(JSContext* cx, HandleString left, HandleString right) { AssertHeapIsIdle(cx); CHECK_REQUEST(cx); return ConcatStrings<CanGC>(cx, left, right); } JS_PUBLIC_API(bool) JS_DecodeBytes(JSContext* cx, const char* src, size_t srclen, char16_t* dst, size_t* dstlenp) { AssertHeapIsIdle(cx); CHECK_REQUEST(cx); if (!dst) { *dstlenp = srclen; return true; } size_t dstlen = *dstlenp; if (srclen > dstlen) { CopyAndInflateChars(dst, src, dstlen); AutoSuppressGC suppress(cx); JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_BUFFER_TOO_SMALL); return false; } CopyAndInflateChars(dst, src, srclen); *dstlenp = srclen; return true; } static char* EncodeLatin1(ExclusiveContext* cx, JSString* str) { JSLinearString* linear = str->ensureLinear(cx); if (!linear) return nullptr; JS::AutoCheckCannotGC nogc; if (linear->hasTwoByteChars()) return JS::LossyTwoByteCharsToNewLatin1CharsZ(cx, linear->twoByteRange(nogc)).c_str(); size_t len = str->length(); Latin1Char* buf = cx->pod_malloc<Latin1Char>(len + 1); if (!buf) { ReportOutOfMemory(cx); return nullptr; } mozilla::PodCopy(buf, linear->latin1Chars(nogc), len); buf[len] = '\0'; return reinterpret_cast<char*>(buf); } JS_PUBLIC_API(char*) JS_EncodeString(JSContext* cx, JSString* str) { AssertHeapIsIdle(cx); CHECK_REQUEST(cx); return EncodeLatin1(cx, str); } JS_PUBLIC_API(char*) JS_EncodeStringToUTF8(JSContext* cx, HandleString str) { AssertHeapIsIdle(cx); CHECK_REQUEST(cx); return StringToNewUTF8CharsZ(cx, *str).release(); } JS_PUBLIC_API(size_t) JS_GetStringEncodingLength(JSContext* cx, JSString* str) { AssertHeapIsIdle(cx); CHECK_REQUEST(cx); if (!str->ensureLinear(cx)) return size_t(-1); return str->length(); } JS_PUBLIC_API(size_t) JS_EncodeStringToBuffer(JSContext* cx, JSString* str, char* buffer, size_t length) { AssertHeapIsIdle(cx); CHECK_REQUEST(cx); /* * FIXME bug 612141 - fix DeflateStringToBuffer interface so the result * would allow to distinguish between insufficient buffer and encoding * error. */ size_t writtenLength = length; JSLinearString* linear = str->ensureLinear(cx); if (!linear) return size_t(-1); bool res; if (linear->hasLatin1Chars()) { JS::AutoCheckCannotGC nogc; res = DeflateStringToBuffer(nullptr, linear->latin1Chars(nogc), linear->length(), buffer, &writtenLength); } else { JS::AutoCheckCannotGC nogc; res = DeflateStringToBuffer(nullptr, linear->twoByteChars(nogc), linear->length(), buffer, &writtenLength); } if (res) { MOZ_ASSERT(writtenLength <= length); return writtenLength; } MOZ_ASSERT(writtenLength <= length); size_t necessaryLength = str->length(); if (necessaryLength == size_t(-1)) return size_t(-1); MOZ_ASSERT(writtenLength == length); // C strings are NOT encoded. return necessaryLength; } JS_PUBLIC_API(JS::Symbol*) JS::NewSymbol(JSContext* cx, HandleString description) { AssertHeapIsIdle(cx); CHECK_REQUEST(cx); if (description) assertSameCompartment(cx, description); return Symbol::new_(cx, SymbolCode::UniqueSymbol, description); } JS_PUBLIC_API(JS::Symbol*) JS::GetSymbolFor(JSContext* cx, HandleString key) { AssertHeapIsIdle(cx); CHECK_REQUEST(cx); assertSameCompartment(cx, key); return Symbol::for_(cx, key); } JS_PUBLIC_API(JSString*) JS::GetSymbolDescription(HandleSymbol symbol) { return symbol->description(); } JS_PUBLIC_API(JS::SymbolCode) JS::GetSymbolCode(Handle<Symbol*> symbol) { return symbol->code(); } JS_PUBLIC_API(JS::Symbol*) JS::GetWellKnownSymbol(JSContext* cx, JS::SymbolCode which) { return cx->wellKnownSymbols().get(uint32_t(which)); } #ifdef DEBUG static bool PropertySpecNameIsDigits(const char* s) { if (JS::PropertySpecNameIsSymbol(s)) return false; if (!*s) return false; for (; *s; s++) { if (*s < '0' || *s > '9') return false; } return true; } #endif // DEBUG JS_PUBLIC_API(bool) JS::PropertySpecNameEqualsId(const char* name, HandleId id) { if (JS::PropertySpecNameIsSymbol(name)) { if (!JSID_IS_SYMBOL(id)) return false; Symbol* sym = JSID_TO_SYMBOL(id); return sym->isWellKnownSymbol() && sym->code() == PropertySpecNameToSymbolCode(name); } MOZ_ASSERT(!PropertySpecNameIsDigits(name)); return JSID_IS_ATOM(id) && JS_FlatStringEqualsAscii(JSID_TO_ATOM(id), name); } JS_PUBLIC_API(bool) JS_Stringify(JSContext* cx, MutableHandleValue vp, HandleObject replacer, HandleValue space, JSONWriteCallback callback, void* data) { AssertHeapIsIdle(cx); CHECK_REQUEST(cx); assertSameCompartment(cx, replacer, space); StringBuffer sb(cx); if (!sb.ensureTwoByteChars()) return false; if (!Stringify(cx, vp, replacer, space, sb, StringifyBehavior::Normal)) return false; if (sb.empty() && !sb.append(cx->names().null)) return false; return callback(sb.rawTwoByteBegin(), sb.length(), data); } JS_PUBLIC_API(bool) JS::ToJSONMaybeSafely(JSContext* cx, JS::HandleObject input, JSONWriteCallback callback, void* data) { AssertHeapIsIdle(cx); CHECK_REQUEST(cx); assertSameCompartment(cx, input); StringBuffer sb(cx); if (!sb.ensureTwoByteChars()) return false; RootedValue inputValue(cx, ObjectValue(*input)); if (!Stringify(cx, &inputValue, nullptr, NullHandleValue, sb, StringifyBehavior::RestrictedSafe)) return false; if (sb.empty() && !sb.append(cx->names().null)) return false; return callback(sb.rawTwoByteBegin(), sb.length(), data); } JS_PUBLIC_API(bool) JS_ParseJSON(JSContext* cx, const char16_t* chars, uint32_t len, MutableHandleValue vp) { AssertHeapIsIdle(cx); CHECK_REQUEST(cx); return ParseJSONWithReviver(cx, mozilla::Range<const char16_t>(chars, len), NullHandleValue, vp); } JS_PUBLIC_API(bool) JS_ParseJSON(JSContext* cx, HandleString str, MutableHandleValue vp) { return JS_ParseJSONWithReviver(cx, str, NullHandleValue, vp); } JS_PUBLIC_API(bool) JS_ParseJSONWithReviver(JSContext* cx, const char16_t* chars, uint32_t len, HandleValue reviver, MutableHandleValue vp) { AssertHeapIsIdle(cx); CHECK_REQUEST(cx); return ParseJSONWithReviver(cx, mozilla::Range<const char16_t>(chars, len), reviver, vp); } JS_PUBLIC_API(bool) JS_ParseJSONWithReviver(JSContext* cx, HandleString str, HandleValue reviver, MutableHandleValue vp) { AssertHeapIsIdle(cx); CHECK_REQUEST(cx); assertSameCompartment(cx, str); AutoStableStringChars stableChars(cx); if (!stableChars.init(cx, str)) return false; return stableChars.isLatin1() ? ParseJSONWithReviver(cx, stableChars.latin1Range(), reviver, vp) : ParseJSONWithReviver(cx, stableChars.twoByteRange(), reviver, vp); } /************************************************************************/ JS_PUBLIC_API(void) JS_ReportErrorASCII(JSContext* cx, const char* format, ...) { va_list ap; AssertHeapIsIdle(cx); va_start(ap, format); ReportErrorVA(cx, JSREPORT_ERROR, format, ArgumentsAreASCII, ap); va_end(ap); } JS_PUBLIC_API(void) JS_ReportErrorLatin1(JSContext* cx, const char* format, ...) { va_list ap; AssertHeapIsIdle(cx); va_start(ap, format); ReportErrorVA(cx, JSREPORT_ERROR, format, ArgumentsAreLatin1, ap); va_end(ap); } JS_PUBLIC_API(void) JS_ReportErrorUTF8(JSContext* cx, const char* format, ...) { va_list ap; AssertHeapIsIdle(cx); va_start(ap, format); ReportErrorVA(cx, JSREPORT_ERROR, format, ArgumentsAreUTF8, ap); va_end(ap); } JS_PUBLIC_API(void) JS_ReportErrorNumberASCII(JSContext* cx, JSErrorCallback errorCallback, void* userRef, const unsigned errorNumber, ...) { va_list ap; va_start(ap, errorNumber); JS_ReportErrorNumberASCIIVA(cx, errorCallback, userRef, errorNumber, ap); va_end(ap); } JS_PUBLIC_API(void) JS_ReportErrorNumberASCIIVA(JSContext* cx, JSErrorCallback errorCallback, void* userRef, const unsigned errorNumber, va_list ap) { AssertHeapIsIdle(cx); ReportErrorNumberVA(cx, JSREPORT_ERROR, errorCallback, userRef, errorNumber, ArgumentsAreASCII, ap); } JS_PUBLIC_API(void) JS_ReportErrorNumberLatin1(JSContext* cx, JSErrorCallback errorCallback, void* userRef, const unsigned errorNumber, ...) { va_list ap; va_start(ap, errorNumber); JS_ReportErrorNumberLatin1VA(cx, errorCallback, userRef, errorNumber, ap); va_end(ap); } JS_PUBLIC_API(void) JS_ReportErrorNumberLatin1VA(JSContext* cx, JSErrorCallback errorCallback, void* userRef, const unsigned errorNumber, va_list ap) { AssertHeapIsIdle(cx); ReportErrorNumberVA(cx, JSREPORT_ERROR, errorCallback, userRef, errorNumber, ArgumentsAreLatin1, ap); } JS_PUBLIC_API(void) JS_ReportErrorNumberUTF8(JSContext* cx, JSErrorCallback errorCallback, void* userRef, const unsigned errorNumber, ...) { va_list ap; va_start(ap, errorNumber); JS_ReportErrorNumberUTF8VA(cx, errorCallback, userRef, errorNumber, ap); va_end(ap); } JS_PUBLIC_API(void) JS_ReportErrorNumberUTF8VA(JSContext* cx, JSErrorCallback errorCallback, void* userRef, const unsigned errorNumber, va_list ap) { AssertHeapIsIdle(cx); ReportErrorNumberVA(cx, JSREPORT_ERROR, errorCallback, userRef, errorNumber, ArgumentsAreUTF8, ap); } JS_PUBLIC_API(void) JS_ReportErrorNumberUC(JSContext* cx, JSErrorCallback errorCallback, void* userRef, const unsigned errorNumber, ...) { va_list ap; AssertHeapIsIdle(cx); va_start(ap, errorNumber); ReportErrorNumberVA(cx, JSREPORT_ERROR, errorCallback, userRef, errorNumber, ArgumentsAreUnicode, ap); va_end(ap); } JS_PUBLIC_API(void) JS_ReportErrorNumberUCArray(JSContext* cx, JSErrorCallback errorCallback, void* userRef, const unsigned errorNumber, const char16_t** args) { AssertHeapIsIdle(cx); ReportErrorNumberUCArray(cx, JSREPORT_ERROR, errorCallback, userRef, errorNumber, args); } JS_PUBLIC_API(bool) JS_ReportWarningASCII(JSContext* cx, const char* format, ...) { va_list ap; bool ok; AssertHeapIsIdle(cx); va_start(ap, format); ok = ReportErrorVA(cx, JSREPORT_WARNING, format, ArgumentsAreASCII, ap); va_end(ap); return ok; } JS_PUBLIC_API(bool) JS_ReportWarningLatin1(JSContext* cx, const char* format, ...) { va_list ap; bool ok; AssertHeapIsIdle(cx); va_start(ap, format); ok = ReportErrorVA(cx, JSREPORT_WARNING, format, ArgumentsAreLatin1, ap); va_end(ap); return ok; } JS_PUBLIC_API(bool) JS_ReportWarningUTF8(JSContext* cx, const char* format, ...) { va_list ap; bool ok; AssertHeapIsIdle(cx); va_start(ap, format); ok = ReportErrorVA(cx, JSREPORT_WARNING, format, ArgumentsAreUTF8, ap); va_end(ap); return ok; } JS_PUBLIC_API(bool) JS_ReportErrorFlagsAndNumberASCII(JSContext* cx, unsigned flags, JSErrorCallback errorCallback, void* userRef, const unsigned errorNumber, ...) { va_list ap; bool ok; AssertHeapIsIdle(cx); va_start(ap, errorNumber); ok = ReportErrorNumberVA(cx, flags, errorCallback, userRef, errorNumber, ArgumentsAreASCII, ap); va_end(ap); return ok; } JS_PUBLIC_API(bool) JS_ReportErrorFlagsAndNumberLatin1(JSContext* cx, unsigned flags, JSErrorCallback errorCallback, void* userRef, const unsigned errorNumber, ...) { va_list ap; bool ok; AssertHeapIsIdle(cx); va_start(ap, errorNumber); ok = ReportErrorNumberVA(cx, flags, errorCallback, userRef, errorNumber, ArgumentsAreLatin1, ap); va_end(ap); return ok; } JS_PUBLIC_API(bool) JS_ReportErrorFlagsAndNumberUTF8(JSContext* cx, unsigned flags, JSErrorCallback errorCallback, void* userRef, const unsigned errorNumber, ...) { va_list ap; bool ok; AssertHeapIsIdle(cx); va_start(ap, errorNumber); ok = ReportErrorNumberVA(cx, flags, errorCallback, userRef, errorNumber, ArgumentsAreUTF8, ap); va_end(ap); return ok; } JS_PUBLIC_API(bool) JS_ReportErrorFlagsAndNumberUC(JSContext* cx, unsigned flags, JSErrorCallback errorCallback, void* userRef, const unsigned errorNumber, ...) { va_list ap; bool ok; AssertHeapIsIdle(cx); va_start(ap, errorNumber); ok = ReportErrorNumberVA(cx, flags, errorCallback, userRef, errorNumber, ArgumentsAreUnicode, ap); va_end(ap); return ok; } JS_PUBLIC_API(void) JS_ReportOutOfMemory(JSContext* cx) { ReportOutOfMemory(cx); } JS_PUBLIC_API(void) JS_ReportAllocationOverflow(JSContext* cx) { ReportAllocationOverflow(cx); } JS_PUBLIC_API(JS::WarningReporter) JS::GetWarningReporter(JSContext* cx) { return cx->warningReporter; } JS_PUBLIC_API(JS::WarningReporter) JS::SetWarningReporter(JSContext* cx, JS::WarningReporter reporter) { WarningReporter older = cx->warningReporter; cx->warningReporter = reporter; return older; } /************************************************************************/ /* * Dates. */ JS_PUBLIC_API(JSObject*) JS_NewDateObject(JSContext* cx, int year, int mon, int mday, int hour, int min, int sec) { AssertHeapIsIdle(cx); CHECK_REQUEST(cx); return NewDateObject(cx, year, mon, mday, hour, min, sec); } JS_PUBLIC_API(JSObject*) JS::NewDateObject(JSContext* cx, JS::ClippedTime time) { AssertHeapIsIdle(cx); CHECK_REQUEST(cx); return NewDateObjectMsec(cx, time); } JS_PUBLIC_API(bool) JS_ObjectIsDate(JSContext* cx, HandleObject obj, bool* isDate) { assertSameCompartment(cx, obj); ESClass cls; if (!GetBuiltinClass(cx, obj, &cls)) return false; *isDate = cls == ESClass::Date; return true; } /************************************************************************/ /* * Regular Expressions. */ JS_PUBLIC_API(JSObject*) JS_NewRegExpObject(JSContext* cx, const char* bytes, size_t length, unsigned flags) { AssertHeapIsIdle(cx); CHECK_REQUEST(cx); ScopedJSFreePtr<char16_t> chars(InflateString(cx, bytes, &length)); if (!chars) return nullptr; RegExpObject* reobj = RegExpObject::create(cx, chars, length, RegExpFlag(flags), nullptr, cx->tempLifoAlloc()); return reobj; } JS_PUBLIC_API(JSObject*) JS_NewUCRegExpObject(JSContext* cx, const char16_t* chars, size_t length, unsigned flags) { AssertHeapIsIdle(cx); CHECK_REQUEST(cx); return RegExpObject::create(cx, chars, length, RegExpFlag(flags), nullptr, cx->tempLifoAlloc()); } JS_PUBLIC_API(bool) JS_SetRegExpInput(JSContext* cx, HandleObject obj, HandleString input) { AssertHeapIsIdle(cx); CHECK_REQUEST(cx); assertSameCompartment(cx, input); Handle<GlobalObject*> global = obj.as<GlobalObject>(); RegExpStatics* res = GlobalObject::getRegExpStatics(cx, global); if (!res) return false; res->reset(cx, input); return true; } JS_PUBLIC_API(bool) JS_ClearRegExpStatics(JSContext* cx, HandleObject obj) { AssertHeapIsIdle(cx); CHECK_REQUEST(cx); MOZ_ASSERT(obj); Handle<GlobalObject*> global = obj.as<GlobalObject>(); RegExpStatics* res = GlobalObject::getRegExpStatics(cx, global); if (!res) return false; res->clear(); return true; } JS_PUBLIC_API(bool) JS_ExecuteRegExp(JSContext* cx, HandleObject obj, HandleObject reobj, char16_t* chars, size_t length, size_t* indexp, bool test, MutableHandleValue rval) { AssertHeapIsIdle(cx); CHECK_REQUEST(cx); Handle<GlobalObject*> global = obj.as<GlobalObject>(); RegExpStatics* res = GlobalObject::getRegExpStatics(cx, global); if (!res) return false; RootedLinearString input(cx, NewStringCopyN<CanGC>(cx, chars, length)); if (!input) return false; return ExecuteRegExpLegacy(cx, res, reobj.as<RegExpObject>(), input, indexp, test, rval); } JS_PUBLIC_API(bool) JS_ExecuteRegExpNoStatics(JSContext* cx, HandleObject obj, char16_t* chars, size_t length, size_t* indexp, bool test, MutableHandleValue rval) { AssertHeapIsIdle(cx); CHECK_REQUEST(cx); RootedLinearString input(cx, NewStringCopyN<CanGC>(cx, chars, length)); if (!input) return false; return ExecuteRegExpLegacy(cx, nullptr, obj.as<RegExpObject>(), input, indexp, test, rval); } JS_PUBLIC_API(bool) JS_ObjectIsRegExp(JSContext* cx, HandleObject obj, bool* isRegExp) { assertSameCompartment(cx, obj); ESClass cls; if (!GetBuiltinClass(cx, obj, &cls)) return false; *isRegExp = cls == ESClass::RegExp; return true; } JS_PUBLIC_API(unsigned) JS_GetRegExpFlags(JSContext* cx, HandleObject obj) { AssertHeapIsIdle(cx); CHECK_REQUEST(cx); RegExpGuard shared(cx); if (!RegExpToShared(cx, obj, &shared)) return false; return shared.re()->getFlags(); } JS_PUBLIC_API(JSString*) JS_GetRegExpSource(JSContext* cx, HandleObject obj) { AssertHeapIsIdle(cx); CHECK_REQUEST(cx); RegExpGuard shared(cx); if (!RegExpToShared(cx, obj, &shared)) return nullptr; return shared.re()->getSource(); } /************************************************************************/ JS_PUBLIC_API(bool) JS_SetDefaultLocale(JSContext* cx, const char* locale) { AssertHeapIsIdle(cx); return cx->setDefaultLocale(locale); } JS_PUBLIC_API(UniqueChars) JS_GetDefaultLocale(JSContext* cx) { AssertHeapIsIdle(cx); if (const char* locale = cx->getDefaultLocale()) return UniqueChars(JS_strdup(cx, locale)); return nullptr; } JS_PUBLIC_API(void) JS_ResetDefaultLocale(JSContext* cx) { AssertHeapIsIdle(cx); cx->resetDefaultLocale(); } JS_PUBLIC_API(void) JS_SetLocaleCallbacks(JSContext* cx, const JSLocaleCallbacks* callbacks) { AssertHeapIsIdle(cx); cx->localeCallbacks = callbacks; } JS_PUBLIC_API(const JSLocaleCallbacks*) JS_GetLocaleCallbacks(JSContext* cx) { /* This function can be called by a finalizer. */ return cx->localeCallbacks; } /************************************************************************/ JS_PUBLIC_API(bool) JS_IsExceptionPending(JSContext* cx) { /* This function can be called by a finalizer. */ return (bool) cx->isExceptionPending(); } JS_PUBLIC_API(bool) JS_GetPendingException(JSContext* cx, MutableHandleValue vp) { AssertHeapIsIdle(cx); CHECK_REQUEST(cx); if (!cx->isExceptionPending()) return false; return cx->getPendingException(vp); } JS_PUBLIC_API(void) JS_SetPendingException(JSContext* cx, HandleValue value) { AssertHeapIsIdle(cx); CHECK_REQUEST(cx); assertSameCompartment(cx, value); cx->setPendingException(value); } JS_PUBLIC_API(void) JS_ClearPendingException(JSContext* cx) { AssertHeapIsIdle(cx); cx->clearPendingException(); } JS::AutoSaveExceptionState::AutoSaveExceptionState(JSContext* cx) : context(cx), wasPropagatingForcedReturn(cx->propagatingForcedReturn_), wasOverRecursed(cx->overRecursed_), wasThrowing(cx->throwing), exceptionValue(cx) { AssertHeapIsIdle(cx); CHECK_REQUEST(cx); if (wasPropagatingForcedReturn) cx->clearPropagatingForcedReturn(); if (wasOverRecursed) cx->overRecursed_ = false; if (wasThrowing) { exceptionValue = cx->unwrappedException_; cx->clearPendingException(); } } void JS::AutoSaveExceptionState::restore() { context->propagatingForcedReturn_ = wasPropagatingForcedReturn; context->overRecursed_ = wasOverRecursed; context->throwing = wasThrowing; context->unwrappedException_ = exceptionValue; drop(); } JS::AutoSaveExceptionState::~AutoSaveExceptionState() { if (!context->isExceptionPending()) { if (wasPropagatingForcedReturn) context->setPropagatingForcedReturn(); if (wasThrowing) { context->overRecursed_ = wasOverRecursed; context->throwing = true; context->unwrappedException_ = exceptionValue; } } } struct JSExceptionState { explicit JSExceptionState(JSContext* cx) : exception(cx) {} bool throwing; PersistentRootedValue exception; }; JS_PUBLIC_API(JSExceptionState*) JS_SaveExceptionState(JSContext* cx) { JSExceptionState* state; AssertHeapIsIdle(cx); CHECK_REQUEST(cx); state = cx->new_<JSExceptionState>(cx); if (state) state->throwing = JS_GetPendingException(cx, &state->exception); return state; } JS_PUBLIC_API(void) JS_RestoreExceptionState(JSContext* cx, JSExceptionState* state) { AssertHeapIsIdle(cx); CHECK_REQUEST(cx); if (state) { if (state->throwing) JS_SetPendingException(cx, state->exception); else JS_ClearPendingException(cx); JS_DropExceptionState(cx, state); } } JS_PUBLIC_API(void) JS_DropExceptionState(JSContext* cx, JSExceptionState* state) { AssertHeapIsIdle(cx); CHECK_REQUEST(cx); js_delete(state); } JS_PUBLIC_API(JSErrorReport*) JS_ErrorFromException(JSContext* cx, HandleObject obj) { AssertHeapIsIdle(cx); CHECK_REQUEST(cx); assertSameCompartment(cx, obj); return ErrorFromException(cx, obj); } void JSErrorReport::initBorrowedLinebuf(const char16_t* linebufArg, size_t linebufLengthArg, size_t tokenOffsetArg) { MOZ_ASSERT(linebufArg); MOZ_ASSERT(tokenOffsetArg <= linebufLengthArg); MOZ_ASSERT(linebufArg[linebufLengthArg] == '\0'); linebuf_ = linebufArg; linebufLength_ = linebufLengthArg; tokenOffset_ = tokenOffsetArg; } void JSErrorReport::freeLinebuf() { if (ownsLinebuf_ && linebuf_) { js_free((void*)linebuf_); ownsLinebuf_ = false; } linebuf_ = nullptr; } JSString* JSErrorBase::newMessageString(JSContext* cx) { if (!message_) return cx->runtime()->emptyString; return JS_NewStringCopyUTF8Z(cx, message_); } void JSErrorBase::freeMessage() { if (ownsMessage_) { js_free((void*)message_.get()); ownsMessage_ = false; } message_ = JS::ConstUTF8CharsZ(); } JSErrorNotes::JSErrorNotes() : notes_() {} JSErrorNotes::~JSErrorNotes() { } static UniquePtr<JSErrorNotes::Note> CreateErrorNoteVA(ExclusiveContext* cx, const char* filename, unsigned lineno, unsigned column, JSErrorCallback errorCallback, void* userRef, const unsigned errorNumber, ErrorArgumentsType argumentsType, va_list ap) { auto note = MakeUnique<JSErrorNotes::Note>(); if (!note) return nullptr; note->errorNumber = errorNumber; note->filename = filename; note->lineno = lineno; note->column = column; if (!ExpandErrorArgumentsVA(cx, errorCallback, userRef, errorNumber, nullptr, argumentsType, note.get(), ap)) { return nullptr; } return note; } bool JSErrorNotes::addNoteASCII(ExclusiveContext* cx, const char* filename, unsigned lineno, unsigned column, JSErrorCallback errorCallback, void* userRef, const unsigned errorNumber, ...) { va_list ap; va_start(ap, errorNumber); auto note = CreateErrorNoteVA(cx, filename, lineno, column, errorCallback, userRef, errorNumber, ArgumentsAreASCII, ap); va_end(ap); if (!note) return false; if (!notes_.append(Move(note))) return false; return true; } bool JSErrorNotes::addNoteLatin1(ExclusiveContext* cx, const char* filename, unsigned lineno, unsigned column, JSErrorCallback errorCallback, void* userRef, const unsigned errorNumber, ...) { va_list ap; va_start(ap, errorNumber); auto note = CreateErrorNoteVA(cx, filename, lineno, column, errorCallback, userRef, errorNumber, ArgumentsAreLatin1, ap); va_end(ap); if (!note) return false; if (!notes_.append(Move(note))) return false; return true; } bool JSErrorNotes::addNoteUTF8(ExclusiveContext* cx, const char* filename, unsigned lineno, unsigned column, JSErrorCallback errorCallback, void* userRef, const unsigned errorNumber, ...) { va_list ap; va_start(ap, errorNumber); auto note = CreateErrorNoteVA(cx, filename, lineno, column, errorCallback, userRef, errorNumber, ArgumentsAreUTF8, ap); va_end(ap); if (!note) return false; if (!notes_.append(Move(note))) return false; return true; } size_t JSErrorNotes::length() { return notes_.length(); } UniquePtr<JSErrorNotes> JSErrorNotes::copy(JSContext* cx) { auto copiedNotes = MakeUnique<JSErrorNotes>(); if (!copiedNotes) return nullptr; for (auto&& note : *this) { js::UniquePtr<JSErrorNotes::Note> copied(CopyErrorNote(cx, note.get())); if (!copied) return nullptr; if (!copiedNotes->notes_.append(Move(copied))) return nullptr; } return copiedNotes; } JSErrorNotes::iterator JSErrorNotes::begin() { return iterator(notes_.begin()); } JSErrorNotes::iterator JSErrorNotes::end() { return iterator(notes_.end()); } JS_PUBLIC_API(bool) JS_ThrowStopIteration(JSContext* cx) { AssertHeapIsIdle(cx); return ThrowStopIteration(cx); } JS_PUBLIC_API(bool) JS_IsStopIteration(const Value& v) { return v.isObject() && v.toObject().is<StopIterationObject>(); } extern MOZ_NEVER_INLINE JS_PUBLIC_API(void) JS_AbortIfWrongThread(JSContext* cx) { if (!CurrentThreadCanAccessRuntime(cx)) MOZ_CRASH(); if (!js::TlsPerThreadData.get()->associatedWith(cx)) MOZ_CRASH(); } JS_PUBLIC_API(void) JS_SetParallelParsingEnabled(JSContext* cx, bool enabled) { cx->setParallelParsingEnabled(enabled); } JS_PUBLIC_API(void) JS_SetOffthreadIonCompilationEnabled(JSContext* cx, bool enabled) { cx->setOffthreadIonCompilationEnabled(enabled); } JS_PUBLIC_API(void) JS_SetGlobalJitCompilerOption(JSContext* cx, JSJitCompilerOption opt, uint32_t value) { JSRuntime* rt = cx->runtime(); switch (opt) { case JSJITCOMPILER_BASELINE_WARMUP_TRIGGER: if (value == uint32_t(-1)) { jit::DefaultJitOptions defaultValues; value = defaultValues.baselineWarmUpThreshold; } jit::JitOptions.baselineWarmUpThreshold = value; break; case JSJITCOMPILER_ION_WARMUP_TRIGGER: if (value == uint32_t(-1)) { jit::JitOptions.resetCompilerWarmUpThreshold(); break; } jit::JitOptions.setCompilerWarmUpThreshold(value); if (value == 0) jit::JitOptions.setEagerCompilation(); break; case JSJITCOMPILER_ION_GVN_ENABLE: if (value == 0) { jit::JitOptions.enableGvn(false); JitSpew(js::jit::JitSpew_IonScripts, "Disable ion's GVN"); } else { jit::JitOptions.enableGvn(true); JitSpew(js::jit::JitSpew_IonScripts, "Enable ion's GVN"); } break; case JSJITCOMPILER_ION_FORCE_IC: if (value == 0) { jit::JitOptions.forceInlineCaches = false; JitSpew(js::jit::JitSpew_IonScripts, "IonBuilder: Enable non-IC optimizations."); } else { jit::JitOptions.forceInlineCaches = true; JitSpew(js::jit::JitSpew_IonScripts, "IonBuilder: Disable non-IC optimizations."); } break; case JSJITCOMPILER_ION_CHECK_RANGE_ANALYSIS: if (value == 0) { jit::JitOptions.checkRangeAnalysis = false; JitSpew(js::jit::JitSpew_IonScripts, "IonBuilder: Enable range analysis checks."); } else { jit::JitOptions.checkRangeAnalysis = true; JitSpew(js::jit::JitSpew_IonScripts, "IonBuilder: Disable range analysis checks."); } break; case JSJITCOMPILER_ION_ENABLE: if (value == 1) { JS::ContextOptionsRef(cx).setIon(true); JitSpew(js::jit::JitSpew_IonScripts, "Enable ion"); } else if (value == 0) { JS::ContextOptionsRef(cx).setIon(false); JitSpew(js::jit::JitSpew_IonScripts, "Disable ion"); } break; case JSJITCOMPILER_BASELINE_ENABLE: if (value == 1) { JS::ContextOptionsRef(cx).setBaseline(true); ReleaseAllJITCode(rt->defaultFreeOp()); JitSpew(js::jit::JitSpew_BaselineScripts, "Enable baseline"); } else if (value == 0) { JS::ContextOptionsRef(cx).setBaseline(false); ReleaseAllJITCode(rt->defaultFreeOp()); JitSpew(js::jit::JitSpew_BaselineScripts, "Disable baseline"); } break; case JSJITCOMPILER_OFFTHREAD_COMPILATION_ENABLE: if (value == 1) { rt->setOffthreadIonCompilationEnabled(true); JitSpew(js::jit::JitSpew_IonScripts, "Enable offthread compilation"); } else if (value == 0) { rt->setOffthreadIonCompilationEnabled(false); JitSpew(js::jit::JitSpew_IonScripts, "Disable offthread compilation"); } break; case JSJITCOMPILER_JUMP_THRESHOLD: if (value == uint32_t(-1)) { jit::DefaultJitOptions defaultValues; value = defaultValues.jumpThreshold; } jit::JitOptions.jumpThreshold = value; break; case JSJITCOMPILER_ASMJS_ATOMICS_ENABLE: jit::JitOptions.asmJSAtomicsEnable = !!value; break; case JSJITCOMPILER_WASM_TEST_MODE: jit::JitOptions.wasmTestMode = !!value; break; case JSJITCOMPILER_WASM_FOLD_OFFSETS: jit::JitOptions.wasmFoldOffsets = !!value; break; case JSJITCOMPILER_ION_INTERRUPT_WITHOUT_SIGNAL: jit::JitOptions.ionInterruptWithoutSignals = !!value; break; default: break; } } JS_PUBLIC_API(bool) JS_GetGlobalJitCompilerOption(JSContext* cx, JSJitCompilerOption opt, uint32_t* valueOut) { MOZ_ASSERT(valueOut); #ifndef JS_CODEGEN_NONE JSRuntime* rt = cx->runtime(); switch (opt) { case JSJITCOMPILER_BASELINE_WARMUP_TRIGGER: *valueOut = jit::JitOptions.baselineWarmUpThreshold; break; case JSJITCOMPILER_ION_WARMUP_TRIGGER: *valueOut = jit::JitOptions.forcedDefaultIonWarmUpThreshold.isSome() ? jit::JitOptions.forcedDefaultIonWarmUpThreshold.ref() : jit::OptimizationInfo::CompilerWarmupThreshold; break; case JSJITCOMPILER_ION_FORCE_IC: *valueOut = jit::JitOptions.forceInlineCaches; break; case JSJITCOMPILER_ION_CHECK_RANGE_ANALYSIS: *valueOut = jit::JitOptions.checkRangeAnalysis; break; case JSJITCOMPILER_ION_ENABLE: *valueOut = JS::ContextOptionsRef(cx).ion(); break; case JSJITCOMPILER_BASELINE_ENABLE: *valueOut = JS::ContextOptionsRef(cx).baseline(); break; case JSJITCOMPILER_OFFTHREAD_COMPILATION_ENABLE: *valueOut = rt->canUseOffthreadIonCompilation(); break; case JSJITCOMPILER_ASMJS_ATOMICS_ENABLE: *valueOut = jit::JitOptions.asmJSAtomicsEnable ? 1 : 0; break; case JSJITCOMPILER_WASM_TEST_MODE: *valueOut = jit::JitOptions.wasmTestMode ? 1 : 0; break; case JSJITCOMPILER_WASM_FOLD_OFFSETS: *valueOut = jit::JitOptions.wasmFoldOffsets ? 1 : 0; break; case JSJITCOMPILER_ION_INTERRUPT_WITHOUT_SIGNAL: *valueOut = jit::JitOptions.ionInterruptWithoutSignals ? 1 : 0; break; default: return false; } #else *valueOut = 0; #endif return true; } /************************************************************************/ #if !defined(STATIC_EXPORTABLE_JS_API) && !defined(STATIC_JS_API) && defined(XP_WIN) #include "jswin.h" /* * Initialization routine for the JS DLL. */ BOOL WINAPI DllMain (HINSTANCE hDLL, DWORD dwReason, LPVOID lpReserved) { return TRUE; } #endif JS_PUBLIC_API(bool) JS_IndexToId(JSContext* cx, uint32_t index, MutableHandleId id) { return IndexToId(cx, index, id); } JS_PUBLIC_API(bool) JS_CharsToId(JSContext* cx, JS::TwoByteChars chars, MutableHandleId idp) { RootedAtom atom(cx, AtomizeChars(cx, chars.begin().get(), chars.length())); if (!atom) return false; #ifdef DEBUG uint32_t dummy; MOZ_ASSERT(!atom->isIndex(&dummy), "API misuse: |chars| must not encode an index"); #endif idp.set(AtomToId(atom)); return true; } JS_PUBLIC_API(bool) JS_IsIdentifier(JSContext* cx, HandleString str, bool* isIdentifier) { assertSameCompartment(cx, str); JSLinearString* linearStr = str->ensureLinear(cx); if (!linearStr) return false; *isIdentifier = js::frontend::IsIdentifier(linearStr); return true; } JS_PUBLIC_API(bool) JS_IsIdentifier(const char16_t* chars, size_t length) { return js::frontend::IsIdentifier(chars, length); } namespace JS { void AutoFilename::reset() { if (ss_) { ss_->decref(); ss_ = nullptr; } if (filename_.is<const char*>()) filename_.as<const char*>() = nullptr; else filename_.as<UniqueChars>().reset(); } void AutoFilename::setScriptSource(js::ScriptSource* p) { MOZ_ASSERT(!ss_); MOZ_ASSERT(!get()); ss_ = p; if (p) { p->incref(); setUnowned(p->filename()); } } void AutoFilename::setUnowned(const char* filename) { MOZ_ASSERT(!get()); filename_.as<const char*>() = filename ? filename : ""; } void AutoFilename::setOwned(UniqueChars&& filename) { MOZ_ASSERT(!get()); filename_ = AsVariant(Move(filename)); } const char* AutoFilename::get() const { if (filename_.is<const char*>()) return filename_.as<const char*>(); return filename_.as<UniqueChars>().get(); } JS_PUBLIC_API(bool) DescribeScriptedCaller(JSContext* cx, AutoFilename* filename, unsigned* lineno, unsigned* column) { if (filename) filename->reset(); if (lineno) *lineno = 0; if (column) *column = 0; if (!cx->compartment()) return false; NonBuiltinFrameIter i(cx, cx->compartment()->principals()); if (i.done()) return false; // If the caller is hidden, the embedding wants us to return false here so // that it can check its own stack (see HideScriptedCaller). if (i.activation()->scriptedCallerIsHidden()) return false; if (filename) { if (i.isWasm()) { // For Wasm, copy out the filename, there is no script source. UniqueChars copy = DuplicateString(i.filename() ? i.filename() : ""); if (!copy) filename->setUnowned("out of memory"); else filename->setOwned(Move(copy)); } else { // All other frames have a script source to read the filename from. filename->setScriptSource(i.scriptSource()); } } if (lineno) *lineno = i.computeLine(column); else if (column) i.computeLine(column); return true; } // Fast path to get the activation to use for GetScriptedCallerGlobal. If this // returns false, the fast path didn't work out and the caller has to use the // (much slower) NonBuiltinFrameIter path. // // The optimization here is that we skip Ion-inlined frames and only look at // 'outer' frames. That's fine: each activation is tied to a single compartment, // so if an activation contains at least one non-self-hosted frame, we can use // the activation's global for GetScriptedCallerGlobal. If, however, all 'outer' // frames are self-hosted, it's possible Ion inlined a non-self-hosted script, // so we must return false and use the slower path. static bool GetScriptedCallerActivationFast(JSContext* cx, Activation** activation) { ActivationIterator activationIter(cx->runtime()); if (activationIter.done()) { *activation = nullptr; return true; } *activation = activationIter.activation(); if (activationIter->isJit()) { for (jit::JitFrameIterator iter(activationIter); !iter.done(); ++iter) { if (iter.isScripted() && !iter.script()->selfHosted()) return true; } } else if (activationIter->isInterpreter()) { for (InterpreterFrameIterator iter((*activation)->asInterpreter()); !iter.done(); ++iter) { if (!iter.frame()->script()->selfHosted()) return true; } } return false; } JS_PUBLIC_API(JSObject*) GetScriptedCallerGlobal(JSContext* cx) { Activation* activation; if (GetScriptedCallerActivationFast(cx, &activation)) { if (!activation) return nullptr; } else { NonBuiltinFrameIter i(cx); if (i.done()) return nullptr; activation = i.activation(); } // If the caller is hidden, the embedding wants us to return null here so // that it can check its own stack (see HideScriptedCaller). if (activation->scriptedCallerIsHidden()) return nullptr; GlobalObject* global = activation->compartment()->maybeGlobal(); // Noone should be running code in the atoms compartment or running code in // a compartment without any live objects, so there should definitely be a // live global. MOZ_ASSERT(global); return global; } JS_PUBLIC_API(void) HideScriptedCaller(JSContext* cx) { MOZ_ASSERT(cx); // If there's no accessible activation on the stack, we'll return null from // DescribeScriptedCaller anyway, so there's no need to annotate anything. Activation* act = cx->runtime()->activation(); if (!act) return; act->hideScriptedCaller(); } JS_PUBLIC_API(void) UnhideScriptedCaller(JSContext* cx) { Activation* act = cx->runtime()->activation(); if (!act) return; act->unhideScriptedCaller(); } } /* namespace JS */ AutoGCRooter::AutoGCRooter(JSContext* cx, ptrdiff_t tag) : AutoGCRooter(JS::RootingContext::get(cx), tag) {} AutoGCRooter::AutoGCRooter(JS::RootingContext* cx, ptrdiff_t tag) : down(cx->roots.autoGCRooters_), tag_(tag), stackTop(&cx->roots.autoGCRooters_) { MOZ_ASSERT(this != *stackTop); *stackTop = this; } #ifdef JS_DEBUG JS_PUBLIC_API(void) JS::detail::AssertArgumentsAreSane(JSContext* cx, HandleValue value) { AssertHeapIsIdle(cx); CHECK_REQUEST(cx); assertSameCompartment(cx, value); } #endif /* JS_DEBUG */ JS_PUBLIC_API(JS::TranscodeResult) JS::EncodeScript(JSContext* cx, TranscodeBuffer& buffer, HandleScript scriptArg) { XDREncoder encoder(cx, buffer, buffer.length()); RootedScript script(cx, scriptArg); if (!encoder.codeScript(&script)) buffer.clearAndFree(); MOZ_ASSERT(!buffer.empty() == (encoder.resultCode() == TranscodeResult_Ok)); return encoder.resultCode(); } JS_PUBLIC_API(JS::TranscodeResult) JS::EncodeInterpretedFunction(JSContext* cx, TranscodeBuffer& buffer, HandleObject funobjArg) { XDREncoder encoder(cx, buffer, buffer.length()); RootedFunction funobj(cx, &funobjArg->as<JSFunction>()); if (!encoder.codeFunction(&funobj)) buffer.clearAndFree(); MOZ_ASSERT(!buffer.empty() == (encoder.resultCode() == TranscodeResult_Ok)); return encoder.resultCode(); } JS_PUBLIC_API(JS::TranscodeResult) JS::DecodeScript(JSContext* cx, TranscodeBuffer& buffer, JS::MutableHandleScript scriptp, size_t cursorIndex) { XDRDecoder decoder(cx, buffer, cursorIndex); decoder.codeScript(scriptp); MOZ_ASSERT(bool(scriptp) == (decoder.resultCode() == TranscodeResult_Ok)); return decoder.resultCode(); } JS_PUBLIC_API(JS::TranscodeResult) JS::DecodeInterpretedFunction(JSContext* cx, TranscodeBuffer& buffer, JS::MutableHandleFunction funp, size_t cursorIndex) { XDRDecoder decoder(cx, buffer, cursorIndex); decoder.codeFunction(funp); MOZ_ASSERT(bool(funp) == (decoder.resultCode() == TranscodeResult_Ok)); return decoder.resultCode(); } JS_PUBLIC_API(void) JS::SetBuildIdOp(JSContext* cx, JS::BuildIdOp buildIdOp) { cx->runtime()->buildIdOp = buildIdOp; } JS_PUBLIC_API(void) JS::SetAsmJSCacheOps(JSContext* cx, const JS::AsmJSCacheOps* ops) { cx->runtime()->asmJSCacheOps = *ops; } bool JS::IsWasmModuleObject(HandleObject obj) { JSObject* unwrapped = CheckedUnwrap(obj); if (!unwrapped) return false; return unwrapped->is<WasmModuleObject>(); } JS_PUBLIC_API(RefPtr<JS::WasmModule>) JS::GetWasmModule(HandleObject obj) { MOZ_ASSERT(JS::IsWasmModuleObject(obj)); return &CheckedUnwrap(obj)->as<WasmModuleObject>().module(); } JS_PUBLIC_API(bool) JS::CompiledWasmModuleAssumptionsMatch(PRFileDesc* compiled, JS::BuildIdCharVector&& buildId) { return wasm::CompiledModuleAssumptionsMatch(compiled, Move(buildId)); } JS_PUBLIC_API(RefPtr<JS::WasmModule>) JS::DeserializeWasmModule(PRFileDesc* bytecode, PRFileDesc* maybeCompiled, JS::BuildIdCharVector&& buildId, UniqueChars file, unsigned line, unsigned column) { return wasm::DeserializeModule(bytecode, maybeCompiled, Move(buildId), Move(file), line, column); } char* JSAutoByteString::encodeLatin1(ExclusiveContext* cx, JSString* str) { mBytes = EncodeLatin1(cx, str); return mBytes; } JS_PUBLIC_API(void) JS::SetLargeAllocationFailureCallback(JSContext* cx, JS::LargeAllocationFailureCallback lafc, void* data) { cx->largeAllocationFailureCallback = lafc; cx->largeAllocationFailureCallbackData = data; } JS_PUBLIC_API(void) JS::SetOutOfMemoryCallback(JSContext* cx, OutOfMemoryCallback cb, void* data) { cx->oomCallback = cb; cx->oomCallbackData = data; } JS::FirstSubsumedFrame::FirstSubsumedFrame(JSContext* cx, bool ignoreSelfHostedFrames /* = true */) : JS::FirstSubsumedFrame(cx, cx->compartment()->principals(), ignoreSelfHostedFrames) { } JS_PUBLIC_API(bool) JS::CaptureCurrentStack(JSContext* cx, JS::MutableHandleObject stackp, JS::StackCapture&& capture /* = JS::StackCapture(JS::AllFrames()) */) { AssertHeapIsIdle(cx); CHECK_REQUEST(cx); MOZ_RELEASE_ASSERT(cx->compartment()); JSCompartment* compartment = cx->compartment(); Rooted<SavedFrame*> frame(cx); if (!compartment->savedStacks().saveCurrentStack(cx, &frame, mozilla::Move(capture))) return false; stackp.set(frame.get()); return true; } JS_PUBLIC_API(bool) JS::CopyAsyncStack(JSContext* cx, JS::HandleObject asyncStack, JS::HandleString asyncCause, JS::MutableHandleObject stackp, unsigned maxFrameCount) { AssertHeapIsIdle(cx); CHECK_REQUEST(cx); MOZ_RELEASE_ASSERT(cx->compartment()); js::AssertObjectIsSavedFrameOrWrapper(cx, asyncStack); JSCompartment* compartment = cx->compartment(); Rooted<SavedFrame*> frame(cx); if (!compartment->savedStacks().copyAsyncStack(cx, asyncStack, asyncCause, &frame, maxFrameCount)) return false; stackp.set(frame.get()); return true; } JS_PUBLIC_API(Zone*) JS::GetObjectZone(JSObject* obj) { return obj->zone(); } JS_PUBLIC_API(JS::TraceKind) JS::GCThingTraceKind(void* thing) { MOZ_ASSERT(thing); return static_cast<js::gc::Cell*>(thing)->getTraceKind(); } JS_PUBLIC_API(void) js::SetStackFormat(JSContext* cx, js::StackFormat format) { cx->setStackFormat(format); } JS_PUBLIC_API(js::StackFormat) js::GetStackFormat(JSContext* cx) { return cx->stackFormat(); }