https://github.com/mozilla/gecko-dev
Tip revision: 050338968470d871acbb00834e47fdddccc55c87 authored by ffxbld on 08 March 2012, 23:55:53 UTC
Added FIREFOX_11_0b7_RELEASE FIREFOX_11_0b7_BUILD1 tag(s) for changeset ff0935d61662. DONTBUILD CLOSED TREE a=release
Added FIREFOX_11_0b7_RELEASE FIREFOX_11_0b7_BUILD1 tag(s) for changeset ff0935d61662. DONTBUILD CLOSED TREE a=release
Tip revision: 0503389
jsapi.cpp
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
* vim: set ts=8 sw=4 et tw=78:
*
* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is Mozilla Communicator client code, released
* March 31, 1998.
*
* The Initial Developer of the Original Code is
* Netscape Communications Corporation.
* Portions created by the Initial Developer are Copyright (C) 1998
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
*
* Alternatively, the contents of this file may be used under the terms of
* either of the GNU General Public License Version 2 or later (the "GPL"),
* or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
/*
* JavaScript API.
*/
#include <ctype.h>
#include <stdarg.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include "jstypes.h"
#include "jsstdint.h"
#include "jsutil.h"
#include "jsclist.h"
#include "jsdhash.h"
#include "jsprf.h"
#include "jsapi.h"
#include "jsarray.h"
#include "jsatom.h"
#include "jsbool.h"
#include "jsclone.h"
#include "jscntxt.h"
#include "jsversion.h"
#include "jsdate.h"
#include "jsexn.h"
#include "jsfun.h"
#include "jsgc.h"
#include "jsgcmark.h"
#include "jsinterp.h"
#include "jsiter.h"
#include "jslock.h"
#include "jsmath.h"
#include "jsnum.h"
#include "json.h"
#include "jsobj.h"
#include "jsopcode.h"
#include "jsprobes.h"
#include "jsproxy.h"
#include "jsscope.h"
#include "jsscript.h"
#include "jsstr.h"
#include "prmjtime.h"
#include "jsweakmap.h"
#include "jswrapper.h"
#include "jstypedarray.h"
#include "ds/LifoAlloc.h"
#include "builtin/RegExp.h"
#include "frontend/BytecodeCompiler.h"
#include "frontend/BytecodeEmitter.h"
#include "jsatominlines.h"
#include "jsinferinlines.h"
#include "jsobjinlines.h"
#include "jsscopeinlines.h"
#include "jsscriptinlines.h"
#include "vm/RegExpObject-inl.h"
#include "vm/RegExpStatics-inl.h"
#include "vm/Stack-inl.h"
#include "vm/String-inl.h"
#if ENABLE_YARR_JIT
#include "assembler/jit/ExecutableAllocator.h"
#include "methodjit/Logging.h"
#endif
#if JS_HAS_XML_SUPPORT
#include "jsxml.h"
#endif
using namespace js;
using namespace js::gc;
using namespace js::types;
/*
* This class is a version-establising barrier at the head of a VM entry or
* re-entry. It ensures that:
*
* - |newVersion| is the starting (default) version used for the context.
* - The starting version state is not an override.
* - Overrides in the VM session are not propagated to the caller.
*/
class AutoVersionAPI
{
JSContext * const cx;
JSVersion oldDefaultVersion;
bool oldHasVersionOverride;
JSVersion oldVersionOverride;
#ifdef DEBUG
uintN oldCompileOptions;
#endif
JSVersion newVersion;
public:
explicit AutoVersionAPI(JSContext *cx, JSVersion newVersion)
: cx(cx),
oldDefaultVersion(cx->getDefaultVersion()),
oldHasVersionOverride(cx->isVersionOverridden()),
oldVersionOverride(oldHasVersionOverride ? cx->findVersion() : JSVERSION_UNKNOWN)
#ifdef DEBUG
, oldCompileOptions(cx->getCompileOptions())
#endif
{
this->newVersion = newVersion;
cx->clearVersionOverride();
cx->setDefaultVersion(newVersion);
}
~AutoVersionAPI() {
cx->setDefaultVersion(oldDefaultVersion);
if (oldHasVersionOverride)
cx->overrideVersion(oldVersionOverride);
else
cx->clearVersionOverride();
JS_ASSERT(oldCompileOptions == cx->getCompileOptions());
}
/* The version that this scoped-entity establishes. */
JSVersion version() const { return newVersion; }
};
#ifdef HAVE_VA_LIST_AS_ARRAY
#define JS_ADDRESSOF_VA_LIST(ap) ((va_list *)(ap))
#else
#define JS_ADDRESSOF_VA_LIST(ap) (&(ap))
#endif
#ifdef JS_USE_JSID_STRUCT_TYPES
jsid JS_DEFAULT_XML_NAMESPACE_ID = { size_t(JSID_TYPE_DEFAULT_XML_NAMESPACE) };
jsid JSID_VOID = { size_t(JSID_TYPE_VOID) };
jsid JSID_EMPTY = { size_t(JSID_TYPE_OBJECT) };
#endif
const jsval JSVAL_NULL = IMPL_TO_JSVAL(BUILD_JSVAL(JSVAL_TAG_NULL, 0));
const jsval JSVAL_ZERO = IMPL_TO_JSVAL(BUILD_JSVAL(JSVAL_TAG_INT32, 0));
const jsval JSVAL_ONE = IMPL_TO_JSVAL(BUILD_JSVAL(JSVAL_TAG_INT32, 1));
const jsval JSVAL_FALSE = IMPL_TO_JSVAL(BUILD_JSVAL(JSVAL_TAG_BOOLEAN, JS_FALSE));
const jsval JSVAL_TRUE = IMPL_TO_JSVAL(BUILD_JSVAL(JSVAL_TAG_BOOLEAN, JS_TRUE));
const jsval JSVAL_VOID = IMPL_TO_JSVAL(BUILD_JSVAL(JSVAL_TAG_UNDEFINED, 0));
/* Make sure that jschar is two bytes unsigned integer */
JS_STATIC_ASSERT((jschar)-1 > 0);
JS_STATIC_ASSERT(sizeof(jschar) == 2);
JS_PUBLIC_API(int64_t)
JS_Now()
{
return PRMJ_Now();
}
JS_PUBLIC_API(jsval)
JS_GetNaNValue(JSContext *cx)
{
return cx->runtime->NaNValue;
}
JS_PUBLIC_API(jsval)
JS_GetNegativeInfinityValue(JSContext *cx)
{
return cx->runtime->negativeInfinityValue;
}
JS_PUBLIC_API(jsval)
JS_GetPositiveInfinityValue(JSContext *cx)
{
return cx->runtime->positiveInfinityValue;
}
JS_PUBLIC_API(jsval)
JS_GetEmptyStringValue(JSContext *cx)
{
return STRING_TO_JSVAL(cx->runtime->emptyString);
}
JS_PUBLIC_API(JSString *)
JS_GetEmptyString(JSRuntime *rt)
{
JS_ASSERT(rt->state == JSRTS_UP);
return rt->emptyString;
}
static JSBool
TryArgumentFormatter(JSContext *cx, const char **formatp, JSBool fromJS, jsval **vpp, va_list *app)
{
const char *format;
JSArgumentFormatMap *map;
format = *formatp;
for (map = cx->argumentFormatMap; map; map = map->next) {
if (!strncmp(format, map->format, map->length)) {
*formatp = format + map->length;
return map->formatter(cx, format, fromJS, vpp, app);
}
}
JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL, JSMSG_BAD_CHAR, format);
return JS_FALSE;
}
JS_PUBLIC_API(JSBool)
JS_ConvertArguments(JSContext *cx, uintN argc, jsval *argv, const char *format, ...)
{
va_list ap;
JSBool ok;
va_start(ap, format);
ok = JS_ConvertArgumentsVA(cx, argc, argv, format, ap);
va_end(ap);
return ok;
}
JS_PUBLIC_API(JSBool)
JS_ConvertArgumentsVA(JSContext *cx, uintN argc, jsval *argv, const char *format, va_list ap)
{
jsval *sp;
JSBool required;
char c;
JSFunction *fun;
jsdouble d;
JSString *str;
JSObject *obj;
CHECK_REQUEST(cx);
assertSameCompartment(cx, JSValueArray(argv - 2, argc + 2));
sp = argv;
required = JS_TRUE;
while ((c = *format++) != '\0') {
if (isspace(c))
continue;
if (c == '/') {
required = JS_FALSE;
continue;
}
if (sp == argv + argc) {
if (required) {
fun = js_ValueToFunction(cx, &argv[-2], 0);
if (fun) {
char numBuf[12];
JS_snprintf(numBuf, sizeof numBuf, "%u", argc);
JSAutoByteString funNameBytes;
if (const char *name = GetFunctionNameBytes(cx, fun, &funNameBytes)) {
JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL, JSMSG_MORE_ARGS_NEEDED,
name, numBuf, (argc == 1) ? "" : "s");
}
}
return JS_FALSE;
}
break;
}
switch (c) {
case 'b':
*va_arg(ap, JSBool *) = js_ValueToBoolean(*sp);
break;
case 'c':
if (!JS_ValueToUint16(cx, *sp, va_arg(ap, uint16_t *)))
return JS_FALSE;
break;
case 'i':
if (!JS_ValueToECMAInt32(cx, *sp, va_arg(ap, int32_t *)))
return JS_FALSE;
break;
case 'u':
if (!JS_ValueToECMAUint32(cx, *sp, va_arg(ap, uint32_t *)))
return JS_FALSE;
break;
case 'j':
if (!JS_ValueToInt32(cx, *sp, va_arg(ap, int32_t *)))
return JS_FALSE;
break;
case 'd':
if (!JS_ValueToNumber(cx, *sp, va_arg(ap, jsdouble *)))
return JS_FALSE;
break;
case 'I':
if (!JS_ValueToNumber(cx, *sp, &d))
return JS_FALSE;
*va_arg(ap, jsdouble *) = js_DoubleToInteger(d);
break;
case 'S':
case 'W':
str = ToString(cx, *sp);
if (!str)
return JS_FALSE;
*sp = STRING_TO_JSVAL(str);
if (c == 'W') {
JSFixedString *fixed = str->ensureFixed(cx);
if (!fixed)
return JS_FALSE;
*va_arg(ap, const jschar **) = fixed->chars();
} else {
*va_arg(ap, JSString **) = str;
}
break;
case 'o':
if (!js_ValueToObjectOrNull(cx, *sp, &obj))
return JS_FALSE;
*sp = OBJECT_TO_JSVAL(obj);
*va_arg(ap, JSObject **) = obj;
break;
case 'f':
obj = js_ValueToFunction(cx, sp, 0);
if (!obj)
return JS_FALSE;
*sp = OBJECT_TO_JSVAL(obj);
*va_arg(ap, JSFunction **) = obj->toFunction();
break;
case 'v':
*va_arg(ap, jsval *) = *sp;
break;
case '*':
break;
default:
format--;
if (!TryArgumentFormatter(cx, &format, JS_TRUE, &sp,
JS_ADDRESSOF_VA_LIST(ap))) {
return JS_FALSE;
}
/* NB: the formatter already updated sp, so we continue here. */
continue;
}
sp++;
}
return JS_TRUE;
}
JS_PUBLIC_API(JSBool)
JS_AddArgumentFormatter(JSContext *cx, const char *format, JSArgumentFormatter formatter)
{
size_t length;
JSArgumentFormatMap **mpp, *map;
length = strlen(format);
mpp = &cx->argumentFormatMap;
while ((map = *mpp) != NULL) {
/* Insert before any shorter string to match before prefixes. */
if (map->length < length)
break;
if (map->length == length && !strcmp(map->format, format))
goto out;
mpp = &map->next;
}
map = (JSArgumentFormatMap *) cx->malloc_(sizeof *map);
if (!map)
return JS_FALSE;
map->format = format;
map->length = length;
map->next = *mpp;
*mpp = map;
out:
map->formatter = formatter;
return JS_TRUE;
}
JS_PUBLIC_API(void)
JS_RemoveArgumentFormatter(JSContext *cx, const char *format)
{
size_t length;
JSArgumentFormatMap **mpp, *map;
length = strlen(format);
mpp = &cx->argumentFormatMap;
while ((map = *mpp) != NULL) {
if (map->length == length && !strcmp(map->format, format)) {
*mpp = map->next;
cx->free_(map);
return;
}
mpp = &map->next;
}
}
JS_PUBLIC_API(JSBool)
JS_ConvertValue(JSContext *cx, jsval v, JSType type, jsval *vp)
{
JSBool ok;
JSObject *obj;
JSString *str;
jsdouble d;
CHECK_REQUEST(cx);
assertSameCompartment(cx, v);
switch (type) {
case JSTYPE_VOID:
*vp = JSVAL_VOID;
ok = JS_TRUE;
break;
case JSTYPE_OBJECT:
ok = js_ValueToObjectOrNull(cx, v, &obj);
if (ok)
*vp = OBJECT_TO_JSVAL(obj);
break;
case JSTYPE_FUNCTION:
*vp = v;
obj = js_ValueToFunction(cx, vp, JSV2F_SEARCH_STACK);
ok = (obj != NULL);
break;
case JSTYPE_STRING:
str = ToString(cx, v);
ok = (str != NULL);
if (ok)
*vp = STRING_TO_JSVAL(str);
break;
case JSTYPE_NUMBER:
ok = JS_ValueToNumber(cx, v, &d);
if (ok)
*vp = DOUBLE_TO_JSVAL(d);
break;
case JSTYPE_BOOLEAN:
*vp = BOOLEAN_TO_JSVAL(js_ValueToBoolean(v));
return JS_TRUE;
default: {
char numBuf[12];
JS_snprintf(numBuf, sizeof numBuf, "%d", (int)type);
JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL, JSMSG_BAD_TYPE, numBuf);
ok = JS_FALSE;
break;
}
}
return ok;
}
JS_PUBLIC_API(JSBool)
JS_ValueToObject(JSContext *cx, jsval v, JSObject **objp)
{
CHECK_REQUEST(cx);
assertSameCompartment(cx, v);
return js_ValueToObjectOrNull(cx, v, objp);
}
JS_PUBLIC_API(JSFunction *)
JS_ValueToFunction(JSContext *cx, jsval v)
{
CHECK_REQUEST(cx);
assertSameCompartment(cx, v);
return js_ValueToFunction(cx, &v, JSV2F_SEARCH_STACK);
}
JS_PUBLIC_API(JSFunction *)
JS_ValueToConstructor(JSContext *cx, jsval v)
{
CHECK_REQUEST(cx);
assertSameCompartment(cx, v);
return js_ValueToFunction(cx, &v, JSV2F_SEARCH_STACK);
}
JS_PUBLIC_API(JSString *)
JS_ValueToString(JSContext *cx, jsval v)
{
CHECK_REQUEST(cx);
assertSameCompartment(cx, v);
return ToString(cx, v);
}
JS_PUBLIC_API(JSString *)
JS_ValueToSource(JSContext *cx, jsval v)
{
CHECK_REQUEST(cx);
assertSameCompartment(cx, v);
return js_ValueToSource(cx, v);
}
JS_PUBLIC_API(JSBool)
JS_ValueToNumber(JSContext *cx, jsval v, jsdouble *dp)
{
CHECK_REQUEST(cx);
assertSameCompartment(cx, v);
AutoValueRooter tvr(cx, v);
return ToNumber(cx, tvr.value(), dp);
}
JS_PUBLIC_API(JSBool)
JS_DoubleIsInt32(jsdouble d, jsint *ip)
{
return JSDOUBLE_IS_INT32(d, (int32_t *)ip);
}
JS_PUBLIC_API(int32_t)
JS_DoubleToInt32(jsdouble d)
{
return js_DoubleToECMAInt32(d);
}
JS_PUBLIC_API(uint32_t)
JS_DoubleToUint32(jsdouble d)
{
return js_DoubleToECMAUint32(d);
}
JS_PUBLIC_API(JSBool)
JS_ValueToECMAInt32(JSContext *cx, jsval v, int32_t *ip)
{
CHECK_REQUEST(cx);
assertSameCompartment(cx, v);
AutoValueRooter tvr(cx, v);
return ToInt32(cx, tvr.value(), (int32_t *)ip);
}
JS_PUBLIC_API(JSBool)
JS_ValueToECMAUint32(JSContext *cx, jsval v, uint32_t *ip)
{
CHECK_REQUEST(cx);
assertSameCompartment(cx, v);
AutoValueRooter tvr(cx, v);
return ToUint32(cx, tvr.value(), (uint32_t *)ip);
}
JS_PUBLIC_API(JSBool)
JS_ValueToInt32(JSContext *cx, jsval v, int32_t *ip)
{
CHECK_REQUEST(cx);
assertSameCompartment(cx, v);
AutoValueRooter tvr(cx, v);
return NonstandardToInt32(cx, tvr.value(), (int32_t *)ip);
}
JS_PUBLIC_API(JSBool)
JS_ValueToUint16(JSContext *cx, jsval v, uint16_t *ip)
{
CHECK_REQUEST(cx);
assertSameCompartment(cx, v);
AutoValueRooter tvr(cx, v);
return ValueToUint16(cx, tvr.value(), (uint16_t *)ip);
}
JS_PUBLIC_API(JSBool)
JS_ValueToBoolean(JSContext *cx, jsval v, JSBool *bp)
{
CHECK_REQUEST(cx);
assertSameCompartment(cx, v);
*bp = js_ValueToBoolean(v);
return JS_TRUE;
}
JS_PUBLIC_API(JSType)
JS_TypeOfValue(JSContext *cx, jsval v)
{
CHECK_REQUEST(cx);
assertSameCompartment(cx, v);
return TypeOfValue(cx, v);
}
JS_PUBLIC_API(const char *)
JS_GetTypeName(JSContext *cx, JSType type)
{
if ((uintN)type >= (uintN)JSTYPE_LIMIT)
return NULL;
return JS_TYPE_STR(type);
}
JS_PUBLIC_API(JSBool)
JS_StrictlyEqual(JSContext *cx, jsval v1, jsval v2, JSBool *equal)
{
CHECK_REQUEST(cx);
assertSameCompartment(cx, v1, v2);
return StrictlyEqual(cx, v1, v2, equal);
}
JS_PUBLIC_API(JSBool)
JS_LooselyEqual(JSContext *cx, jsval v1, jsval v2, JSBool *equal)
{
CHECK_REQUEST(cx);
assertSameCompartment(cx, v1, v2);
return LooselyEqual(cx, v1, v2, equal);
}
JS_PUBLIC_API(JSBool)
JS_SameValue(JSContext *cx, jsval v1, jsval v2, JSBool *same)
{
CHECK_REQUEST(cx);
assertSameCompartment(cx, v1, v2);
return SameValue(cx, v1, v2, same);
}
JS_PUBLIC_API(JSBool)
JS_IsBuiltinEvalFunction(JSFunction *fun)
{
return IsAnyBuiltinEval(fun);
}
JS_PUBLIC_API(JSBool)
JS_IsBuiltinFunctionConstructor(JSFunction *fun)
{
return IsBuiltinFunctionConstructor(fun);
}
/************************************************************************/
/*
* Has a new runtime ever been created? This flag is used to detect unsafe
* changes to js_CStringsAreUTF8 after a runtime has been created, and to
* control things that should happen only once across all runtimes.
*/
static JSBool js_NewRuntimeWasCalled = JS_FALSE;
JSRuntime::JSRuntime()
: atomsCompartment(NULL),
state(),
cxCallback(NULL),
compartmentCallback(NULL),
activityCallback(NULL),
activityCallbackArg(NULL),
gcSystemAvailableChunkListHead(NULL),
gcUserAvailableChunkListHead(NULL),
gcKeepAtoms(0),
gcBytes(0),
gcTriggerBytes(0),
gcLastBytes(0),
gcMaxBytes(0),
gcMaxMallocBytes(0),
gcEmptyArenaPoolLifespan(0),
gcNumArenasFreeCommitted(0),
gcNumber(0),
gcIncrementalTracer(NULL),
gcVerifyData(NULL),
gcChunkAllocationSinceLastGC(false),
gcNextFullGCTime(0),
gcJitReleaseTime(0),
gcMode(JSGC_MODE_GLOBAL),
gcIsNeeded(0),
gcWeakMapList(NULL),
gcStats(thisFromCtor()),
gcTriggerCompartment(NULL),
gcCurrentCompartment(NULL),
gcCheckCompartment(NULL),
gcPoke(false),
gcMarkAndSweep(false),
gcRunning(false),
#ifdef JS_GC_ZEAL
gcZeal_(0),
gcZealFrequency(0),
gcNextScheduled(0),
gcDebugCompartmentGC(false),
#endif
gcCallback(NULL),
gcFinishedCallback(NULL),
gcMallocBytes(0),
gcBlackRootsTraceOp(NULL),
gcBlackRootsData(NULL),
gcGrayRootsTraceOp(NULL),
gcGrayRootsData(NULL),
scriptPCCounters(NULL),
NaNValue(UndefinedValue()),
negativeInfinityValue(UndefinedValue()),
positiveInfinityValue(UndefinedValue()),
emptyString(NULL),
debugMode(false),
profilingScripts(false),
hadOutOfMemory(false),
data(NULL),
#ifdef JS_THREADSAFE
gcLock(NULL),
gcDone(NULL),
requestDone(NULL),
requestCount(0),
gcThread(NULL),
gcHelperThread(thisFromCtor()),
rtLock(NULL),
# ifdef DEBUG
rtLockOwner(0),
# endif
stateChange(NULL),
#endif
debuggerMutations(0),
securityCallbacks(NULL),
structuredCloneCallbacks(NULL),
telemetryCallback(NULL),
propertyRemovals(0),
scriptFilenameTable(NULL),
#ifdef JS_THREADSAFE
scriptFilenameTableLock(NULL),
#endif
thousandsSeparator(0),
decimalSeparator(0),
numGrouping(0),
anynameObject(NULL),
functionNamespaceObject(NULL),
#ifdef JS_THREADSAFE
interruptCounter(0),
#else
threadData(thisFromCtor()),
#endif
trustedPrincipals_(NULL),
wrapObjectCallback(NULL),
preWrapObjectCallback(NULL),
preserveWrapperCallback(NULL),
inOOMReport(0)
{
/* Initialize infallibly first, so we can goto bad and JS_DestroyRuntime. */
JS_INIT_CLIST(&contextList);
JS_INIT_CLIST(&debuggerList);
PodZero(&globalDebugHooks);
PodZero(&atomState);
}
bool
JSRuntime::init(uint32_t maxbytes)
{
#ifdef JS_THREADSAFE
ownerThread_ = js_CurrentThreadId();
#endif
#ifdef JS_METHODJIT_SPEW
JMCheckLogging();
#endif
if (!js_InitGC(this, maxbytes))
return false;
if (!(atomsCompartment = this->new_<JSCompartment>(this)) ||
!atomsCompartment->init(NULL) ||
!compartments.append(atomsCompartment)) {
Foreground::delete_(atomsCompartment);
return false;
}
atomsCompartment->isSystemCompartment = true;
atomsCompartment->setGCLastBytes(8192, GC_NORMAL);
if (!js_InitAtomState(this))
return false;
wrapObjectCallback = js::TransparentObjectWrapper;
#ifdef JS_THREADSAFE
/* this is asymmetric with JS_ShutDown: */
if (!js_SetupLocks(8, 16))
return false;
rtLock = JS_NEW_LOCK();
if (!rtLock)
return false;
stateChange = JS_NEW_CONDVAR(gcLock);
if (!stateChange)
return false;
#endif
debugMode = false;
if (!js_InitThreads(this))
return false;
if (!InitRuntimeNumberState(this))
return false;
return true;
}
JSRuntime::~JSRuntime()
{
#ifdef DEBUG
/* Don't hurt everyone in leaky ol' Mozilla with a fatal JS_ASSERT! */
if (!JS_CLIST_IS_EMPTY(&contextList)) {
JSContext *cx, *iter = NULL;
uintN cxcount = 0;
while ((cx = js_ContextIterator(this, JS_TRUE, &iter)) != NULL) {
fprintf(stderr,
"JS API usage error: found live context at %p\n",
(void *) cx);
cxcount++;
}
fprintf(stderr,
"JS API usage error: %u context%s left in runtime upon JS_DestroyRuntime.\n",
cxcount, (cxcount == 1) ? "" : "s");
}
#endif
FinishRuntimeNumberState(this);
js_FinishThreads(this);
js_FinishAtomState(this);
js_FinishGC(this);
#ifdef JS_THREADSAFE
if (gcLock)
JS_DESTROY_LOCK(gcLock);
if (gcDone)
JS_DESTROY_CONDVAR(gcDone);
if (requestDone)
JS_DESTROY_CONDVAR(requestDone);
if (rtLock)
JS_DESTROY_LOCK(rtLock);
if (stateChange)
JS_DESTROY_CONDVAR(stateChange);
#endif
}
#ifdef JS_THREADSAFE
void
JSRuntime::setOwnerThread()
{
JS_ASSERT(ownerThread_ == (void *)-1);
ownerThread_ = js_CurrentThreadId();
}
void
JSRuntime::clearOwnerThread()
{
JS_ASSERT(onOwnerThread());
ownerThread_ = (void *)-1;
}
JS_FRIEND_API(bool)
JSRuntime::onOwnerThread() const
{
return ownerThread_ == js_CurrentThreadId();
}
#endif
JS_PUBLIC_API(JSRuntime *)
JS_NewRuntime(uint32_t maxbytes)
{
if (!js_NewRuntimeWasCalled) {
#ifdef DEBUG
/*
* This code asserts that the numbers associated with the error names
* in jsmsg.def are monotonically increasing. It uses values for the
* error names enumerated in jscntxt.c. It's not a compile-time check
* but it's better than nothing.
*/
int errorNumber = 0;
#define MSG_DEF(name, number, count, exception, format) \
JS_ASSERT(name == errorNumber++);
#include "js.msg"
#undef MSG_DEF
#define MSG_DEF(name, number, count, exception, format) \
JS_BEGIN_MACRO \
uintN numfmtspecs = 0; \
const char *fmt; \
for (fmt = format; *fmt != '\0'; fmt++) { \
if (*fmt == '{' && isdigit(fmt[1])) \
++numfmtspecs; \
} \
JS_ASSERT(count == numfmtspecs); \
JS_END_MACRO;
#include "js.msg"
#undef MSG_DEF
#endif /* DEBUG */
js_NewRuntimeWasCalled = JS_TRUE;
}
JSRuntime *rt = OffTheBooks::new_<JSRuntime>();
if (!rt)
return NULL;
if (!rt->init(maxbytes)) {
JS_DestroyRuntime(rt);
return NULL;
}
Probes::createRuntime(rt);
return rt;
}
JS_PUBLIC_API(void)
JS_DestroyRuntime(JSRuntime *rt)
{
Probes::destroyRuntime(rt);
Foreground::delete_(rt);
}
JS_PUBLIC_API(void)
JS_ShutDown(void)
{
Probes::shutdown();
#ifdef JS_THREADSAFE
js_CleanupLocks();
#endif
PRMJ_NowShutdown();
}
JS_PUBLIC_API(void *)
JS_GetRuntimePrivate(JSRuntime *rt)
{
return rt->data;
}
JS_PUBLIC_API(void)
JS_SetRuntimePrivate(JSRuntime *rt, void *data)
{
rt->data = data;
}
#ifdef JS_THREADSAFE
static void
StartRequest(JSContext *cx)
{
JSThread *t = cx->thread();
JS_ASSERT(CURRENT_THREAD_IS_ME(t));
if (t->data.requestDepth) {
t->data.requestDepth++;
} else {
JSRuntime *rt = cx->runtime;
AutoLockGC lock(rt);
/* Wait until the GC is finished. */
if (rt->gcThread != cx->thread()) {
while (rt->gcThread)
JS_AWAIT_GC_DONE(rt);
}
/* Indicate that a request is running. */
rt->requestCount++;
t->data.requestDepth = 1;
/*
* Adjust rt->interruptCounter to reflect any interrupts added while the
* thread was suspended.
*/
if (t->data.interruptFlags)
JS_ATOMIC_INCREMENT(&rt->interruptCounter);
if (rt->requestCount == 1 && rt->activityCallback)
rt->activityCallback(rt->activityCallbackArg, true);
}
}
static void
StopRequest(JSContext *cx)
{
JSThread *t = cx->thread();
JS_ASSERT(CURRENT_THREAD_IS_ME(t));
JS_ASSERT(t->data.requestDepth != 0);
if (t->data.requestDepth != 1) {
t->data.requestDepth--;
} else {
t->data.conservativeGC.updateForRequestEnd(t->suspendCount);
/* Lock before clearing to interlock with ClaimScope, in jslock.c. */
JSRuntime *rt = cx->runtime;
AutoLockGC lock(rt);
t->data.requestDepth = 0;
/*
* Adjust rt->interruptCounter to reflect any interrupts added while the
* thread still had active requests.
*/
if (t->data.interruptFlags)
JS_ATOMIC_DECREMENT(&rt->interruptCounter);
/* Give the GC a chance to run if this was the last request running. */
JS_ASSERT(rt->requestCount > 0);
rt->requestCount--;
if (rt->requestCount == 0) {
JS_NOTIFY_REQUEST_DONE(rt);
if (rt->activityCallback)
rt->activityCallback(rt->activityCallbackArg, false);
}
}
}
#endif /* JS_THREADSAFE */
JS_PUBLIC_API(void)
JS_BeginRequest(JSContext *cx)
{
#ifdef JS_THREADSAFE
cx->outstandingRequests++;
StartRequest(cx);
#endif
}
JS_PUBLIC_API(void)
JS_EndRequest(JSContext *cx)
{
#ifdef JS_THREADSAFE
JS_ASSERT(cx->outstandingRequests != 0);
cx->outstandingRequests--;
StopRequest(cx);
#endif
}
/* Yield to pending GC operations, regardless of request depth */
JS_PUBLIC_API(void)
JS_YieldRequest(JSContext *cx)
{
#ifdef JS_THREADSAFE
CHECK_REQUEST(cx);
JS_ResumeRequest(cx, JS_SuspendRequest(cx));
#endif
}
JS_PUBLIC_API(jsrefcount)
JS_SuspendRequest(JSContext *cx)
{
#ifdef JS_THREADSAFE
JSThread *t = cx->thread();
JS_ASSERT(CURRENT_THREAD_IS_ME(t));
jsrefcount saveDepth = t->data.requestDepth;
if (!saveDepth)
return 0;
t->suspendCount++;
t->data.requestDepth = 1;
StopRequest(cx);
return saveDepth;
#else
return 0;
#endif
}
JS_PUBLIC_API(void)
JS_ResumeRequest(JSContext *cx, jsrefcount saveDepth)
{
#ifdef JS_THREADSAFE
JSThread *t = cx->thread();
JS_ASSERT(CURRENT_THREAD_IS_ME(t));
if (saveDepth == 0)
return;
JS_ASSERT(saveDepth >= 1);
JS_ASSERT(!t->data.requestDepth);
JS_ASSERT(t->suspendCount);
StartRequest(cx);
t->data.requestDepth = saveDepth;
t->suspendCount--;
#endif
}
JS_PUBLIC_API(JSBool)
JS_IsInRequest(JSContext *cx)
{
#ifdef JS_THREADSAFE
JS_ASSERT(CURRENT_THREAD_IS_ME(cx->thread()));
return JS_THREAD_DATA(cx)->requestDepth != 0;
#else
return false;
#endif
}
JS_PUBLIC_API(void)
JS_Lock(JSRuntime *rt)
{
JS_LOCK_RUNTIME(rt);
}
JS_PUBLIC_API(void)
JS_Unlock(JSRuntime *rt)
{
JS_UNLOCK_RUNTIME(rt);
}
JS_PUBLIC_API(JSContextCallback)
JS_SetContextCallback(JSRuntime *rt, JSContextCallback cxCallback)
{
JSContextCallback old;
old = rt->cxCallback;
rt->cxCallback = cxCallback;
return old;
}
JS_PUBLIC_API(JSContext *)
JS_NewContext(JSRuntime *rt, size_t stackChunkSize)
{
return js_NewContext(rt, stackChunkSize);
}
JS_PUBLIC_API(void)
JS_DestroyContext(JSContext *cx)
{
js_DestroyContext(cx, JSDCM_FORCE_GC);
}
JS_PUBLIC_API(void)
JS_DestroyContextNoGC(JSContext *cx)
{
js_DestroyContext(cx, JSDCM_NO_GC);
}
JS_PUBLIC_API(void)
JS_DestroyContextMaybeGC(JSContext *cx)
{
js_DestroyContext(cx, JSDCM_MAYBE_GC);
}
JS_PUBLIC_API(void *)
JS_GetContextPrivate(JSContext *cx)
{
return cx->data;
}
JS_PUBLIC_API(void)
JS_SetContextPrivate(JSContext *cx, void *data)
{
cx->data = data;
}
JS_PUBLIC_API(JSRuntime *)
JS_GetRuntime(JSContext *cx)
{
return cx->runtime;
}
JS_PUBLIC_API(JSContext *)
JS_ContextIterator(JSRuntime *rt, JSContext **iterp)
{
return js_ContextIterator(rt, JS_TRUE, iterp);
}
JS_PUBLIC_API(JSContext *)
JS_ContextIteratorUnlocked(JSRuntime *rt, JSContext **iterp)
{
return js_ContextIterator(rt, JS_FALSE, iterp);
}
JS_PUBLIC_API(JSVersion)
JS_GetVersion(JSContext *cx)
{
return VersionNumber(cx->findVersion());
}
JS_PUBLIC_API(JSVersion)
JS_SetVersion(JSContext *cx, JSVersion newVersion)
{
JS_ASSERT(VersionIsKnown(newVersion));
JS_ASSERT(!VersionHasFlags(newVersion));
JSVersion newVersionNumber = newVersion;
#ifdef DEBUG
uintN coptsBefore = cx->getCompileOptions();
#endif
JSVersion oldVersion = cx->findVersion();
JSVersion oldVersionNumber = VersionNumber(oldVersion);
if (oldVersionNumber == newVersionNumber)
return oldVersionNumber; /* No override actually occurs! */
/* We no longer support 1.4 or below. */
if (newVersionNumber != JSVERSION_DEFAULT && newVersionNumber <= JSVERSION_1_4)
return oldVersionNumber;
VersionCopyFlags(&newVersion, oldVersion);
cx->maybeOverrideVersion(newVersion);
JS_ASSERT(cx->getCompileOptions() == coptsBefore);
return oldVersionNumber;
}
static struct v2smap {
JSVersion version;
const char *string;
} v2smap[] = {
{JSVERSION_1_0, "1.0"},
{JSVERSION_1_1, "1.1"},
{JSVERSION_1_2, "1.2"},
{JSVERSION_1_3, "1.3"},
{JSVERSION_1_4, "1.4"},
{JSVERSION_ECMA_3, "ECMAv3"},
{JSVERSION_1_5, "1.5"},
{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_UNKNOWN, NULL}, /* must be last, NULL 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(uint32_t)
JS_GetOptions(JSContext *cx)
{
/*
* Can't check option/version synchronization here.
* We may have been synchronized with a script version that was formerly on
* the stack, but has now been popped.
*/
return cx->allOptions();
}
static uintN
SetOptionsCommon(JSContext *cx, uintN options)
{
JS_ASSERT((options & JSALLOPTION_MASK) == options);
uintN oldopts = cx->allOptions();
uintN newropts = options & JSRUNOPTION_MASK;
uintN newcopts = options & JSCOMPILEOPTION_MASK;
cx->setRunOptions(newropts);
cx->setCompileOptions(newcopts);
cx->updateJITEnabled();
return oldopts;
}
JS_PUBLIC_API(uint32_t)
JS_SetOptions(JSContext *cx, uint32_t options)
{
AutoLockGC lock(cx->runtime);
return SetOptionsCommon(cx, options);
}
JS_PUBLIC_API(uint32_t)
JS_ToggleOptions(JSContext *cx, uint32_t options)
{
AutoLockGC lock(cx->runtime);
uintN oldopts = cx->allOptions();
uintN newopts = oldopts ^ options;
return SetOptionsCommon(cx, newopts);
}
JS_PUBLIC_API(const char *)
JS_GetImplementationVersion(void)
{
return "JavaScript-C 1.8.5+ 2011-04-16";
}
JS_PUBLIC_API(JSCompartmentCallback)
JS_SetCompartmentCallback(JSRuntime *rt, JSCompartmentCallback callback)
{
JSCompartmentCallback old = rt->compartmentCallback;
rt->compartmentCallback = callback;
return old;
}
JS_PUBLIC_API(JSWrapObjectCallback)
JS_SetWrapObjectCallbacks(JSRuntime *rt,
JSWrapObjectCallback callback,
JSPreWrapCallback precallback)
{
JSWrapObjectCallback old = rt->wrapObjectCallback;
rt->wrapObjectCallback = callback;
rt->preWrapObjectCallback = precallback;
return old;
}
JS_PUBLIC_API(JSCrossCompartmentCall *)
JS_EnterCrossCompartmentCall(JSContext *cx, JSObject *target)
{
CHECK_REQUEST(cx);
JS_ASSERT(target);
AutoCompartment *call = cx->new_<AutoCompartment>(cx, target);
if (!call)
return NULL;
if (!call->enter()) {
Foreground::delete_(call);
return NULL;
}
return reinterpret_cast<JSCrossCompartmentCall *>(call);
}
namespace js {
// Declared in jscompartment.h
Class dummy_class = {
"jdummy",
JSCLASS_GLOBAL_FLAGS,
JS_PropertyStub, JS_PropertyStub,
JS_PropertyStub, JS_StrictPropertyStub,
JS_EnumerateStub, JS_ResolveStub,
JS_ConvertStub
};
} /*namespace js */
JS_PUBLIC_API(JSCrossCompartmentCall *)
JS_EnterCrossCompartmentCallScript(JSContext *cx, JSScript *target)
{
CHECK_REQUEST(cx);
JS_ASSERT(!target->isCachedEval);
GlobalObject *global = target->globalObject;
if (!global) {
SwitchToCompartment sc(cx, target->compartment());
global = GlobalObject::create(cx, &dummy_class);
if (!global)
return NULL;
}
return JS_EnterCrossCompartmentCall(cx, global);
}
JS_PUBLIC_API(JSCrossCompartmentCall *)
JS_EnterCrossCompartmentCallStackFrame(JSContext *cx, JSStackFrame *target)
{
CHECK_REQUEST(cx);
return JS_EnterCrossCompartmentCall(cx, Valueify(target)->scopeChain().getGlobal());
}
JS_PUBLIC_API(void)
JS_LeaveCrossCompartmentCall(JSCrossCompartmentCall *call)
{
AutoCompartment *realcall = reinterpret_cast<AutoCompartment *>(call);
CHECK_REQUEST(realcall->context);
realcall->leave();
Foreground::delete_(realcall);
}
bool
JSAutoEnterCompartment::enter(JSContext *cx, JSObject *target)
{
JS_ASSERT(state == STATE_UNENTERED);
if (cx->compartment == target->compartment()) {
state = STATE_SAME_COMPARTMENT;
return true;
}
JS_STATIC_ASSERT(sizeof(bytes) == sizeof(AutoCompartment));
CHECK_REQUEST(cx);
AutoCompartment *call = new (bytes) AutoCompartment(cx, target);
if (call->enter()) {
state = STATE_OTHER_COMPARTMENT;
return true;
}
return false;
}
void
JSAutoEnterCompartment::enterAndIgnoreErrors(JSContext *cx, JSObject *target)
{
(void) enter(cx, target);
}
JSAutoEnterCompartment::~JSAutoEnterCompartment()
{
if (state == STATE_OTHER_COMPARTMENT) {
AutoCompartment* ac = reinterpret_cast<AutoCompartment*>(bytes);
CHECK_REQUEST(ac->context);
ac->~AutoCompartment();
}
}
namespace JS {
bool
AutoEnterScriptCompartment::enter(JSContext *cx, JSScript *target)
{
JS_ASSERT(!call);
if (cx->compartment == target->compartment()) {
call = reinterpret_cast<JSCrossCompartmentCall*>(1);
return true;
}
call = JS_EnterCrossCompartmentCallScript(cx, target);
return call != NULL;
}
bool
AutoEnterFrameCompartment::enter(JSContext *cx, JSStackFrame *target)
{
JS_ASSERT(!call);
if (cx->compartment == Valueify(target)->scopeChain().compartment()) {
call = reinterpret_cast<JSCrossCompartmentCall*>(1);
return true;
}
call = JS_EnterCrossCompartmentCallStackFrame(cx, target);
return call != NULL;
}
} /* namespace JS */
JS_PUBLIC_API(void *)
JS_SetCompartmentPrivate(JSContext *cx, JSCompartment *compartment, void *data)
{
CHECK_REQUEST(cx);
void *old = compartment->data;
compartment->data = data;
return old;
}
JS_PUBLIC_API(void *)
JS_GetCompartmentPrivate(JSContext *cx, JSCompartment *compartment)
{
CHECK_REQUEST(cx);
return js_GetCompartmentPrivate(compartment);
}
JS_PUBLIC_API(JSBool)
JS_WrapObject(JSContext *cx, JSObject **objp)
{
CHECK_REQUEST(cx);
return cx->compartment->wrap(cx, objp);
}
JS_PUBLIC_API(JSBool)
JS_WrapValue(JSContext *cx, jsval *vp)
{
CHECK_REQUEST(cx);
return cx->compartment->wrap(cx, vp);
}
JS_PUBLIC_API(JSObject *)
JS_TransplantObject(JSContext *cx, JSObject *origobj, JSObject *target)
{
// This function is called when an object moves between two
// different compartments. In that case, we need to "move" the
// window from origobj's compartment to target's compartment.
JSCompartment *destination = target->compartment();
WrapperMap &map = destination->crossCompartmentWrappers;
Value origv = ObjectValue(*origobj);
JSObject *obj;
if (origobj->compartment() == destination) {
// If the original object is in the same compartment as the
// destination, then we know that we won't find wrapper in the
// destination's cross compartment map and that the same
// object will continue to work. Note the rare case where
// |origobj == target|. In that case, we can just treat this
// as a same compartment navigation. The effect is to clear
// all of the wrappers and their holders if they have
// them. This would be cleaner as a separate API.
if (origobj != target && !origobj->swap(cx, target))
return NULL;
obj = origobj;
} else if (WrapperMap::Ptr p = map.lookup(origv)) {
// There might already be a wrapper for the original object in
// the new compartment. If there is, make it the primary outer
// window proxy around the inner (accomplished by swapping
// target's innards with the old, possibly security wrapper,
// innards).
obj = &p->value.toObject();
map.remove(p);
if (!obj->swap(cx, target))
return NULL;
} else {
// Otherwise, this is going to be our outer window proxy in
// the new compartment.
obj = target;
}
// Now, iterate through other scopes looking for references to the
// old outer window. They need to be updated to point at the new
// outer window. They also might transition between different
// types of security wrappers based on whether the new compartment
// is same origin with them.
Value targetv = ObjectValue(*obj);
CompartmentVector &vector = cx->runtime->compartments;
AutoValueVector toTransplant(cx);
if (!toTransplant.reserve(vector.length()))
return NULL;
for (JSCompartment **p = vector.begin(), **end = vector.end(); p != end; ++p) {
WrapperMap &pmap = (*p)->crossCompartmentWrappers;
if (WrapperMap::Ptr wp = pmap.lookup(origv)) {
// We found a wrapper. Remember and root it.
toTransplant.infallibleAppend(wp->value);
}
}
for (Value *begin = toTransplant.begin(), *end = toTransplant.end(); begin != end; ++begin) {
JSObject *wobj = &begin->toObject();
JSCompartment *wcompartment = wobj->compartment();
WrapperMap &pmap = wcompartment->crossCompartmentWrappers;
JS_ASSERT(pmap.lookup(origv));
pmap.remove(origv);
// First, we wrap it in the new compartment. This will return
// a new wrapper.
AutoCompartment ac(cx, wobj);
JSObject *tobj = obj;
if (!ac.enter() || !wcompartment->wrap(cx, &tobj))
return NULL;
// Now, because we need to maintain object identity, we do a
// brain transplant on the old object. At the same time, we
// update the entry in the compartment's wrapper map to point
// to the old wrapper.
JS_ASSERT(tobj != wobj);
if (!wobj->swap(cx, tobj))
return NULL;
pmap.put(targetv, ObjectValue(*wobj));
}
// Lastly, update the original object to point to the new one.
if (origobj->compartment() != destination) {
AutoCompartment ac(cx, origobj);
JSObject *tobj = obj;
if (!ac.enter() || !JS_WrapObject(cx, &tobj))
return NULL;
if (!origobj->swap(cx, tobj))
return NULL;
origobj->compartment()->crossCompartmentWrappers.put(targetv, origv);
}
return obj;
}
/*
* The location object is special. There is the location object itself and
* then the location object wrapper. Because there are no direct references to
* the location object itself, we don't want the old obj (|origobj| here) to
* become the new wrapper but the wrapper itself instead. This leads to very
* subtle differences between js_TransplantObjectWithWrapper and
* JS_TransplantObject.
*/
JS_FRIEND_API(JSObject *)
js_TransplantObjectWithWrapper(JSContext *cx,
JSObject *origobj,
JSObject *origwrapper,
JSObject *targetobj,
JSObject *targetwrapper)
{
JSObject *obj;
JSCompartment *destination = targetobj->compartment();
WrapperMap &map = destination->crossCompartmentWrappers;
// |origv| is the map entry we're looking up. The map entries are going to
// be for the location object itself.
Value origv = ObjectValue(*origobj);
// There might already be a wrapper for the original object in the new
// compartment.
if (WrapperMap::Ptr p = map.lookup(origv)) {
// There is. Make the existing wrapper a same compartment location
// wrapper (swapping it with the given new wrapper).
obj = &p->value.toObject();
map.remove(p);
if (!obj->swap(cx, targetwrapper))
return NULL;
} else {
// Otherwise, use the passed-in wrapper as the same compartment
// location wrapper.
obj = targetwrapper;
}
// Now, iterate through other scopes looking for references to the old
// location object. Note that the entries in the maps are for |origobj|
// and not |origwrapper|. They need to be updated to point at the new
// location object.
Value targetv = ObjectValue(*targetobj);
CompartmentVector &vector = cx->runtime->compartments;
AutoValueVector toTransplant(cx);
if (!toTransplant.reserve(vector.length()))
return NULL;
for (JSCompartment **p = vector.begin(), **end = vector.end(); p != end; ++p) {
WrapperMap &pmap = (*p)->crossCompartmentWrappers;
if (WrapperMap::Ptr wp = pmap.lookup(origv)) {
// We found a wrapper. Remember and root it.
toTransplant.infallibleAppend(wp->value);
}
}
for (Value *begin = toTransplant.begin(), *end = toTransplant.end(); begin != end; ++begin) {
JSObject *wobj = &begin->toObject();
JSCompartment *wcompartment = wobj->compartment();
WrapperMap &pmap = wcompartment->crossCompartmentWrappers;
JS_ASSERT(pmap.lookup(origv));
pmap.remove(origv);
// First, we wrap it in the new compartment. This will return a
// new wrapper.
AutoCompartment ac(cx, wobj);
JSObject *tobj = targetobj;
if (!ac.enter() || !wcompartment->wrap(cx, &tobj))
return NULL;
// Now, because we need to maintain object identity, we do a brain
// transplant on the old object. At the same time, we update the
// entry in the compartment's wrapper map to point to the old
// wrapper.
JS_ASSERT(tobj != wobj);
if (!wobj->swap(cx, tobj))
return NULL;
pmap.put(targetv, ObjectValue(*wobj));
}
// Lastly, update the original object to point to the new one. However, as
// mentioned above, we do the transplant on the wrapper, not the object
// itself, since all of the references are to the object itself.
{
AutoCompartment ac(cx, origobj);
JSObject *tobj = obj;
if (!ac.enter() || !JS_WrapObject(cx, &tobj))
return NULL;
if (!origwrapper->swap(cx, tobj))
return NULL;
origwrapper->compartment()->crossCompartmentWrappers.put(targetv,
ObjectValue(*origwrapper));
}
return obj;
}
JS_PUBLIC_API(JSObject *)
JS_GetGlobalObject(JSContext *cx)
{
return cx->globalObject;
}
JS_PUBLIC_API(void)
JS_SetGlobalObject(JSContext *cx, JSObject *obj)
{
CHECK_REQUEST(cx);
cx->globalObject = obj;
if (!cx->hasfp())
cx->resetCompartment();
}
JS_PUBLIC_API(JSBool)
JS_InitStandardClasses(JSContext *cx, JSObject *obj)
{
JS_THREADSAFE_ASSERT(cx->compartment != cx->runtime->atomsCompartment);
CHECK_REQUEST(cx);
/*
* JS_SetGlobalObject might or might not change cx's compartment, so call
* it before assertSameCompartment. (The API contract is that *after* this,
* cx and obj must be in the same compartment.)
*/
if (!cx->globalObject)
JS_SetGlobalObject(cx, obj);
assertSameCompartment(cx, obj);
return obj->asGlobal()->initStandardClasses(cx);
}
#define CLASP(name) (&name##Class)
#define TYPED_ARRAY_CLASP(type) (&TypedArray::fastClasses[TypedArray::type])
#define EAGER_ATOM(name) ATOM_OFFSET(name), NULL
#define EAGER_CLASS_ATOM(name) CLASS_ATOM_OFFSET(name), NULL
#define EAGER_ATOM_AND_CLASP(name) EAGER_CLASS_ATOM(name), CLASP(name)
#define LAZY_ATOM(name) ATOM_OFFSET(lazy.name), js_##name##_str
typedef struct JSStdName {
JSObjectOp init;
size_t atomOffset; /* offset of atom pointer in JSAtomState */
const char *name; /* null if atom is pre-pinned, else name */
Class *clasp;
} JSStdName;
static JSAtom *
StdNameToAtom(JSContext *cx, JSStdName *stdn)
{
size_t offset;
JSAtom *atom;
const char *name;
offset = stdn->atomOffset;
atom = OFFSET_TO_ATOM(cx->runtime, offset);
if (!atom) {
name = stdn->name;
if (name) {
atom = js_Atomize(cx, name, strlen(name), InternAtom);
OFFSET_TO_ATOM(cx->runtime, offset) = atom;
}
}
return atom;
}
/*
* Table of class initializers and their atom offsets in rt->atomState.
* If you add a "standard" class, remember to update this table.
*/
static JSStdName standard_class_atoms[] = {
{js_InitFunctionClass, EAGER_ATOM_AND_CLASP(Function)},
{js_InitObjectClass, EAGER_ATOM_AND_CLASP(Object)},
{js_InitArrayClass, EAGER_ATOM_AND_CLASP(Array)},
{js_InitBooleanClass, EAGER_ATOM_AND_CLASP(Boolean)},
{js_InitDateClass, EAGER_ATOM_AND_CLASP(Date)},
{js_InitMathClass, EAGER_ATOM_AND_CLASP(Math)},
{js_InitNumberClass, EAGER_ATOM_AND_CLASP(Number)},
{js_InitStringClass, EAGER_ATOM_AND_CLASP(String)},
{js_InitExceptionClasses, EAGER_ATOM_AND_CLASP(Error)},
{js_InitRegExpClass, EAGER_ATOM_AND_CLASP(RegExp)},
#if JS_HAS_XML_SUPPORT
{js_InitXMLClass, EAGER_ATOM_AND_CLASP(XML)},
{js_InitNamespaceClass, EAGER_ATOM_AND_CLASP(Namespace)},
{js_InitQNameClass, EAGER_ATOM_AND_CLASP(QName)},
#endif
#if JS_HAS_GENERATORS
{js_InitIteratorClasses, EAGER_ATOM_AND_CLASP(StopIteration)},
#endif
{js_InitJSONClass, EAGER_ATOM_AND_CLASP(JSON)},
{js_InitTypedArrayClasses, EAGER_CLASS_ATOM(ArrayBuffer), &js::ArrayBuffer::slowClass},
{js_InitWeakMapClass, EAGER_CLASS_ATOM(WeakMap), &js::WeakMapClass},
{NULL, 0, NULL, NULL}
};
/*
* Table of top-level function and constant names and their init functions.
* If you add a "standard" global function or property, remember to update
* this table.
*/
static JSStdName standard_class_names[] = {
{js_InitObjectClass, EAGER_ATOM(eval), CLASP(Object)},
/* Global properties and functions defined by the Number class. */
{js_InitNumberClass, EAGER_ATOM(NaN), CLASP(Number)},
{js_InitNumberClass, EAGER_ATOM(Infinity), CLASP(Number)},
{js_InitNumberClass, LAZY_ATOM(isNaN), CLASP(Number)},
{js_InitNumberClass, LAZY_ATOM(isFinite), CLASP(Number)},
{js_InitNumberClass, LAZY_ATOM(parseFloat), CLASP(Number)},
{js_InitNumberClass, LAZY_ATOM(parseInt), CLASP(Number)},
/* String global functions. */
{js_InitStringClass, LAZY_ATOM(escape), CLASP(String)},
{js_InitStringClass, LAZY_ATOM(unescape), CLASP(String)},
{js_InitStringClass, LAZY_ATOM(decodeURI), CLASP(String)},
{js_InitStringClass, LAZY_ATOM(encodeURI), CLASP(String)},
{js_InitStringClass, LAZY_ATOM(decodeURIComponent), CLASP(String)},
{js_InitStringClass, LAZY_ATOM(encodeURIComponent), CLASP(String)},
#if JS_HAS_UNEVAL
{js_InitStringClass, LAZY_ATOM(uneval), CLASP(String)},
#endif
/* Exception constructors. */
{js_InitExceptionClasses, EAGER_CLASS_ATOM(Error), CLASP(Error)},
{js_InitExceptionClasses, EAGER_CLASS_ATOM(InternalError), CLASP(Error)},
{js_InitExceptionClasses, EAGER_CLASS_ATOM(EvalError), CLASP(Error)},
{js_InitExceptionClasses, EAGER_CLASS_ATOM(RangeError), CLASP(Error)},
{js_InitExceptionClasses, EAGER_CLASS_ATOM(ReferenceError), CLASP(Error)},
{js_InitExceptionClasses, EAGER_CLASS_ATOM(SyntaxError), CLASP(Error)},
{js_InitExceptionClasses, EAGER_CLASS_ATOM(TypeError), CLASP(Error)},
{js_InitExceptionClasses, EAGER_CLASS_ATOM(URIError), CLASP(Error)},
#if JS_HAS_XML_SUPPORT
{js_InitXMLClass, LAZY_ATOM(XMLList), CLASP(XML)},
{js_InitXMLClass, LAZY_ATOM(isXMLName), CLASP(XML)},
#endif
#if JS_HAS_GENERATORS
{js_InitIteratorClasses, EAGER_ATOM_AND_CLASP(Iterator)},
#endif
/* Typed Arrays */
{js_InitTypedArrayClasses, EAGER_CLASS_ATOM(ArrayBuffer), &ArrayBufferClass},
{js_InitTypedArrayClasses, EAGER_CLASS_ATOM(Int8Array), TYPED_ARRAY_CLASP(TYPE_INT8)},
{js_InitTypedArrayClasses, EAGER_CLASS_ATOM(Uint8Array), TYPED_ARRAY_CLASP(TYPE_UINT8)},
{js_InitTypedArrayClasses, EAGER_CLASS_ATOM(Int16Array), TYPED_ARRAY_CLASP(TYPE_INT16)},
{js_InitTypedArrayClasses, EAGER_CLASS_ATOM(Uint16Array), TYPED_ARRAY_CLASP(TYPE_UINT16)},
{js_InitTypedArrayClasses, EAGER_CLASS_ATOM(Int32Array), TYPED_ARRAY_CLASP(TYPE_INT32)},
{js_InitTypedArrayClasses, EAGER_CLASS_ATOM(Uint32Array), TYPED_ARRAY_CLASP(TYPE_UINT32)},
{js_InitTypedArrayClasses, EAGER_CLASS_ATOM(Float32Array), TYPED_ARRAY_CLASP(TYPE_FLOAT32)},
{js_InitTypedArrayClasses, EAGER_CLASS_ATOM(Float64Array), TYPED_ARRAY_CLASP(TYPE_FLOAT64)},
{js_InitTypedArrayClasses, EAGER_CLASS_ATOM(Uint8ClampedArray),
TYPED_ARRAY_CLASP(TYPE_UINT8_CLAMPED)},
{js_InitProxyClass, EAGER_ATOM_AND_CLASP(Proxy)},
{NULL, 0, NULL, NULL}
};
static JSStdName object_prototype_names[] = {
/* Object.prototype properties (global delegates to Object.prototype). */
{js_InitObjectClass, EAGER_ATOM(proto), CLASP(Object)},
#if JS_HAS_TOSOURCE
{js_InitObjectClass, EAGER_ATOM(toSource), CLASP(Object)},
#endif
{js_InitObjectClass, EAGER_ATOM(toString), CLASP(Object)},
{js_InitObjectClass, EAGER_ATOM(toLocaleString), CLASP(Object)},
{js_InitObjectClass, EAGER_ATOM(valueOf), CLASP(Object)},
#if JS_HAS_OBJ_WATCHPOINT
{js_InitObjectClass, LAZY_ATOM(watch), CLASP(Object)},
{js_InitObjectClass, LAZY_ATOM(unwatch), CLASP(Object)},
#endif
{js_InitObjectClass, LAZY_ATOM(hasOwnProperty), CLASP(Object)},
{js_InitObjectClass, LAZY_ATOM(isPrototypeOf), CLASP(Object)},
{js_InitObjectClass, LAZY_ATOM(propertyIsEnumerable), CLASP(Object)},
#if OLD_GETTER_SETTER_METHODS
{js_InitObjectClass, LAZY_ATOM(defineGetter), CLASP(Object)},
{js_InitObjectClass, LAZY_ATOM(defineSetter), CLASP(Object)},
{js_InitObjectClass, LAZY_ATOM(lookupGetter), CLASP(Object)},
{js_InitObjectClass, LAZY_ATOM(lookupSetter), CLASP(Object)},
#endif
{NULL, 0, NULL, NULL}
};
JS_PUBLIC_API(JSBool)
JS_ResolveStandardClass(JSContext *cx, JSObject *obj, jsid id, JSBool *resolved)
{
JSString *idstr;
JSRuntime *rt;
JSAtom *atom;
JSStdName *stdnm;
uintN i;
CHECK_REQUEST(cx);
assertSameCompartment(cx, obj, id);
*resolved = JS_FALSE;
rt = cx->runtime;
JS_ASSERT(rt->state != JSRTS_DOWN);
if (rt->state == JSRTS_LANDING || !JSID_IS_ATOM(id))
return JS_TRUE;
idstr = JSID_TO_STRING(id);
/* Check whether we're resolving 'undefined', and define it if so. */
atom = rt->atomState.typeAtoms[JSTYPE_VOID];
if (idstr == atom) {
*resolved = JS_TRUE;
return obj->defineProperty(cx, atom->asPropertyName(), UndefinedValue(),
JS_PropertyStub, JS_StrictPropertyStub,
JSPROP_PERMANENT | JSPROP_READONLY);
}
/* Try for class constructors/prototypes named by well-known atoms. */
stdnm = NULL;
for (i = 0; standard_class_atoms[i].init; i++) {
JS_ASSERT(standard_class_atoms[i].clasp);
atom = OFFSET_TO_ATOM(rt, standard_class_atoms[i].atomOffset);
if (idstr == atom) {
stdnm = &standard_class_atoms[i];
break;
}
}
if (!stdnm) {
/* Try less frequently used top-level functions and constants. */
for (i = 0; standard_class_names[i].init; i++) {
JS_ASSERT(standard_class_names[i].clasp);
atom = StdNameToAtom(cx, &standard_class_names[i]);
if (!atom)
return JS_FALSE;
if (idstr == atom) {
stdnm = &standard_class_names[i];
break;
}
}
if (!stdnm && !obj->getProto()) {
/*
* Try even less frequently used names delegated from the global
* object to Object.prototype, but only if the Object class hasn't
* yet been initialized.
*/
for (i = 0; object_prototype_names[i].init; i++) {
JS_ASSERT(object_prototype_names[i].clasp);
atom = StdNameToAtom(cx, &object_prototype_names[i]);
if (!atom)
return JS_FALSE;
if (idstr == atom) {
stdnm = &object_prototype_names[i];
break;
}
}
}
}
if (stdnm) {
/*
* If this standard class is anonymous, then we don't want to resolve
* by name.
*/
JS_ASSERT(obj->isGlobal());
if (stdnm->clasp->flags & JSCLASS_IS_ANONYMOUS)
return JS_TRUE;
if (IsStandardClassResolved(obj, stdnm->clasp))
return JS_TRUE;
if (!stdnm->init(cx, obj))
return JS_FALSE;
*resolved = JS_TRUE;
}
return JS_TRUE;
}
JS_PUBLIC_API(JSBool)
JS_EnumerateStandardClasses(JSContext *cx, JSObject *obj)
{
JSRuntime *rt;
uintN i;
CHECK_REQUEST(cx);
assertSameCompartment(cx, obj);
rt = cx->runtime;
/*
* Check whether we need to bind 'undefined' and define it if so.
* Since ES5 15.1.1.3 undefined can't be deleted.
*/
PropertyName *name = rt->atomState.typeAtoms[JSTYPE_VOID];
if (!obj->nativeContains(cx, ATOM_TO_JSID(name)) &&
!obj->defineProperty(cx, name, UndefinedValue(),
JS_PropertyStub, JS_StrictPropertyStub,
JSPROP_PERMANENT | JSPROP_READONLY)) {
return JS_FALSE;
}
/* Initialize any classes that have not been initialized yet. */
for (i = 0; standard_class_atoms[i].init; i++) {
if (!js::IsStandardClassResolved(obj, standard_class_atoms[i].clasp) &&
!standard_class_atoms[i].init(cx, obj))
{
return JS_FALSE;
}
}
return JS_TRUE;
}
static JSIdArray *
NewIdArray(JSContext *cx, jsint length)
{
JSIdArray *ida;
ida = (JSIdArray *)
cx->calloc_(offsetof(JSIdArray, vector) + length * sizeof(jsval));
if (ida)
ida->length = length;
return ida;
}
/*
* Unlike realloc(3), this function frees ida on failure.
*/
static JSIdArray *
SetIdArrayLength(JSContext *cx, JSIdArray *ida, jsint length)
{
JSIdArray *rida;
rida = (JSIdArray *)
JS_realloc(cx, ida,
offsetof(JSIdArray, vector) + length * sizeof(jsval));
if (!rida) {
JS_DestroyIdArray(cx, ida);
} else {
rida->length = length;
}
return rida;
}
static JSIdArray *
AddAtomToArray(JSContext *cx, JSAtom *atom, JSIdArray *ida, jsint *ip)
{
jsint i, length;
i = *ip;
length = ida->length;
if (i >= length) {
ida = SetIdArrayLength(cx, ida, JS_MAX(length * 2, 8));
if (!ida)
return NULL;
JS_ASSERT(i < ida->length);
}
ida->vector[i].init(ATOM_TO_JSID(atom));
*ip = i + 1;
return ida;
}
static JSIdArray *
EnumerateIfResolved(JSContext *cx, JSObject *obj, JSAtom *atom, JSIdArray *ida,
jsint *ip, JSBool *foundp)
{
*foundp = obj->nativeContains(cx, ATOM_TO_JSID(atom));
if (*foundp)
ida = AddAtomToArray(cx, atom, ida, ip);
return ida;
}
JS_PUBLIC_API(JSIdArray *)
JS_EnumerateResolvedStandardClasses(JSContext *cx, JSObject *obj, JSIdArray *ida)
{
JSRuntime *rt;
jsint i, j, k;
JSAtom *atom;
JSBool found;
JSObjectOp init;
CHECK_REQUEST(cx);
assertSameCompartment(cx, obj, ida);
rt = cx->runtime;
if (ida) {
i = ida->length;
} else {
ida = NewIdArray(cx, 8);
if (!ida)
return NULL;
i = 0;
}
/* Check whether 'undefined' has been resolved and enumerate it if so. */
atom = rt->atomState.typeAtoms[JSTYPE_VOID];
ida = EnumerateIfResolved(cx, obj, atom, ida, &i, &found);
if (!ida)
return NULL;
/* Enumerate only classes that *have* been resolved. */
for (j = 0; standard_class_atoms[j].init; j++) {
atom = OFFSET_TO_ATOM(rt, standard_class_atoms[j].atomOffset);
ida = EnumerateIfResolved(cx, obj, atom, ida, &i, &found);
if (!ida)
return NULL;
if (found) {
init = standard_class_atoms[j].init;
for (k = 0; standard_class_names[k].init; k++) {
if (standard_class_names[k].init == init) {
atom = StdNameToAtom(cx, &standard_class_names[k]);
ida = AddAtomToArray(cx, atom, ida, &i);
if (!ida)
return NULL;
}
}
if (init == js_InitObjectClass) {
for (k = 0; object_prototype_names[k].init; k++) {
atom = StdNameToAtom(cx, &object_prototype_names[k]);
ida = AddAtomToArray(cx, atom, ida, &i);
if (!ida)
return NULL;
}
}
}
}
/* Trim to exact length. */
return SetIdArrayLength(cx, ida, i);
}
#undef CLASP
#undef EAGER_ATOM
#undef EAGER_CLASS_ATOM
#undef EAGER_ATOM_CLASP
#undef LAZY_ATOM
JS_PUBLIC_API(JSBool)
JS_GetClassObject(JSContext *cx, JSObject *obj, JSProtoKey key, JSObject **objp)
{
CHECK_REQUEST(cx);
assertSameCompartment(cx, obj);
return js_GetClassObject(cx, obj, key, objp);
}
JS_PUBLIC_API(JSObject *)
JS_GetGlobalForObject(JSContext *cx, JSObject *obj)
{
assertSameCompartment(cx, obj);
return obj->getGlobal();
}
JS_PUBLIC_API(JSObject *)
JS_GetGlobalForScopeChain(JSContext *cx)
{
CHECK_REQUEST(cx);
return GetGlobalForScopeChain(cx);
}
JS_PUBLIC_API(jsval)
JS_ComputeThis(JSContext *cx, jsval *vp)
{
assertSameCompartment(cx, JSValueArray(vp, 2));
CallReceiver call = CallReceiverFromVp(vp);
if (!BoxNonStrictThis(cx, call))
return JSVAL_NULL;
return call.thisv();
}
JS_PUBLIC_API(void *)
JS_malloc(JSContext *cx, size_t nbytes)
{
CHECK_REQUEST(cx);
return cx->malloc_(nbytes);
}
JS_PUBLIC_API(void *)
JS_realloc(JSContext *cx, void *p, size_t nbytes)
{
CHECK_REQUEST(cx);
return cx->realloc_(p, nbytes);
}
JS_PUBLIC_API(void)
JS_free(JSContext *cx, void *p)
{
return cx->free_(p);
}
JS_PUBLIC_API(void)
JS_updateMallocCounter(JSContext *cx, size_t nbytes)
{
return cx->runtime->updateMallocCounter(nbytes);
}
JS_PUBLIC_API(char *)
JS_strdup(JSContext *cx, const char *s)
{
size_t n;
void *p;
n = strlen(s) + 1;
p = cx->malloc_(n);
if (!p)
return NULL;
return (char *)memcpy(p, s, n);
}
JS_PUBLIC_API(JSBool)
JS_NewNumberValue(JSContext *cx, jsdouble d, jsval *rval)
{
d = JS_CANONICALIZE_NAN(d);
rval->setNumber(d);
return JS_TRUE;
}
#undef JS_AddRoot
JS_PUBLIC_API(JSBool)
JS_AddValueRoot(JSContext *cx, jsval *vp)
{
CHECK_REQUEST(cx);
return js_AddRoot(cx, vp, NULL);
}
JS_PUBLIC_API(JSBool)
JS_AddStringRoot(JSContext *cx, JSString **rp)
{
CHECK_REQUEST(cx);
return js_AddGCThingRoot(cx, (void **)rp, NULL);
}
JS_PUBLIC_API(JSBool)
JS_AddObjectRoot(JSContext *cx, JSObject **rp)
{
CHECK_REQUEST(cx);
return js_AddGCThingRoot(cx, (void **)rp, NULL);
}
JS_PUBLIC_API(JSBool)
JS_AddGCThingRoot(JSContext *cx, void **rp)
{
CHECK_REQUEST(cx);
return js_AddGCThingRoot(cx, (void **)rp, NULL);
}
JS_PUBLIC_API(JSBool)
JS_AddNamedValueRoot(JSContext *cx, jsval *vp, const char *name)
{
CHECK_REQUEST(cx);
return js_AddRoot(cx, vp, name);
}
JS_PUBLIC_API(JSBool)
JS_AddNamedStringRoot(JSContext *cx, JSString **rp, const char *name)
{
CHECK_REQUEST(cx);
return js_AddGCThingRoot(cx, (void **)rp, name);
}
JS_PUBLIC_API(JSBool)
JS_AddNamedObjectRoot(JSContext *cx, JSObject **rp, const char *name)
{
CHECK_REQUEST(cx);
return js_AddGCThingRoot(cx, (void **)rp, name);
}
JS_PUBLIC_API(JSBool)
JS_AddNamedScriptRoot(JSContext *cx, JSScript **rp, const char *name)
{
CHECK_REQUEST(cx);
return js_AddGCThingRoot(cx, (void **)rp, name);
}
JS_PUBLIC_API(JSBool)
JS_AddNamedGCThingRoot(JSContext *cx, void **rp, const char *name)
{
CHECK_REQUEST(cx);
return js_AddGCThingRoot(cx, (void **)rp, name);
}
JS_PUBLIC_API(JSBool)
JS_RemoveValueRoot(JSContext *cx, jsval *vp)
{
CHECK_REQUEST(cx);
return js_RemoveRoot(cx->runtime, (void *)vp);
}
JS_PUBLIC_API(JSBool)
JS_RemoveStringRoot(JSContext *cx, JSString **rp)
{
CHECK_REQUEST(cx);
return js_RemoveRoot(cx->runtime, (void *)rp);
}
JS_PUBLIC_API(JSBool)
JS_RemoveObjectRoot(JSContext *cx, JSObject **rp)
{
CHECK_REQUEST(cx);
return js_RemoveRoot(cx->runtime, (void *)rp);
}
JS_PUBLIC_API(JSBool)
JS_RemoveScriptRoot(JSContext *cx, JSScript **rp)
{
CHECK_REQUEST(cx);
return js_RemoveRoot(cx->runtime, (void *)rp);
}
JS_PUBLIC_API(JSBool)
JS_RemoveGCThingRoot(JSContext *cx, void **rp)
{
CHECK_REQUEST(cx);
return js_RemoveRoot(cx->runtime, (void *)rp);
}
JS_NEVER_INLINE JS_PUBLIC_API(void)
JS_AnchorPtr(void *p)
{
}
#ifdef DEBUG
JS_PUBLIC_API(void)
JS_DumpNamedRoots(JSRuntime *rt,
void (*dump)(const char *name, void *rp, JSGCRootType type, void *data),
void *data)
{
js_DumpNamedRoots(rt, dump, data);
}
#endif /* DEBUG */
JS_PUBLIC_API(uint32_t)
JS_MapGCRoots(JSRuntime *rt, JSGCRootMapFun map, void *data)
{
return js_MapGCRoots(rt, map, data);
}
JS_PUBLIC_API(JSBool)
JS_LockGCThing(JSContext *cx, void *thing)
{
JSBool ok;
CHECK_REQUEST(cx);
ok = js_LockGCThingRT(cx->runtime, thing);
if (!ok)
JS_ReportOutOfMemory(cx);
return ok;
}
JS_PUBLIC_API(JSBool)
JS_LockGCThingRT(JSRuntime *rt, void *thing)
{
return js_LockGCThingRT(rt, thing);
}
JS_PUBLIC_API(JSBool)
JS_UnlockGCThing(JSContext *cx, void *thing)
{
CHECK_REQUEST(cx);
js_UnlockGCThingRT(cx->runtime, thing);
return true;
}
JS_PUBLIC_API(JSBool)
JS_UnlockGCThingRT(JSRuntime *rt, void *thing)
{
js_UnlockGCThingRT(rt, thing);
return true;
}
JS_PUBLIC_API(void)
JS_SetExtraGCRootsTracer(JSRuntime *rt, JSTraceDataOp traceOp, void *data)
{
rt->gcBlackRootsTraceOp = traceOp;
rt->gcBlackRootsData = data;
}
JS_PUBLIC_API(void)
JS_TraceRuntime(JSTracer *trc)
{
TraceRuntime(trc);
}
JS_PUBLIC_API(void)
JS_TraceChildren(JSTracer *trc, void *thing, JSGCTraceKind kind)
{
js::TraceChildren(trc, thing, kind);
}
JS_PUBLIC_API(void)
JS_CallTracer(JSTracer *trc, void *thing, JSGCTraceKind kind)
{
js::CallTracer(trc, thing, kind);
}
#ifdef DEBUG
#ifdef HAVE_XPCONNECT
#include "dump_xpc.h"
#endif
JS_PUBLIC_API(void)
JS_PrintTraceThingInfo(char *buf, size_t bufsize, JSTracer *trc, void *thing,
JSGCTraceKind kind, JSBool details)
{
const char *name = NULL; /* silence uninitialized warning */
size_t n;
if (bufsize == 0)
return;
switch (kind) {
case JSTRACE_OBJECT:
{
JSObject *obj = (JSObject *)thing;
Class *clasp = obj->getClass();
name = clasp->name;
#ifdef HAVE_XPCONNECT
if (clasp->flags & JSCLASS_PRIVATE_IS_NSISUPPORTS) {
void *privateThing = obj->getPrivate();
if (privateThing) {
const char *xpcClassName = GetXPCObjectClassName(privateThing);
if (xpcClassName)
name = xpcClassName;
}
}
#endif
break;
}
case JSTRACE_STRING:
name = ((JSString *)thing)->isDependent()
? "substring"
: "string";
break;
case JSTRACE_SCRIPT:
name = "script";
break;
case JSTRACE_SHAPE:
name = "shape";
break;
case JSTRACE_BASE_SHAPE:
name = "base_shape";
break;
case JSTRACE_TYPE_OBJECT:
name = "type_object";
break;
#if JS_HAS_XML_SUPPORT
case JSTRACE_XML:
name = "xml";
break;
#endif
}
n = strlen(name);
if (n > bufsize - 1)
n = bufsize - 1;
memcpy(buf, name, n + 1);
buf += n;
bufsize -= n;
if (details && bufsize > 2) {
*buf++ = ' ';
bufsize--;
switch (kind) {
case JSTRACE_OBJECT:
{
JSObject *obj = (JSObject *)thing;
Class *clasp = obj->getClass();
if (clasp == &FunctionClass) {
JSFunction *fun = obj->toFunction();
if (!fun) {
JS_snprintf(buf, bufsize, "<newborn>");
} else if (fun != obj) {
JS_snprintf(buf, bufsize, "%p", fun);
} else {
if (fun->atom)
PutEscapedString(buf, bufsize, fun->atom, 0);
}
} else if (clasp->flags & JSCLASS_HAS_PRIVATE) {
JS_snprintf(buf, bufsize, "%p", obj->getPrivate());
} else {
JS_snprintf(buf, bufsize, "<no private>");
}
break;
}
case JSTRACE_STRING:
{
JSString *str = (JSString *)thing;
if (str->isLinear())
PutEscapedString(buf, bufsize, &str->asLinear(), 0);
else
JS_snprintf(buf, bufsize, "<rope: length %d>", (int)str->length());
break;
}
case JSTRACE_SCRIPT:
{
JSScript *script = static_cast<JSScript *>(thing);
JS_snprintf(buf, bufsize, "%s:%u", script->filename, unsigned(script->lineno));
break;
}
case JSTRACE_SHAPE:
case JSTRACE_BASE_SHAPE:
case JSTRACE_TYPE_OBJECT:
break;
#if JS_HAS_XML_SUPPORT
case JSTRACE_XML:
{
extern const char *js_xml_class_str[];
JSXML *xml = (JSXML *)thing;
JS_snprintf(buf, bufsize, "%s", js_xml_class_str[xml->xml_class]);
break;
}
#endif
}
}
buf[bufsize - 1] = '\0';
}
extern JS_PUBLIC_API(const char *)
JS_GetTraceEdgeName(JSTracer *trc, char *buffer, int bufferSize)
{
if (trc->debugPrinter) {
trc->debugPrinter(trc, buffer, bufferSize);
return buffer;
}
if (trc->debugPrintIndex != (size_t) - 1) {
JS_snprintf(buffer, bufferSize, "%s[%lu]",
(const char *)trc->debugPrintArg,
trc->debugPrintIndex);
return buffer;
}
return (const char*)trc->debugPrintArg;
}
typedef struct JSHeapDumpNode JSHeapDumpNode;
struct JSHeapDumpNode {
void *thing;
JSGCTraceKind kind;
JSHeapDumpNode *next; /* next sibling */
JSHeapDumpNode *parent; /* node with the thing that refer to thing
from this node */
char edgeName[1]; /* name of the edge from parent->thing
into thing */
};
typedef struct JSDumpingTracer {
JSTracer base;
JSDHashTable visited;
JSBool ok;
void *startThing;
void *thingToFind;
void *thingToIgnore;
JSHeapDumpNode *parentNode;
JSHeapDumpNode **lastNodep;
char buffer[200];
} JSDumpingTracer;
static void
DumpNotify(JSTracer *trc, void *thing, JSGCTraceKind kind)
{
JSDumpingTracer *dtrc;
JSContext *cx;
JSDHashEntryStub *entry;
JSHeapDumpNode *node;
const char *edgeName;
size_t edgeNameSize;
JS_ASSERT(trc->callback == DumpNotify);
dtrc = (JSDumpingTracer *)trc;
if (!dtrc->ok || thing == dtrc->thingToIgnore)
return;
cx = trc->context;
/*
* Check if we have already seen thing unless it is thingToFind to include
* it to the graph each time we reach it and print all live things that
* refer to thingToFind.
*
* This does not print all possible paths leading to thingToFind since
* when a thing A refers directly or indirectly to thingToFind and A is
* present several times in the graph, we will print only the first path
* leading to A and thingToFind, other ways to reach A will be ignored.
*/
if (dtrc->thingToFind != thing) {
/*
* The startThing check allows to avoid putting startThing into the
* hash table before tracing startThing in JS_DumpHeap.
*/
if (thing == dtrc->startThing)
return;
entry = (JSDHashEntryStub *)
JS_DHashTableOperate(&dtrc->visited, thing, JS_DHASH_ADD);
if (!entry) {
JS_ReportOutOfMemory(cx);
dtrc->ok = JS_FALSE;
return;
}
if (entry->key)
return;
entry->key = thing;
}
edgeName = JS_GetTraceEdgeName(&dtrc->base, dtrc->buffer, sizeof(dtrc->buffer));
edgeNameSize = strlen(edgeName) + 1;
size_t bytes = offsetof(JSHeapDumpNode, edgeName) + edgeNameSize;
node = (JSHeapDumpNode *) OffTheBooks::malloc_(bytes);
if (!node) {
dtrc->ok = JS_FALSE;
return;
}
node->thing = thing;
node->kind = kind;
node->next = NULL;
node->parent = dtrc->parentNode;
memcpy(node->edgeName, edgeName, edgeNameSize);
JS_ASSERT(!*dtrc->lastNodep);
*dtrc->lastNodep = node;
dtrc->lastNodep = &node->next;
}
/* Dump node and the chain that leads to thing it contains. */
static JSBool
DumpNode(JSDumpingTracer *dtrc, FILE* fp, JSHeapDumpNode *node)
{
JSHeapDumpNode *prev, *following;
size_t chainLimit;
JSBool ok;
enum { MAX_PARENTS_TO_PRINT = 10 };
JS_PrintTraceThingInfo(dtrc->buffer, sizeof dtrc->buffer,
&dtrc->base, node->thing, node->kind, JS_TRUE);
if (fprintf(fp, "%p %-22s via ", node->thing, dtrc->buffer) < 0)
return JS_FALSE;
/*
* We need to print the parent chain in the reverse order. To do it in
* O(N) time where N is the chain length we first reverse the chain while
* searching for the top and then print each node while restoring the
* chain order.
*/
chainLimit = MAX_PARENTS_TO_PRINT;
prev = NULL;
for (;;) {
following = node->parent;
node->parent = prev;
prev = node;
node = following;
if (!node)
break;
if (chainLimit == 0) {
if (fputs("...", fp) < 0)
return JS_FALSE;
break;
}
--chainLimit;
}
node = prev;
prev = following;
ok = JS_TRUE;
do {
/* Loop must continue even when !ok to restore the parent chain. */
if (ok) {
if (!prev) {
/* Print edge from some runtime root or startThing. */
if (fputs(node->edgeName, fp) < 0)
ok = JS_FALSE;
} else {
JS_PrintTraceThingInfo(dtrc->buffer, sizeof dtrc->buffer,
&dtrc->base, prev->thing, prev->kind,
JS_FALSE);
if (fprintf(fp, "(%p %s).%s",
prev->thing, dtrc->buffer, node->edgeName) < 0) {
ok = JS_FALSE;
}
}
}
following = node->parent;
node->parent = prev;
prev = node;
node = following;
} while (node);
return ok && putc('\n', fp) >= 0;
}
JS_PUBLIC_API(JSBool)
JS_DumpHeap(JSContext *cx, FILE *fp, void* startThing, JSGCTraceKind startKind,
void *thingToFind, size_t maxDepth, void *thingToIgnore)
{
JSDumpingTracer dtrc;
JSHeapDumpNode *node, *children, *next, *parent;
size_t depth;
JSBool thingToFindWasTraced;
if (maxDepth == 0)
return JS_TRUE;
JS_TRACER_INIT(&dtrc.base, cx, DumpNotify);
if (!JS_DHashTableInit(&dtrc.visited, JS_DHashGetStubOps(),
NULL, sizeof(JSDHashEntryStub),
JS_DHASH_DEFAULT_CAPACITY(100))) {
JS_ReportOutOfMemory(cx);
return JS_FALSE;
}
dtrc.ok = JS_TRUE;
dtrc.startThing = startThing;
dtrc.thingToFind = thingToFind;
dtrc.thingToIgnore = thingToIgnore;
dtrc.parentNode = NULL;
node = NULL;
dtrc.lastNodep = &node;
if (!startThing) {
JS_ASSERT(startKind == JSTRACE_OBJECT);
TraceRuntime(&dtrc.base);
} else {
JS_TraceChildren(&dtrc.base, startThing, startKind);
}
depth = 1;
if (!node)
goto dump_out;
thingToFindWasTraced = thingToFind && thingToFind == startThing;
for (;;) {
/*
* Loop must continue even when !dtrc.ok to free all nodes allocated
* so far.
*/
if (dtrc.ok) {
if (thingToFind == NULL || thingToFind == node->thing)
dtrc.ok = DumpNode(&dtrc, fp, node);
/* Descend into children. */
if (dtrc.ok &&
depth < maxDepth &&
(thingToFind != node->thing || !thingToFindWasTraced)) {
dtrc.parentNode = node;
children = NULL;
dtrc.lastNodep = &children;
JS_TraceChildren(&dtrc.base, node->thing, node->kind);
if (thingToFind == node->thing)
thingToFindWasTraced = JS_TRUE;
if (children != NULL) {
++depth;
node = children;
continue;
}
}
}
/* Move to next or parents next and free the node. */
for (;;) {
next = node->next;
parent = node->parent;
Foreground::free_(node);
node = next;
if (node)
break;
if (!parent)
goto dump_out;
JS_ASSERT(depth > 1);
--depth;
node = parent;
}
}
dump_out:
JS_ASSERT(depth == 1);
JS_DHashTableFinish(&dtrc.visited);
return dtrc.ok;
}
#endif /* DEBUG */
extern JS_PUBLIC_API(JSBool)
JS_IsGCMarkingTracer(JSTracer *trc)
{
return IS_GC_MARKING_TRACER(trc);
}
JS_PUBLIC_API(void)
JS_CompartmentGC(JSContext *cx, JSCompartment *comp)
{
/* We cannot GC the atoms compartment alone; use a full GC instead. */
JS_ASSERT(comp != cx->runtime->atomsCompartment);
js::gc::VerifyBarriers(cx, true);
js_GC(cx, comp, GC_NORMAL, gcstats::PUBLIC_API);
}
JS_PUBLIC_API(void)
JS_GC(JSContext *cx)
{
JS_CompartmentGC(cx, NULL);
}
JS_PUBLIC_API(void)
JS_MaybeGC(JSContext *cx)
{
MaybeGC(cx);
}
JS_PUBLIC_API(JSGCCallback)
JS_SetGCCallback(JSContext *cx, JSGCCallback cb)
{
CHECK_REQUEST(cx);
return JS_SetGCCallbackRT(cx->runtime, cb);
}
JS_PUBLIC_API(JSGCCallback)
JS_SetGCCallbackRT(JSRuntime *rt, JSGCCallback cb)
{
JSGCCallback oldcb;
oldcb = rt->gcCallback;
rt->gcCallback = cb;
return oldcb;
}
JS_PUBLIC_API(JSBool)
JS_IsAboutToBeFinalized(JSContext *cx, void *thing)
{
JS_ASSERT(thing);
JS_ASSERT(!cx->runtime->gcIncrementalTracer);
return IsAboutToBeFinalized(cx, (gc::Cell *)thing);
}
JS_PUBLIC_API(void)
JS_SetGCParameter(JSRuntime *rt, JSGCParamKey key, uint32_t value)
{
switch (key) {
case JSGC_MAX_BYTES:
rt->gcMaxBytes = value;
break;
case JSGC_MAX_MALLOC_BYTES:
rt->setGCMaxMallocBytes(value);
break;
case JSGC_STACKPOOL_LIFESPAN:
rt->gcEmptyArenaPoolLifespan = value;
break;
default:
JS_ASSERT(key == JSGC_MODE);
rt->gcMode = JSGCMode(value);
JS_ASSERT(rt->gcMode == JSGC_MODE_GLOBAL ||
rt->gcMode == JSGC_MODE_COMPARTMENT);
return;
}
}
JS_PUBLIC_API(uint32_t)
JS_GetGCParameter(JSRuntime *rt, JSGCParamKey key)
{
switch (key) {
case JSGC_MAX_BYTES:
return rt->gcMaxBytes;
case JSGC_MAX_MALLOC_BYTES:
return rt->gcMaxMallocBytes;
case JSGC_STACKPOOL_LIFESPAN:
return rt->gcEmptyArenaPoolLifespan;
case JSGC_BYTES:
return rt->gcBytes;
case JSGC_MODE:
return uint32_t(rt->gcMode);
case JSGC_UNUSED_CHUNKS:
return uint32_t(rt->gcChunkPool.getEmptyCount());
case JSGC_TOTAL_CHUNKS:
return uint32_t(rt->gcChunkSet.count() + rt->gcChunkPool.getEmptyCount());
default:
JS_ASSERT(key == JSGC_NUMBER);
return rt->gcNumber;
}
}
JS_PUBLIC_API(void)
JS_SetGCParameterForThread(JSContext *cx, JSGCParamKey key, uint32_t value)
{
JS_ASSERT(key == JSGC_MAX_CODE_CACHE_BYTES);
}
JS_PUBLIC_API(uint32_t)
JS_GetGCParameterForThread(JSContext *cx, JSGCParamKey key)
{
JS_ASSERT(key == JSGC_MAX_CODE_CACHE_BYTES);
return 0;
}
JS_PUBLIC_API(void)
JS_FlushCaches(JSContext *cx)
{
}
JS_PUBLIC_API(intN)
JS_AddExternalStringFinalizer(JSStringFinalizeOp finalizer)
{
return JSExternalString::changeFinalizer(NULL, finalizer);
}
JS_PUBLIC_API(intN)
JS_RemoveExternalStringFinalizer(JSStringFinalizeOp finalizer)
{
return JSExternalString::changeFinalizer(finalizer, NULL);
}
JS_PUBLIC_API(JSString *)
JS_NewExternalString(JSContext *cx, const jschar *chars, size_t length, intN type)
{
CHECK_REQUEST(cx);
JSString *s = JSExternalString::new_(cx, chars, length, type, NULL);
Probes::createString(cx, s, length);
return s;
}
extern JS_PUBLIC_API(JSString *)
JS_NewExternalStringWithClosure(JSContext *cx, const jschar *chars, size_t length,
intN type, void *closure)
{
CHECK_REQUEST(cx);
return JSExternalString::new_(cx, chars, length, type, closure);
}
extern JS_PUBLIC_API(JSBool)
JS_IsExternalString(JSContext *cx, JSString *str)
{
CHECK_REQUEST(cx);
return str->isExternal();
}
extern JS_PUBLIC_API(void *)
JS_GetExternalStringClosure(JSContext *cx, JSString *str)
{
CHECK_REQUEST(cx);
return str->asExternal().externalClosure();
}
JS_PUBLIC_API(void)
JS_SetThreadStackLimit(JSContext *cx, jsuword limitAddr)
{
#if JS_STACK_GROWTH_DIRECTION > 0
if (limitAddr == 0)
limitAddr = jsuword(-1);
#endif
cx->stackLimit = limitAddr;
}
JS_PUBLIC_API(void)
JS_SetNativeStackQuota(JSContext *cx, size_t stackSize)
{
#ifdef JS_THREADSAFE
JS_ASSERT(cx->thread());
#endif
#if JS_STACK_GROWTH_DIRECTION > 0
if (stackSize == 0) {
cx->stackLimit = jsuword(-1);
} else {
jsuword stackBase = reinterpret_cast<jsuword>(JS_THREAD_DATA(cx)->nativeStackBase);
JS_ASSERT(stackBase <= size_t(-1) - stackSize);
cx->stackLimit = stackBase + stackSize - 1;
}
#else
if (stackSize == 0) {
cx->stackLimit = 0;
} else {
jsuword stackBase = reinterpret_cast<jsuword>(JS_THREAD_DATA(cx)->nativeStackBase);
JS_ASSERT(stackBase >= stackSize);
cx->stackLimit = stackBase - (stackSize - 1);
}
#endif
}
/************************************************************************/
JS_PUBLIC_API(jsint)
JS_IdArrayLength(JSContext *cx, JSIdArray *ida)
{
return ida->length;
}
JS_PUBLIC_API(jsid)
JS_IdArrayGet(JSContext *cx, JSIdArray *ida, jsint index)
{
JS_ASSERT(index >= 0 && index < ida->length);
return ida->vector[index];
}
JS_PUBLIC_API(void)
JS_DestroyIdArray(JSContext *cx, JSIdArray *ida)
{
cx->free_(ida);
}
JS_PUBLIC_API(JSBool)
JS_ValueToId(JSContext *cx, jsval v, jsid *idp)
{
CHECK_REQUEST(cx);
assertSameCompartment(cx, v);
return ValueToId(cx, v, idp);
}
JS_PUBLIC_API(JSBool)
JS_IdToValue(JSContext *cx, jsid id, jsval *vp)
{
CHECK_REQUEST(cx);
*vp = IdToJsval(id);
assertSameCompartment(cx, *vp);
return JS_TRUE;
}
JS_PUBLIC_API(JSBool)
JS_DefaultValue(JSContext *cx, JSObject *obj, JSType hint, jsval *vp)
{
CHECK_REQUEST(cx);
JS_ASSERT(obj != NULL);
JS_ASSERT(hint == JSTYPE_VOID || hint == JSTYPE_STRING || hint == JSTYPE_NUMBER);
return obj->defaultValue(cx, hint, vp);
}
JS_PUBLIC_API(JSBool)
JS_PropertyStub(JSContext *cx, JSObject *obj, jsid id, jsval *vp)
{
return JS_TRUE;
}
JS_PUBLIC_API(JSBool)
JS_StrictPropertyStub(JSContext *cx, JSObject *obj, jsid id, JSBool strict, jsval *vp)
{
return JS_TRUE;
}
JS_PUBLIC_API(JSBool)
JS_EnumerateStub(JSContext *cx, JSObject *obj)
{
return JS_TRUE;
}
JS_PUBLIC_API(JSBool)
JS_ResolveStub(JSContext *cx, JSObject *obj, jsid id)
{
return JS_TRUE;
}
JS_PUBLIC_API(JSBool)
JS_ConvertStub(JSContext *cx, JSObject *obj, JSType type, jsval *vp)
{
JS_ASSERT(type != JSTYPE_OBJECT && type != JSTYPE_FUNCTION);
JS_ASSERT(obj);
return DefaultValue(cx, obj, type, vp);
}
JS_PUBLIC_API(void)
JS_FinalizeStub(JSContext *cx, JSObject *obj)
{}
JS_PUBLIC_API(JSObject *)
JS_InitClass(JSContext *cx, JSObject *obj, JSObject *parent_proto,
JSClass *clasp, JSNative constructor, uintN nargs,
JSPropertySpec *ps, JSFunctionSpec *fs,
JSPropertySpec *static_ps, JSFunctionSpec *static_fs)
{
CHECK_REQUEST(cx);
assertSameCompartment(cx, obj, parent_proto);
return js_InitClass(cx, obj, parent_proto, Valueify(clasp), constructor,
nargs, ps, fs, static_ps, static_fs);
}
#ifdef JS_THREADSAFE
JS_PUBLIC_API(JSClass *)
JS_GetClass(JSContext *cx, JSObject *obj)
{
return obj->getJSClass();
}
#else
JS_PUBLIC_API(JSClass *)
JS_GetClass(JSObject *obj)
{
return obj->getJSClass();
}
#endif
JS_PUBLIC_API(JSBool)
JS_InstanceOf(JSContext *cx, JSObject *obj, JSClass *clasp, jsval *argv)
{
CHECK_REQUEST(cx);
#ifdef DEBUG
if (argv) {
assertSameCompartment(cx, obj);
assertSameCompartment(cx, JSValueArray(argv - 2, 2));
}
#endif
if (!obj || obj->getJSClass() != clasp) {
if (argv)
ReportIncompatibleMethod(cx, CallReceiverFromArgv(argv), Valueify(clasp));
return false;
}
return true;
}
JS_PUBLIC_API(JSBool)
JS_HasInstance(JSContext *cx, JSObject *obj, jsval v, JSBool *bp)
{
assertSameCompartment(cx, obj, v);
return HasInstance(cx, obj, &v, bp);
}
JS_PUBLIC_API(void *)
JS_GetPrivate(JSContext *cx, JSObject *obj)
{
return obj->getPrivate();
}
JS_PUBLIC_API(JSBool)
JS_SetPrivate(JSContext *cx, JSObject *obj, void *data)
{
obj->setPrivate(data);
return true;
}
JS_PUBLIC_API(void *)
JS_GetInstancePrivate(JSContext *cx, JSObject *obj, JSClass *clasp, jsval *argv)
{
if (!JS_InstanceOf(cx, obj, clasp, argv))
return NULL;
return obj->getPrivate();
}
JS_PUBLIC_API(JSObject *)
JS_GetPrototype(JSContext *cx, JSObject *obj)
{
CHECK_REQUEST(cx);
assertSameCompartment(cx, obj);
return obj->getProto();
}
JS_PUBLIC_API(JSBool)
JS_SetPrototype(JSContext *cx, JSObject *obj, JSObject *proto)
{
CHECK_REQUEST(cx);
assertSameCompartment(cx, obj, proto);
return SetProto(cx, obj, proto, JS_FALSE);
}
JS_PUBLIC_API(JSObject *)
JS_GetParent(JSContext *cx, JSObject *obj)
{
JS_ASSERT(!obj->isInternalScope());
assertSameCompartment(cx, obj);
return obj->getParent();
}
JS_PUBLIC_API(JSBool)
JS_SetParent(JSContext *cx, JSObject *obj, JSObject *parent)
{
CHECK_REQUEST(cx);
JS_ASSERT(!obj->isInternalScope());
JS_ASSERT(parent || !obj->getParent());
assertSameCompartment(cx, obj, parent);
return obj->setParent(cx, parent);
}
JS_PUBLIC_API(JSObject *)
JS_GetConstructor(JSContext *cx, JSObject *proto)
{
Value cval;
CHECK_REQUEST(cx);
assertSameCompartment(cx, proto);
{
JSAutoResolveFlags rf(cx, JSRESOLVE_QUALIFIED);
if (!proto->getProperty(cx, cx->runtime->atomState.constructorAtom, &cval))
return NULL;
}
if (!IsFunctionObject(cval)) {
JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL, JSMSG_NO_CONSTRUCTOR,
proto->getClass()->name);
return NULL;
}
return &cval.toObject();
}
JS_PUBLIC_API(JSBool)
JS_GetObjectId(JSContext *cx, JSObject *obj, jsid *idp)
{
assertSameCompartment(cx, obj);
*idp = OBJECT_TO_JSID(obj);
return JS_TRUE;
}
JS_PUBLIC_API(JSObject *)
JS_NewGlobalObject(JSContext *cx, JSClass *clasp)
{
JS_THREADSAFE_ASSERT(cx->compartment != cx->runtime->atomsCompartment);
CHECK_REQUEST(cx);
return GlobalObject::create(cx, Valueify(clasp));
}
class AutoHoldCompartment {
public:
explicit AutoHoldCompartment(JSCompartment *compartment JS_GUARD_OBJECT_NOTIFIER_PARAM)
: holdp(&compartment->hold)
{
JS_GUARD_OBJECT_NOTIFIER_INIT;
*holdp = true;
}
~AutoHoldCompartment() {
*holdp = false;
}
private:
bool *holdp;
JS_DECL_USE_GUARD_OBJECT_NOTIFIER
};
JS_PUBLIC_API(JSObject *)
JS_NewCompartmentAndGlobalObject(JSContext *cx, JSClass *clasp, JSPrincipals *principals)
{
CHECK_REQUEST(cx);
JSCompartment *compartment = NewCompartment(cx, principals);
if (!compartment)
return NULL;
AutoHoldCompartment hold(compartment);
JSCompartment *saved = cx->compartment;
cx->setCompartment(compartment);
JSObject *obj = JS_NewGlobalObject(cx, clasp);
cx->setCompartment(saved);
return obj;
}
JS_PUBLIC_API(JSObject *)
JS_NewObject(JSContext *cx, JSClass *jsclasp, JSObject *proto, JSObject *parent)
{
JS_THREADSAFE_ASSERT(cx->compartment != cx->runtime->atomsCompartment);
CHECK_REQUEST(cx);
assertSameCompartment(cx, proto, parent);
Class *clasp = Valueify(jsclasp);
if (!clasp)
clasp = &ObjectClass; /* default class is Object */
JS_ASSERT(clasp != &FunctionClass);
JS_ASSERT(!(clasp->flags & JSCLASS_IS_GLOBAL));
if (proto && !proto->setNewTypeUnknown(cx))
return NULL;
JSObject *obj = NewObjectWithClassProto(cx, clasp, proto, parent);
if (obj) {
if (clasp->ext.equality)
MarkTypeObjectFlags(cx, obj, OBJECT_FLAG_SPECIAL_EQUALITY);
MarkTypeObjectUnknownProperties(cx, obj->type());
}
JS_ASSERT_IF(obj, obj->getParent());
return obj;
}
JS_PUBLIC_API(JSObject *)
JS_NewObjectWithGivenProto(JSContext *cx, JSClass *jsclasp, JSObject *proto, JSObject *parent)
{
JS_THREADSAFE_ASSERT(cx->compartment != cx->runtime->atomsCompartment);
CHECK_REQUEST(cx);
assertSameCompartment(cx, proto, parent);
Class *clasp = Valueify(jsclasp);
if (!clasp)
clasp = &ObjectClass; /* default class is Object */
JS_ASSERT(clasp != &FunctionClass);
JS_ASSERT(!(clasp->flags & JSCLASS_IS_GLOBAL));
JSObject *obj = NewObjectWithGivenProto(cx, clasp, proto, parent);
if (obj)
MarkTypeObjectUnknownProperties(cx, obj->type());
return obj;
}
JS_PUBLIC_API(JSObject *)
JS_NewObjectForConstructor(JSContext *cx, const jsval *vp)
{
CHECK_REQUEST(cx);
assertSameCompartment(cx, *vp);
return js_CreateThis(cx, JSVAL_TO_OBJECT(*vp));
}
JS_PUBLIC_API(JSBool)
JS_IsExtensible(JSObject *obj)
{
return obj->isExtensible();
}
JS_PUBLIC_API(JSBool)
JS_IsNative(JSObject *obj)
{
return obj->isNative();
}
JS_PUBLIC_API(JSBool)
JS_FreezeObject(JSContext *cx, JSObject *obj)
{
CHECK_REQUEST(cx);
assertSameCompartment(cx, obj);
return obj->freeze(cx);
}
JS_PUBLIC_API(JSBool)
JS_DeepFreezeObject(JSContext *cx, JSObject *obj)
{
CHECK_REQUEST(cx);
assertSameCompartment(cx, obj);
/* Assume that non-extensible objects are already deep-frozen, to avoid divergence. */
if (!obj->isExtensible())
return true;
if (!obj->freeze(cx))
return false;
/* Walk slots in obj and if any value is a non-null object, seal it. */
for (uint32_t i = 0, n = obj->slotSpan(); i < n; ++i) {
const Value &v = obj->getSlot(i);
if (v.isPrimitive())
continue;
if (!JS_DeepFreezeObject(cx, &v.toObject()))
return false;
}
return true;
}
JS_PUBLIC_API(JSObject *)
JS_ConstructObject(JSContext *cx, JSClass *jsclasp, JSObject *proto, JSObject *parent)
{
CHECK_REQUEST(cx);
assertSameCompartment(cx, proto, parent);
Class *clasp = Valueify(jsclasp);
if (!clasp)
clasp = &ObjectClass; /* default class is Object */
return js_ConstructObject(cx, clasp, proto, parent, 0, NULL);
}
JS_PUBLIC_API(JSObject *)
JS_ConstructObjectWithArguments(JSContext *cx, JSClass *jsclasp, JSObject *proto,
JSObject *parent, uintN argc, jsval *argv)
{
CHECK_REQUEST(cx);
assertSameCompartment(cx, proto, parent, JSValueArray(argv, argc));
Class *clasp = Valueify(jsclasp);
if (!clasp)
clasp = &ObjectClass; /* default class is Object */
return js_ConstructObject(cx, clasp, proto, parent, argc, argv);
}
static JSBool
LookupPropertyById(JSContext *cx, JSObject *obj, jsid id, uintN flags,
JSObject **objp, JSProperty **propp)
{
CHECK_REQUEST(cx);
assertSameCompartment(cx, obj, id);
JSAutoResolveFlags rf(cx, flags);
id = js_CheckForStringIndex(id);
return obj->lookupGeneric(cx, id, objp, propp);
}
#define AUTO_NAMELEN(s,n) (((n) == (size_t)-1) ? js_strlen(s) : (n))
static JSBool
LookupResult(JSContext *cx, JSObject *obj, JSObject *obj2, jsid id,
JSProperty *prop, Value *vp)
{
if (!prop) {
/* XXX bad API: no way to tell "not defined" from "void value" */
vp->setUndefined();
return JS_TRUE;
}
if (obj2->isNative()) {
Shape *shape = (Shape *) prop;
if (shape->isMethod()) {
vp->setObject(*obj2->nativeGetMethod(shape));
return !!obj2->methodReadBarrier(cx, *shape, vp);
}
/* Peek at the native property's slot value, without doing a Get. */
if (shape->hasSlot()) {
*vp = obj2->nativeGetSlot(shape->slot());
return true;
}
} else {
if (obj2->isDenseArray())
return js_GetDenseArrayElementValue(cx, obj2, id, vp);
if (obj2->isProxy()) {
AutoPropertyDescriptorRooter desc(cx);
if (!Proxy::getPropertyDescriptor(cx, obj2, id, false, &desc))
return false;
if (!(desc.attrs & JSPROP_SHARED)) {
*vp = desc.value;
return true;
}
}
}
/* XXX bad API: no way to return "defined but value unknown" */
vp->setBoolean(true);
return true;
}
JS_PUBLIC_API(JSBool)
JS_LookupPropertyById(JSContext *cx, JSObject *obj, jsid id, jsval *vp)
{
JSObject *obj2;
JSProperty *prop;
return LookupPropertyById(cx, obj, id, JSRESOLVE_QUALIFIED, &obj2, &prop) &&
LookupResult(cx, obj, obj2, id, prop, vp);
}
JS_PUBLIC_API(JSBool)
JS_LookupElement(JSContext *cx, JSObject *obj, uint32_t index, jsval *vp)
{
CHECK_REQUEST(cx);
jsid id;
if (!IndexToId(cx, index, &id))
return false;
return JS_LookupPropertyById(cx, obj, id, vp);
}
JS_PUBLIC_API(JSBool)
JS_LookupProperty(JSContext *cx, JSObject *obj, const char *name, jsval *vp)
{
JSAtom *atom = js_Atomize(cx, name, strlen(name));
return atom && JS_LookupPropertyById(cx, obj, ATOM_TO_JSID(atom), vp);
}
JS_PUBLIC_API(JSBool)
JS_LookupUCProperty(JSContext *cx, JSObject *obj, const jschar *name, size_t namelen, jsval *vp)
{
JSAtom *atom = js_AtomizeChars(cx, name, AUTO_NAMELEN(name, namelen));
return atom && JS_LookupPropertyById(cx, obj, ATOM_TO_JSID(atom), vp);
}
JS_PUBLIC_API(JSBool)
JS_LookupPropertyWithFlagsById(JSContext *cx, JSObject *obj, jsid id, uintN flags,
JSObject **objp, jsval *vp)
{
JSBool ok;
JSProperty *prop;
CHECK_REQUEST(cx);
assertSameCompartment(cx, obj, id);
ok = obj->isNative()
? LookupPropertyWithFlags(cx, obj, id, flags, objp, &prop)
: obj->lookupGeneric(cx, id, objp, &prop);
return ok && LookupResult(cx, obj, *objp, id, prop, vp);
}
JS_PUBLIC_API(JSBool)
JS_LookupPropertyWithFlags(JSContext *cx, JSObject *obj, const char *name, uintN flags, jsval *vp)
{
JSObject *obj2;
JSAtom *atom = js_Atomize(cx, name, strlen(name));
return atom && JS_LookupPropertyWithFlagsById(cx, obj, ATOM_TO_JSID(atom), flags, &obj2, vp);
}
JS_PUBLIC_API(JSBool)
JS_HasPropertyById(JSContext *cx, JSObject *obj, jsid id, JSBool *foundp)
{
JSObject *obj2;
JSProperty *prop;
JSBool ok = LookupPropertyById(cx, obj, id, JSRESOLVE_QUALIFIED | JSRESOLVE_DETECTING,
&obj2, &prop);
*foundp = (prop != NULL);
return ok;
}
JS_PUBLIC_API(JSBool)
JS_HasElement(JSContext *cx, JSObject *obj, uint32_t index, JSBool *foundp)
{
CHECK_REQUEST(cx);
jsid id;
if (!IndexToId(cx, index, &id))
return false;
return JS_HasPropertyById(cx, obj, id, foundp);
}
JS_PUBLIC_API(JSBool)
JS_HasProperty(JSContext *cx, JSObject *obj, const char *name, JSBool *foundp)
{
JSAtom *atom = js_Atomize(cx, name, strlen(name));
return atom && JS_HasPropertyById(cx, obj, ATOM_TO_JSID(atom), foundp);
}
JS_PUBLIC_API(JSBool)
JS_HasUCProperty(JSContext *cx, JSObject *obj, const jschar *name, size_t namelen, JSBool *foundp)
{
JSAtom *atom = js_AtomizeChars(cx, name, AUTO_NAMELEN(name, namelen));
return atom && JS_HasPropertyById(cx, obj, ATOM_TO_JSID(atom), foundp);
}
JS_PUBLIC_API(JSBool)
JS_AlreadyHasOwnPropertyById(JSContext *cx, JSObject *obj, jsid id, JSBool *foundp)
{
CHECK_REQUEST(cx);
assertSameCompartment(cx, obj, id);
if (!obj->isNative()) {
JSObject *obj2;
JSProperty *prop;
if (!LookupPropertyById(cx, obj, id, JSRESOLVE_QUALIFIED | JSRESOLVE_DETECTING,
&obj2, &prop)) {
return JS_FALSE;
}
*foundp = (obj == obj2);
return JS_TRUE;
}
*foundp = obj->nativeContains(cx, id);
return JS_TRUE;
}
JS_PUBLIC_API(JSBool)
JS_AlreadyHasOwnElement(JSContext *cx, JSObject *obj, uint32_t index, JSBool *foundp)
{
CHECK_REQUEST(cx);
jsid id;
if (!IndexToId(cx, index, &id))
return false;
return JS_AlreadyHasOwnPropertyById(cx, obj, id, foundp);
}
JS_PUBLIC_API(JSBool)
JS_AlreadyHasOwnProperty(JSContext *cx, JSObject *obj, const char *name, JSBool *foundp)
{
JSAtom *atom = js_Atomize(cx, name, strlen(name));
return atom && JS_AlreadyHasOwnPropertyById(cx, obj, ATOM_TO_JSID(atom), foundp);
}
JS_PUBLIC_API(JSBool)
JS_AlreadyHasOwnUCProperty(JSContext *cx, JSObject *obj, const jschar *name, size_t namelen,
JSBool *foundp)
{
JSAtom *atom = js_AtomizeChars(cx, name, AUTO_NAMELEN(name, namelen));
return atom && JS_AlreadyHasOwnPropertyById(cx, obj, ATOM_TO_JSID(atom), foundp);
}
static JSBool
DefinePropertyById(JSContext *cx, JSObject *obj, jsid id, const Value &value,
PropertyOp getter, StrictPropertyOp setter, uintN attrs,
uintN flags, intN tinyid)
{
/*
* 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;
CHECK_REQUEST(cx);
assertSameCompartment(cx, obj, id, value,
(attrs & JSPROP_GETTER)
? JS_FUNC_TO_DATA_PTR(JSObject *, getter)
: NULL,
(attrs & JSPROP_SETTER)
? JS_FUNC_TO_DATA_PTR(JSObject *, setter)
: NULL);
JSAutoResolveFlags rf(cx, JSRESOLVE_QUALIFIED | JSRESOLVE_DECLARING);
if (flags != 0 && obj->isNative()) {
return !!DefineNativeProperty(cx, obj, id, value, getter, setter,
attrs, flags, tinyid);
}
return obj->defineGeneric(cx, id, value, getter, setter, attrs);
}
JS_PUBLIC_API(JSBool)
JS_DefinePropertyById(JSContext *cx, JSObject *obj, jsid id, jsval value,
JSPropertyOp getter, JSStrictPropertyOp setter, uintN attrs)
{
return DefinePropertyById(cx, obj, id, value, getter, setter, attrs, 0, 0);
}
JS_PUBLIC_API(JSBool)
JS_DefineElement(JSContext *cx, JSObject *obj, uint32_t index, jsval value,
JSPropertyOp getter, JSStrictPropertyOp setter, uintN attrs)
{
CHECK_REQUEST(cx);
jsid id;
if (!IndexToId(cx, index, &id))
return false;
return DefinePropertyById(cx, obj, id, value, getter, setter, attrs, 0, 0);
}
static JSBool
DefineProperty(JSContext *cx, JSObject *obj, const char *name, const Value &value,
PropertyOp getter, StrictPropertyOp setter, uintN attrs,
uintN flags, intN tinyid)
{
jsid id;
JSAtom *atom;
if (attrs & JSPROP_INDEX) {
id = INT_TO_JSID(intptr_t(name));
atom = NULL;
attrs &= ~JSPROP_INDEX;
} else {
atom = js_Atomize(cx, name, strlen(name));
if (!atom)
return JS_FALSE;
id = ATOM_TO_JSID(atom);
}
if (attrs & JSPROP_NATIVE_ACCESSORS) {
JS_ASSERT(!(attrs & (JSPROP_GETTER | JSPROP_SETTER)));
attrs &= ~JSPROP_NATIVE_ACCESSORS;
if (getter) {
JSObject *getobj = JS_NewFunction(cx, (Native) getter, 0, 0, obj->getGlobal(), NULL);
if (!getobj)
return false;
getter = JS_DATA_TO_FUNC_PTR(PropertyOp, getobj);
attrs |= JSPROP_GETTER;
}
if (setter) {
JSObject *setobj = JS_NewFunction(cx, (Native) setter, 1, 0, obj->getGlobal(), NULL);
if (!setobj)
return false;
setter = JS_DATA_TO_FUNC_PTR(StrictPropertyOp, setobj);
attrs |= JSPROP_SETTER;
}
}
return DefinePropertyById(cx, obj, id, value, getter, setter, attrs, flags, tinyid);
}
JS_PUBLIC_API(JSBool)
JS_DefineProperty(JSContext *cx, JSObject *obj, const char *name, jsval value,
PropertyOp getter, JSStrictPropertyOp setter, uintN attrs)
{
return DefineProperty(cx, obj, name, value, getter, setter, attrs, 0, 0);
}
JS_PUBLIC_API(JSBool)
JS_DefinePropertyWithTinyId(JSContext *cx, JSObject *obj, const char *name, int8_t tinyid,
jsval value, PropertyOp getter, JSStrictPropertyOp setter, uintN attrs)
{
return DefineProperty(cx, obj, name, value, getter, setter, attrs, Shape::HAS_SHORTID, tinyid);
}
static JSBool
DefineUCProperty(JSContext *cx, JSObject *obj, const jschar *name, size_t namelen,
const Value &value, PropertyOp getter, StrictPropertyOp setter, uintN attrs,
uintN flags, intN tinyid)
{
JSAtom *atom = js_AtomizeChars(cx, name, AUTO_NAMELEN(name, namelen));
return atom && DefinePropertyById(cx, obj, ATOM_TO_JSID(atom), value, getter, setter, attrs,
flags, tinyid);
}
JS_PUBLIC_API(JSBool)
JS_DefineUCProperty(JSContext *cx, JSObject *obj, const jschar *name, size_t namelen,
jsval value, JSPropertyOp getter, JSStrictPropertyOp setter, uintN attrs)
{
return DefineUCProperty(cx, obj, name, namelen, value, getter, setter, attrs, 0, 0);
}
JS_PUBLIC_API(JSBool)
JS_DefineUCPropertyWithTinyId(JSContext *cx, JSObject *obj, const jschar *name, size_t namelen,
int8_t tinyid, jsval value,
JSPropertyOp getter, JSStrictPropertyOp setter, uintN attrs)
{
return DefineUCProperty(cx, obj, name, namelen, value, getter, setter, attrs,
Shape::HAS_SHORTID, tinyid);
}
JS_PUBLIC_API(JSBool)
JS_DefineOwnProperty(JSContext *cx, JSObject *obj, jsid id, jsval descriptor, JSBool *bp)
{
CHECK_REQUEST(cx);
assertSameCompartment(cx, obj, id, descriptor);
return js_DefineOwnProperty(cx, obj, id, descriptor, bp);
}
JS_PUBLIC_API(JSObject *)
JS_DefineObject(JSContext *cx, JSObject *obj, const char *name, JSClass *jsclasp,
JSObject *proto, uintN attrs)
{
CHECK_REQUEST(cx);
assertSameCompartment(cx, obj, proto);
Class *clasp = Valueify(jsclasp);
if (!clasp)
clasp = &ObjectClass; /* default class is Object */
JSObject *nobj = NewObjectWithClassProto(cx, clasp, proto, obj);
if (!nobj)
return NULL;
if (!DefineProperty(cx, obj, name, ObjectValue(*nobj), NULL, NULL, attrs, 0, 0))
return NULL;
return nobj;
}
JS_PUBLIC_API(JSBool)
JS_DefineConstDoubles(JSContext *cx, JSObject *obj, JSConstDoubleSpec *cds)
{
JSBool ok;
uintN attrs;
CHECK_REQUEST(cx);
for (ok = JS_TRUE; cds->name; cds++) {
Value value = DoubleValue(cds->dval);
attrs = cds->flags;
if (!attrs)
attrs = JSPROP_READONLY | JSPROP_PERMANENT;
ok = DefineProperty(cx, obj, cds->name, value, NULL, NULL, attrs, 0, 0);
if (!ok)
break;
}
return ok;
}
JS_PUBLIC_API(JSBool)
JS_DefineProperties(JSContext *cx, JSObject *obj, JSPropertySpec *ps)
{
JSBool ok;
for (ok = true; ps->name; ps++) {
ok = DefineProperty(cx, obj, ps->name, UndefinedValue(), ps->getter, ps->setter,
ps->flags, Shape::HAS_SHORTID, ps->tinyid);
if (!ok)
break;
}
return ok;
}
static JSBool
GetPropertyDescriptorById(JSContext *cx, JSObject *obj, jsid id, uintN flags,
JSBool own, PropertyDescriptor *desc)
{
JSObject *obj2;
JSProperty *prop;
if (!LookupPropertyById(cx, obj, id, flags, &obj2, &prop))
return JS_FALSE;
if (!prop || (own && obj != obj2)) {
desc->obj = NULL;
desc->attrs = 0;
desc->getter = NULL;
desc->setter = NULL;
desc->value.setUndefined();
return JS_TRUE;
}
desc->obj = obj2;
if (obj2->isNative()) {
Shape *shape = (Shape *) prop;
desc->attrs = shape->attributes();
if (shape->isMethod()) {
desc->getter = JS_PropertyStub;
desc->setter = JS_StrictPropertyStub;
desc->value.setObject(*obj2->nativeGetMethod(shape));
} else {
desc->getter = shape->getter();
desc->setter = shape->setter();
if (shape->hasSlot())
desc->value = obj2->nativeGetSlot(shape->slot());
else
desc->value.setUndefined();
}
} else {
if (obj2->isProxy()) {
JSAutoResolveFlags rf(cx, flags);
return own
? Proxy::getOwnPropertyDescriptor(cx, obj2, id, false, desc)
: Proxy::getPropertyDescriptor(cx, obj2, id, false, desc);
}
if (!obj2->getGenericAttributes(cx, id, &desc->attrs))
return false;
desc->getter = NULL;
desc->setter = NULL;
desc->value.setUndefined();
}
return true;
}
JS_PUBLIC_API(JSBool)
JS_GetPropertyDescriptorById(JSContext *cx, JSObject *obj, jsid id, uintN flags,
JSPropertyDescriptor *desc)
{
return GetPropertyDescriptorById(cx, obj, id, flags, JS_FALSE, desc);
}
JS_PUBLIC_API(JSBool)
JS_GetPropertyAttrsGetterAndSetterById(JSContext *cx, JSObject *obj, jsid id,
uintN *attrsp, JSBool *foundp,
JSPropertyOp *getterp, JSStrictPropertyOp *setterp)
{
PropertyDescriptor desc;
if (!GetPropertyDescriptorById(cx, obj, id, JSRESOLVE_QUALIFIED, JS_FALSE, &desc))
return false;
*attrsp = desc.attrs;
*foundp = (desc.obj != NULL);
if (getterp)
*getterp = desc.getter;
if (setterp)
*setterp = desc.setter;
return true;
}
JS_PUBLIC_API(JSBool)
JS_GetPropertyAttributes(JSContext *cx, JSObject *obj, const char *name,
uintN *attrsp, JSBool *foundp)
{
JSAtom *atom = js_Atomize(cx, name, strlen(name));
return atom && JS_GetPropertyAttrsGetterAndSetterById(cx, obj, ATOM_TO_JSID(atom),
attrsp, foundp, NULL, NULL);
}
JS_PUBLIC_API(JSBool)
JS_GetUCPropertyAttributes(JSContext *cx, JSObject *obj, const jschar *name, size_t namelen,
uintN *attrsp, JSBool *foundp)
{
JSAtom *atom = js_AtomizeChars(cx, name, AUTO_NAMELEN(name, namelen));
return atom && JS_GetPropertyAttrsGetterAndSetterById(cx, obj, ATOM_TO_JSID(atom),
attrsp, foundp, NULL, NULL);
}
JS_PUBLIC_API(JSBool)
JS_GetPropertyAttrsGetterAndSetter(JSContext *cx, JSObject *obj, const char *name,
uintN *attrsp, JSBool *foundp,
JSPropertyOp *getterp, JSStrictPropertyOp *setterp)
{
JSAtom *atom = js_Atomize(cx, name, strlen(name));
return atom && JS_GetPropertyAttrsGetterAndSetterById(cx, obj, ATOM_TO_JSID(atom),
attrsp, foundp, getterp, setterp);
}
JS_PUBLIC_API(JSBool)
JS_GetUCPropertyAttrsGetterAndSetter(JSContext *cx, JSObject *obj,
const jschar *name, size_t namelen,
uintN *attrsp, JSBool *foundp,
JSPropertyOp *getterp, JSStrictPropertyOp *setterp)
{
JSAtom *atom = js_AtomizeChars(cx, name, AUTO_NAMELEN(name, namelen));
return atom && JS_GetPropertyAttrsGetterAndSetterById(cx, obj, ATOM_TO_JSID(atom),
attrsp, foundp, getterp, setterp);
}
JS_PUBLIC_API(JSBool)
JS_GetOwnPropertyDescriptor(JSContext *cx, JSObject *obj, jsid id, jsval *vp)
{
CHECK_REQUEST(cx);
return GetOwnPropertyDescriptor(cx, obj, id, vp);
}
static JSBool
SetPropertyAttributesById(JSContext *cx, JSObject *obj, jsid id, uintN attrs, JSBool *foundp)
{
JSObject *obj2;
JSProperty *prop;
if (!LookupPropertyById(cx, obj, id, JSRESOLVE_QUALIFIED, &obj2, &prop))
return false;
if (!prop || obj != obj2) {
*foundp = false;
return true;
}
JSBool ok = obj->isNative()
? js_SetNativeAttributes(cx, obj, (Shape *) prop, attrs)
: obj->setGenericAttributes(cx, id, &attrs);
if (ok)
*foundp = true;
return ok;
}
JS_PUBLIC_API(JSBool)
JS_SetPropertyAttributes(JSContext *cx, JSObject *obj, const char *name,
uintN attrs, JSBool *foundp)
{
JSAtom *atom = js_Atomize(cx, name, strlen(name));
return atom && SetPropertyAttributesById(cx, obj, ATOM_TO_JSID(atom), attrs, foundp);
}
JS_PUBLIC_API(JSBool)
JS_SetUCPropertyAttributes(JSContext *cx, JSObject *obj, const jschar *name, size_t namelen,
uintN attrs, JSBool *foundp)
{
JSAtom *atom = js_AtomizeChars(cx, name, AUTO_NAMELEN(name, namelen));
return atom && SetPropertyAttributesById(cx, obj, ATOM_TO_JSID(atom), attrs, foundp);
}
JS_PUBLIC_API(JSBool)
JS_GetPropertyById(JSContext *cx, JSObject *obj, jsid id, jsval *vp)
{
return JS_ForwardGetPropertyTo(cx, obj, id, obj, vp);
}
JS_PUBLIC_API(JSBool)
JS_ForwardGetPropertyTo(JSContext *cx, JSObject *obj, jsid id, JSObject *onBehalfOf, jsval *vp)
{
CHECK_REQUEST(cx);
assertSameCompartment(cx, obj, id);
assertSameCompartment(cx, onBehalfOf);
JSAutoResolveFlags rf(cx, JSRESOLVE_QUALIFIED);
return obj->getGeneric(cx, onBehalfOf, id, vp);
}
JS_PUBLIC_API(JSBool)
JS_GetPropertyByIdDefault(JSContext *cx, JSObject *obj, jsid id, jsval def, jsval *vp)
{
return GetPropertyDefault(cx, obj, id, def, vp);
}
JS_PUBLIC_API(JSBool)
JS_GetElement(JSContext *cx, JSObject *obj, uint32_t index, jsval *vp)
{
return JS_ForwardGetElementTo(cx, obj, index, obj, vp);
}
JS_PUBLIC_API(JSBool)
JS_ForwardGetElementTo(JSContext *cx, JSObject *obj, uint32_t index, JSObject *onBehalfOf, jsval *vp)
{
CHECK_REQUEST(cx);
assertSameCompartment(cx, obj);
JSAutoResolveFlags rf(cx, JSRESOLVE_QUALIFIED);
return obj->getElement(cx, onBehalfOf, index, vp);
}
JS_PUBLIC_API(JSBool)
JS_GetElementIfPresent(JSContext *cx, JSObject *obj, uint32_t index, JSObject *onBehalfOf, jsval *vp, JSBool* present)
{
CHECK_REQUEST(cx);
assertSameCompartment(cx, obj);
JSAutoResolveFlags rf(cx, JSRESOLVE_QUALIFIED);
bool isPresent;
if (!obj->getElementIfPresent(cx, onBehalfOf, index, vp, &isPresent))
return false;
*present = isPresent;
return true;
}
JS_PUBLIC_API(JSBool)
JS_GetProperty(JSContext *cx, JSObject *obj, const char *name, jsval *vp)
{
JSAtom *atom = js_Atomize(cx, name, strlen(name));
return atom && JS_GetPropertyById(cx, obj, ATOM_TO_JSID(atom), vp);
}
JS_PUBLIC_API(JSBool)
JS_GetPropertyDefault(JSContext *cx, JSObject *obj, const char *name, jsval def, jsval *vp)
{
JSAtom *atom = js_Atomize(cx, name, strlen(name));
return atom && JS_GetPropertyByIdDefault(cx, obj, ATOM_TO_JSID(atom), def, vp);
}
JS_PUBLIC_API(JSBool)
JS_GetUCProperty(JSContext *cx, JSObject *obj, const jschar *name, size_t namelen, jsval *vp)
{
JSAtom *atom = js_AtomizeChars(cx, name, AUTO_NAMELEN(name, namelen));
return atom && JS_GetPropertyById(cx, obj, ATOM_TO_JSID(atom), vp);
}
JS_PUBLIC_API(JSBool)
JS_GetMethodById(JSContext *cx, JSObject *obj, jsid id, JSObject **objp, jsval *vp)
{
CHECK_REQUEST(cx);
assertSameCompartment(cx, obj, id);
if (!js_GetMethod(cx, obj, id, JSGET_METHOD_BARRIER, vp))
return JS_FALSE;
if (objp)
*objp = obj;
return JS_TRUE;
}
JS_PUBLIC_API(JSBool)
JS_GetMethod(JSContext *cx, JSObject *obj, const char *name, JSObject **objp, jsval *vp)
{
JSAtom *atom = js_Atomize(cx, name, strlen(name));
return atom && JS_GetMethodById(cx, obj, ATOM_TO_JSID(atom), objp, vp);
}
JS_PUBLIC_API(JSBool)
JS_SetPropertyById(JSContext *cx, JSObject *obj, jsid id, jsval *vp)
{
CHECK_REQUEST(cx);
assertSameCompartment(cx, obj, id);
JSAutoResolveFlags rf(cx, JSRESOLVE_QUALIFIED | JSRESOLVE_ASSIGNING);
return obj->setGeneric(cx, id, vp, false);
}
JS_PUBLIC_API(JSBool)
JS_SetElement(JSContext *cx, JSObject *obj, uint32_t index, jsval *vp)
{
CHECK_REQUEST(cx);
assertSameCompartment(cx, obj);
JSAutoResolveFlags rf(cx, JSRESOLVE_QUALIFIED | JSRESOLVE_ASSIGNING);
return obj->setElement(cx, index, vp, false);
}
JS_PUBLIC_API(JSBool)
JS_SetProperty(JSContext *cx, JSObject *obj, const char *name, jsval *vp)
{
JSAtom *atom = js_Atomize(cx, name, strlen(name));
return atom && JS_SetPropertyById(cx, obj, ATOM_TO_JSID(atom), vp);
}
JS_PUBLIC_API(JSBool)
JS_SetUCProperty(JSContext *cx, JSObject *obj, const jschar *name, size_t namelen, jsval *vp)
{
JSAtom *atom = js_AtomizeChars(cx, name, AUTO_NAMELEN(name, namelen));
return atom && JS_SetPropertyById(cx, obj, ATOM_TO_JSID(atom), vp);
}
JS_PUBLIC_API(JSBool)
JS_DeletePropertyById2(JSContext *cx, JSObject *obj, jsid id, jsval *rval)
{
CHECK_REQUEST(cx);
assertSameCompartment(cx, obj, id);
JSAutoResolveFlags rf(cx, JSRESOLVE_QUALIFIED);
return obj->deleteGeneric(cx, id, rval, false);
}
JS_PUBLIC_API(JSBool)
JS_DeleteElement2(JSContext *cx, JSObject *obj, uint32_t index, jsval *rval)
{
CHECK_REQUEST(cx);
jsid id;
if (!IndexToId(cx, index, &id))
return false;
return JS_DeletePropertyById2(cx, obj, id, rval);
}
JS_PUBLIC_API(JSBool)
JS_DeleteProperty2(JSContext *cx, JSObject *obj, const char *name, jsval *rval)
{
JSAtom *atom = js_Atomize(cx, name, strlen(name));
return atom && JS_DeletePropertyById2(cx, obj, ATOM_TO_JSID(atom), rval);
}
JS_PUBLIC_API(JSBool)
JS_DeleteUCProperty2(JSContext *cx, JSObject *obj, const jschar *name, size_t namelen, jsval *rval)
{
JSAtom *atom = js_AtomizeChars(cx, name, AUTO_NAMELEN(name, namelen));
return atom && JS_DeletePropertyById2(cx, obj, ATOM_TO_JSID(atom), rval);
}
JS_PUBLIC_API(JSBool)
JS_DeletePropertyById(JSContext *cx, JSObject *obj, jsid id)
{
jsval junk;
return JS_DeletePropertyById2(cx, obj, id, &junk);
}
JS_PUBLIC_API(JSBool)
JS_DeleteElement(JSContext *cx, JSObject *obj, uint32_t index)
{
jsval junk;
return JS_DeleteElement2(cx, obj, index, &junk);
}
JS_PUBLIC_API(JSBool)
JS_DeleteProperty(JSContext *cx, JSObject *obj, const char *name)
{
jsval junk;
return JS_DeleteProperty2(cx, obj, name, &junk);
}
JS_PUBLIC_API(void)
JS_ClearScope(JSContext *cx, JSObject *obj)
{
CHECK_REQUEST(cx);
assertSameCompartment(cx, obj);
JSFinalizeOp clearOp = obj->getOps()->clear;
if (clearOp)
clearOp(cx, obj);
if (obj->isNative())
js_ClearNative(cx, obj);
/* Clear cached class objects on the global object. */
if (obj->isGlobal())
obj->asGlobal()->clear(cx);
js_InitRandom(cx);
}
JS_PUBLIC_API(JSIdArray *)
JS_Enumerate(JSContext *cx, JSObject *obj)
{
CHECK_REQUEST(cx);
assertSameCompartment(cx, obj);
AutoIdVector props(cx);
JSIdArray *ida;
if (!GetPropertyNames(cx, obj, JSITER_OWNONLY, &props) || !VectorToIdArray(cx, props, &ida))
return NULL;
for (size_t n = 0; n < size_t(ida->length); ++n)
JS_ASSERT(js_CheckForStringIndex(ida->vector[n]) == ida->vector[n]);
return ida;
}
/*
* XXX reverse iterator for properties, unreverse and meld with jsinterp.c's
* prop_iterator_class somehow...
* + preserve the obj->enumerate API while optimizing the native object case
* + native case here uses a Shape *, but that iterates in reverse!
* + so we make non-native match, by reverse-iterating after JS_Enumerating
*/
const uint32_t JSSLOT_ITER_INDEX = 0;
static void
prop_iter_finalize(JSContext *cx, JSObject *obj)
{
void *pdata = obj->getPrivate();
if (!pdata)
return;
if (obj->getSlot(JSSLOT_ITER_INDEX).toInt32() >= 0) {
/* Non-native case: destroy the ida enumerated when obj was created. */
JSIdArray *ida = (JSIdArray *) pdata;
JS_DestroyIdArray(cx, ida);
}
}
static void
prop_iter_trace(JSTracer *trc, JSObject *obj)
{
void *pdata = obj->getPrivate();
if (!pdata)
return;
if (obj->getSlot(JSSLOT_ITER_INDEX).toInt32() < 0) {
/*
* Native case: just mark the next property to visit. We don't need a
* barrier here because the pointer is updated via setPrivate, which
* always takes a barrier.
*/
MarkShapeUnbarriered(trc, (Shape *)pdata, "prop iter shape");
} else {
/* Non-native case: mark each id in the JSIdArray private. */
JSIdArray *ida = (JSIdArray *) pdata;
MarkIdRange(trc, ida->vector, ida->vector + ida->length, "prop iter");
}
}
static Class prop_iter_class = {
"PropertyIterator",
JSCLASS_HAS_PRIVATE | JSCLASS_HAS_RESERVED_SLOTS(1),
JS_PropertyStub, /* addProperty */
JS_PropertyStub, /* delProperty */
JS_PropertyStub, /* getProperty */
JS_StrictPropertyStub, /* setProperty */
JS_EnumerateStub,
JS_ResolveStub,
JS_ConvertStub,
prop_iter_finalize,
NULL, /* reserved0 */
NULL, /* checkAccess */
NULL, /* call */
NULL, /* construct */
NULL, /* xdrObject */
NULL, /* hasInstance */
prop_iter_trace
};
JS_PUBLIC_API(JSObject *)
JS_NewPropertyIterator(JSContext *cx, JSObject *obj)
{
JSObject *iterobj;
void *pdata;
jsint index;
JSIdArray *ida;
CHECK_REQUEST(cx);
assertSameCompartment(cx, obj);
iterobj = NewObjectWithClassProto(cx, &prop_iter_class, NULL, obj);
if (!iterobj)
return NULL;
if (obj->isNative()) {
/* Native case: start with the last property in obj. */
pdata = (void *)obj->lastProperty();
index = -1;
} else {
/*
* Non-native case: enumerate a JSIdArray and keep it via private.
*
* Note: we have to make sure that we root obj around the call to
* JS_Enumerate to protect against multiple allocations under it.
*/
AutoObjectRooter tvr(cx, iterobj);
ida = JS_Enumerate(cx, obj);
if (!ida)
return NULL;
pdata = ida;
index = ida->length;
}
/* iterobj cannot escape to other threads here. */
iterobj->setPrivate(pdata);
iterobj->setSlot(JSSLOT_ITER_INDEX, Int32Value(index));
return iterobj;
}
JS_PUBLIC_API(JSBool)
JS_NextProperty(JSContext *cx, JSObject *iterobj, jsid *idp)
{
jsint i;
const Shape *shape;
JSIdArray *ida;
CHECK_REQUEST(cx);
assertSameCompartment(cx, iterobj);
i = iterobj->getSlot(JSSLOT_ITER_INDEX).toInt32();
if (i < 0) {
/* Native case: private data is a property tree node pointer. */
JS_ASSERT(iterobj->getParent()->isNative());
shape = (Shape *) iterobj->getPrivate();
while (shape->previous() && !shape->enumerable())
shape = shape->previous();
if (!shape->previous()) {
JS_ASSERT(shape->isEmptyShape());
*idp = JSID_VOID;
} else {
iterobj->setPrivate(const_cast<Shape *>(shape->previous().get()));
*idp = shape->propid();
}
} else {
/* Non-native case: use the ida enumerated when iterobj was created. */
ida = (JSIdArray *) iterobj->getPrivate();
JS_ASSERT(i <= ida->length);
STATIC_ASSUME(i <= ida->length);
if (i == 0) {
*idp = JSID_VOID;
} else {
*idp = ida->vector[--i];
iterobj->setSlot(JSSLOT_ITER_INDEX, Int32Value(i));
}
}
return JS_TRUE;
}
JS_PUBLIC_API(JSBool)
JS_GetReservedSlot(JSContext *cx, JSObject *obj, uint32_t index, jsval *vp)
{
CHECK_REQUEST(cx);
assertSameCompartment(cx, obj);
return js_GetReservedSlot(cx, obj, index, vp);
}
JS_PUBLIC_API(JSBool)
JS_SetReservedSlot(JSContext *cx, JSObject *obj, uint32_t index, jsval v)
{
CHECK_REQUEST(cx);
assertSameCompartment(cx, obj, v);
return js_SetReservedSlot(cx, obj, index, v);
}
JS_PUBLIC_API(JSObject *)
JS_NewArrayObject(JSContext *cx, jsint length, jsval *vector)
{
JS_THREADSAFE_ASSERT(cx->compartment != cx->runtime->atomsCompartment);
CHECK_REQUEST(cx);
/* NB: jsuint cast does ToUint32. */
assertSameCompartment(cx, JSValueArray(vector, vector ? (jsuint)length : 0));
return NewDenseCopiedArray(cx, (jsuint)length, vector);
}
JS_PUBLIC_API(JSBool)
JS_IsArrayObject(JSContext *cx, JSObject *obj)
{
assertSameCompartment(cx, obj);
return ObjectClassIs(*obj, ESClass_Array, cx);
}
JS_PUBLIC_API(JSBool)
JS_GetArrayLength(JSContext *cx, JSObject *obj, jsuint *lengthp)
{
CHECK_REQUEST(cx);
assertSameCompartment(cx, obj);
return js_GetLengthProperty(cx, obj, lengthp);
}
JS_PUBLIC_API(JSBool)
JS_SetArrayLength(JSContext *cx, JSObject *obj, jsuint length)
{
CHECK_REQUEST(cx);
assertSameCompartment(cx, obj);
return js_SetLengthProperty(cx, obj, length);
}
JS_PUBLIC_API(JSBool)
JS_CheckAccess(JSContext *cx, JSObject *obj, jsid id, JSAccessMode mode,
jsval *vp, uintN *attrsp)
{
CHECK_REQUEST(cx);
assertSameCompartment(cx, obj, id);
return CheckAccess(cx, obj, id, mode, vp, attrsp);
}
#ifdef JS_THREADSAFE
JS_PUBLIC_API(jsrefcount)
JS_HoldPrincipals(JSContext *cx, JSPrincipals *principals)
{
return JS_ATOMIC_INCREMENT(&principals->refcount);
}
JS_PUBLIC_API(jsrefcount)
JS_DropPrincipals(JSContext *cx, JSPrincipals *principals)
{
jsrefcount rc = JS_ATOMIC_DECREMENT(&principals->refcount);
if (rc == 0)
principals->destroy(cx, principals);
return rc;
}
#endif
JS_PUBLIC_API(JSSecurityCallbacks *)
JS_SetRuntimeSecurityCallbacks(JSRuntime *rt, JSSecurityCallbacks *callbacks)
{
JSSecurityCallbacks *oldcallbacks;
oldcallbacks = rt->securityCallbacks;
rt->securityCallbacks = callbacks;
return oldcallbacks;
}
JS_PUBLIC_API(JSSecurityCallbacks *)
JS_GetRuntimeSecurityCallbacks(JSRuntime *rt)
{
return rt->securityCallbacks;
}
JS_PUBLIC_API(JSSecurityCallbacks *)
JS_SetContextSecurityCallbacks(JSContext *cx, JSSecurityCallbacks *callbacks)
{
JSSecurityCallbacks *oldcallbacks;
oldcallbacks = cx->securityCallbacks;
cx->securityCallbacks = callbacks;
return oldcallbacks;
}
JS_PUBLIC_API(JSSecurityCallbacks *)
JS_GetSecurityCallbacks(JSContext *cx)
{
return cx->securityCallbacks
? cx->securityCallbacks
: cx->runtime->securityCallbacks;
}
JS_PUBLIC_API(void)
JS_SetTrustedPrincipals(JSRuntime *rt, JSPrincipals *prin)
{
rt->setTrustedPrincipals(prin);
}
JS_PUBLIC_API(JSFunction *)
JS_NewFunction(JSContext *cx, JSNative native, uintN nargs, uintN flags,
JSObject *parent, const char *name)
{
JS_THREADSAFE_ASSERT(cx->compartment != cx->runtime->atomsCompartment);
JSAtom *atom;
CHECK_REQUEST(cx);
assertSameCompartment(cx, parent);
if (!name) {
atom = NULL;
} else {
atom = js_Atomize(cx, name, strlen(name));
if (!atom)
return NULL;
}
return js_NewFunction(cx, NULL, native, nargs, flags, parent, atom);
}
JS_PUBLIC_API(JSFunction *)
JS_NewFunctionById(JSContext *cx, JSNative native, uintN nargs, uintN flags, JSObject *parent,
jsid id)
{
JS_ASSERT(JSID_IS_STRING(id));
JS_THREADSAFE_ASSERT(cx->compartment != cx->runtime->atomsCompartment);
CHECK_REQUEST(cx);
assertSameCompartment(cx, parent);
return js_NewFunction(cx, NULL, native, nargs, flags, parent, JSID_TO_ATOM(id));
}
JS_PUBLIC_API(JSObject *)
JS_CloneFunctionObject(JSContext *cx, JSObject *funobj, JSObject *parent)
{
CHECK_REQUEST(cx);
assertSameCompartment(cx, parent); // XXX no funobj for now
if (!parent) {
if (cx->hasfp())
parent = &cx->fp()->scopeChain();
if (!parent)
parent = cx->globalObject;
JS_ASSERT(parent);
}
if (!funobj->isFunction()) {
/*
* We cannot clone this object, so fail (we used to return funobj, bad
* idea, but we changed incompatibly to teach any abusers a lesson!).
*/
Value v = ObjectValue(*funobj);
js_ReportIsNotFunction(cx, &v, 0);
return NULL;
}
JSFunction *fun = funobj->toFunction();
if (!fun->isInterpreted())
return CloneFunctionObject(cx, fun, parent, fun->getAllocKind());
if (fun->script()->compileAndGo) {
JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL,
JSMSG_BAD_CLONE_FUNOBJ_SCOPE);
return NULL;
}
if (!fun->isFlatClosure())
return CloneFunctionObject(cx, fun, parent, fun->getAllocKind());
/*
* A flat closure carries its own environment, so why clone it? In case
* someone wants to mutate its fixed slots or add ad-hoc properties. API
* compatibility suggests we not return funobj and let callers mutate the
* returned object at will.
*
* But it's worse than that: API compatibility according to the test for
* bug 300079 requires we get "upvars" from parent and its ancestors! So
* we do that (grudgingly!). The scope chain ancestors are searched as if
* they were activations, respecting the skip field in each upvar's cookie
* but looking up the property by name instead of frame slot.
*/
JSObject *clone = js_AllocFlatClosure(cx, fun, parent);
if (!clone)
return NULL;
JSUpvarArray *uva = fun->script()->upvars();
uint32_t i = uva->length;
JS_ASSERT(i != 0);
for (Shape::Range r(fun->script()->bindings.lastUpvar()); i-- != 0; r.popFront()) {
JSObject *obj = parent;
int skip = uva->vector[i].level();
while (--skip > 0) {
if (!obj) {
JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL,
JSMSG_BAD_CLONE_FUNOBJ_SCOPE);
return NULL;
}
obj = obj->scopeChain();
}
Value v;
if (!obj->getGeneric(cx, r.front().propid(), &v))
return NULL;
clone->toFunction()->setFlatClosureUpvar(i, v);
}
return clone;
}
JS_PUBLIC_API(JSObject *)
JS_GetFunctionObject(JSFunction *fun)
{
return fun;
}
JS_PUBLIC_API(JSString *)
JS_GetFunctionId(JSFunction *fun)
{
return fun->atom;
}
JS_PUBLIC_API(uintN)
JS_GetFunctionFlags(JSFunction *fun)
{
return fun->flags;
}
JS_PUBLIC_API(uint16_t)
JS_GetFunctionArity(JSFunction *fun)
{
return fun->nargs;
}
JS_PUBLIC_API(JSBool)
JS_ObjectIsFunction(JSContext *cx, JSObject *obj)
{
return obj->isFunction();
}
JS_PUBLIC_API(JSBool)
JS_ObjectIsCallable(JSContext *cx, JSObject *obj)
{
return obj->isCallable();
}
JS_PUBLIC_API(JSBool)
JS_IsNativeFunction(JSObject *funobj, JSNative call)
{
if (!funobj->isFunction())
return false;
JSFunction *fun = funobj->toFunction();
return fun->isNative() && fun->native() == call;
}
JSBool
js_generic_native_method_dispatcher(JSContext *cx, uintN argc, Value *vp)
{
JSFunctionSpec *fs = (JSFunctionSpec *)
vp->toObject().toFunction()->getExtendedSlot(0).toPrivate();
JS_ASSERT((fs->flags & JSFUN_GENERIC_NATIVE) != 0);
if (argc < 1) {
js_ReportMissingArg(cx, *vp, 0);
return JS_FALSE;
}
/*
* Copy all actual (argc) arguments down over our |this| parameter, vp[1],
* which is almost always the class constructor object, e.g. Array. Then
* call the corresponding prototype native method with our first argument
* passed as |this|.
*/
memmove(vp + 1, vp + 2, argc * sizeof(jsval));
/* Clear the last parameter in case too few arguments were passed. */
vp[2 + --argc].setUndefined();
return fs->call(cx, argc, vp);
}
JS_PUBLIC_API(JSBool)
JS_DefineFunctions(JSContext *cx, JSObject *obj, JSFunctionSpec *fs)
{
JS_THREADSAFE_ASSERT(cx->compartment != cx->runtime->atomsCompartment);
uintN flags;
JSObject *ctor;
JSFunction *fun;
CHECK_REQUEST(cx);
assertSameCompartment(cx, obj);
ctor = NULL;
for (; fs->name; fs++) {
flags = fs->flags;
JSAtom *atom = js_Atomize(cx, fs->name, strlen(fs->name));
if (!atom)
return JS_FALSE;
/*
* Define a generic arity N+1 static method for the arity N prototype
* method if flags contains JSFUN_GENERIC_NATIVE.
*/
if (flags & JSFUN_GENERIC_NATIVE) {
if (!ctor) {
ctor = JS_GetConstructor(cx, obj);
if (!ctor)
return JS_FALSE;
}
flags &= ~JSFUN_GENERIC_NATIVE;
fun = js_DefineFunction(cx, ctor, ATOM_TO_JSID(atom),
js_generic_native_method_dispatcher,
fs->nargs + 1,
flags,
JSFunction::ExtendedFinalizeKind);
if (!fun)
return JS_FALSE;
/*
* As jsapi.h notes, fs must point to storage that lives as long
* as fun->object lives.
*/
fun->setExtendedSlot(0, PrivateValue(fs));
}
fun = js_DefineFunction(cx, obj, ATOM_TO_JSID(atom), fs->call, fs->nargs, flags);
if (!fun)
return JS_FALSE;
}
return JS_TRUE;
}
JS_PUBLIC_API(JSFunction *)
JS_DefineFunction(JSContext *cx, JSObject *obj, const char *name, JSNative call,
uintN nargs, uintN attrs)
{
JS_THREADSAFE_ASSERT(cx->compartment != cx->runtime->atomsCompartment);
CHECK_REQUEST(cx);
assertSameCompartment(cx, obj);
JSAtom *atom = js_Atomize(cx, name, strlen(name));
if (!atom)
return NULL;
return js_DefineFunction(cx, obj, ATOM_TO_JSID(atom), call, nargs, attrs);
}
JS_PUBLIC_API(JSFunction *)
JS_DefineUCFunction(JSContext *cx, JSObject *obj,
const jschar *name, size_t namelen, JSNative call,
uintN nargs, uintN attrs)
{
JS_THREADSAFE_ASSERT(cx->compartment != cx->runtime->atomsCompartment);
CHECK_REQUEST(cx);
assertSameCompartment(cx, obj);
JSAtom *atom = js_AtomizeChars(cx, name, AUTO_NAMELEN(name, namelen));
if (!atom)
return NULL;
return js_DefineFunction(cx, obj, ATOM_TO_JSID(atom), call, nargs, attrs);
}
extern JS_PUBLIC_API(JSFunction *)
JS_DefineFunctionById(JSContext *cx, JSObject *obj, jsid id, JSNative call,
uintN nargs, uintN attrs)
{
JS_THREADSAFE_ASSERT(cx->compartment != cx->runtime->atomsCompartment);
CHECK_REQUEST(cx);
assertSameCompartment(cx, obj);
return js_DefineFunction(cx, obj, id, call, nargs, attrs);
}
struct AutoLastFrameCheck {
AutoLastFrameCheck(JSContext *cx JS_GUARD_OBJECT_NOTIFIER_PARAM)
: cx(cx) {
JS_ASSERT(cx);
JS_GUARD_OBJECT_NOTIFIER_INIT;
}
~AutoLastFrameCheck() {
if (cx->isExceptionPending() &&
!JS_IsRunning(cx) &&
!cx->hasRunOption(JSOPTION_DONT_REPORT_UNCAUGHT)) {
js_ReportUncaughtException(cx);
}
}
private:
JSContext *cx;
JS_DECL_USE_GUARD_OBJECT_NOTIFIER
};
inline static uint32_t
JS_OPTIONS_TO_TCFLAGS(JSContext *cx)
{
return (cx->hasRunOption(JSOPTION_COMPILE_N_GO) ? TCF_COMPILE_N_GO : 0) |
(cx->hasRunOption(JSOPTION_NO_SCRIPT_RVAL) ? TCF_NO_SCRIPT_RVAL : 0);
}
static JSScript *
CompileUCScriptForPrincipalsCommon(JSContext *cx, JSObject *obj, JSPrincipals *principals,
const jschar *chars, size_t length,
const char *filename, uintN lineno, JSVersion version)
{
JS_THREADSAFE_ASSERT(cx->compartment != cx->runtime->atomsCompartment);
CHECK_REQUEST(cx);
assertSameCompartment(cx, obj, principals);
AutoLastFrameCheck lfc(cx);
uint32_t tcflags = JS_OPTIONS_TO_TCFLAGS(cx) | TCF_NEED_SCRIPT_GLOBAL;
return frontend::CompileScript(cx, obj, NULL, principals, NULL, tcflags,
chars, length, filename, lineno, version);
}
extern JS_PUBLIC_API(JSScript *)
JS_CompileUCScriptForPrincipalsVersion(JSContext *cx, JSObject *obj,
JSPrincipals *principals,
const jschar *chars, size_t length,
const char *filename, uintN lineno,
JSVersion version)
{
AutoVersionAPI avi(cx, version);
return CompileUCScriptForPrincipalsCommon(cx, obj, principals, chars, length, filename, lineno,
avi.version());
}
JS_PUBLIC_API(JSScript *)
JS_CompileUCScriptForPrincipals(JSContext *cx, JSObject *obj, JSPrincipals *principals,
const jschar *chars, size_t length,
const char *filename, uintN lineno)
{
return CompileUCScriptForPrincipalsCommon(cx, obj, principals, chars, length, filename, lineno,
cx->findVersion());
}
JS_PUBLIC_API(JSScript *)
JS_CompileUCScript(JSContext *cx, JSObject *obj, const jschar *chars, size_t length,
const char *filename, uintN lineno)
{
JS_THREADSAFE_ASSERT(cx->compartment != cx->runtime->atomsCompartment);
return JS_CompileUCScriptForPrincipals(cx, obj, NULL, chars, length, filename, lineno);
}
JS_PUBLIC_API(JSScript *)
JS_CompileScriptForPrincipalsVersion(JSContext *cx, JSObject *obj,
JSPrincipals *principals,
const char *bytes, size_t length,
const char *filename, uintN lineno,
JSVersion version)
{
AutoVersionAPI ava(cx, version);
return JS_CompileScriptForPrincipals(cx, obj, principals, bytes, length, filename, lineno);
}
JS_PUBLIC_API(JSScript *)
JS_CompileScriptForPrincipals(JSContext *cx, JSObject *obj,
JSPrincipals *principals,
const char *bytes, size_t length,
const char *filename, uintN lineno)
{
JS_THREADSAFE_ASSERT(cx->compartment != cx->runtime->atomsCompartment);
CHECK_REQUEST(cx);
jschar *chars = InflateString(cx, bytes, &length);
if (!chars)
return NULL;
JSScript *script =
JS_CompileUCScriptForPrincipals(cx, obj, principals, chars, length, filename, lineno);
cx->free_(chars);
return script;
}
JS_PUBLIC_API(JSScript *)
JS_CompileScript(JSContext *cx, JSObject *obj, const char *bytes, size_t length,
const char *filename, uintN lineno)
{
JS_THREADSAFE_ASSERT(cx->compartment != cx->runtime->atomsCompartment);
return JS_CompileScriptForPrincipals(cx, obj, NULL, bytes, length, filename, lineno);
}
JS_PUBLIC_API(JSBool)
JS_BufferIsCompilableUnit(JSContext *cx, JSBool bytes_are_utf8, JSObject *obj, const char *bytes, size_t length)
{
jschar *chars;
JSBool result;
JSExceptionState *exnState;
JSErrorReporter older;
CHECK_REQUEST(cx);
assertSameCompartment(cx, obj);
if (bytes_are_utf8)
chars = InflateString(cx, bytes, &length, CESU8Encoding);
else
chars = InflateString(cx, bytes, &length);
if (!chars)
return JS_TRUE;
/*
* Return true on any out-of-memory error, so our caller doesn't try to
* collect more buffered source.
*/
result = JS_TRUE;
exnState = JS_SaveExceptionState(cx);
{
Parser parser(cx);
if (parser.init(chars, length, NULL, 1, cx->findVersion())) {
older = JS_SetErrorReporter(cx, NULL);
if (!parser.parse(obj) &&
parser.tokenStream.isUnexpectedEOF()) {
/*
* 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.
*/
result = JS_FALSE;
}
JS_SetErrorReporter(cx, older);
}
}
cx->free_(chars);
JS_RestoreExceptionState(cx, exnState);
return result;
}
/* 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
static JSScript *
CompileUTF8FileHelper(JSContext *cx, JSObject *obj, JSPrincipals *principals,
const char* filename, FILE *fp)
{
struct stat st;
int ok = fstat(fileno(fp), &st);
if (ok != 0)
return NULL;
char *buf = NULL;
size_t len = st.st_size;
size_t i = 0;
JSScript *script;
/* Read in the whole file, then compile it. */
if (fp == stdin) {
if (len == 0)
len = 8; /* start with a small buffer, expand as necessary */
int c;
bool hitEOF = false;
while (!hitEOF) {
len *= 2;
char* tmpbuf = (char *) cx->realloc_(buf, len * sizeof(char));
if (!tmpbuf) {
cx->free_(buf);
return NULL;
}
buf = tmpbuf;
while (i < len) {
c = fast_getc(fp);
if (c == EOF) {
hitEOF = true;
break;
}
buf[i++] = c;
}
}
} else {
buf = (char *) cx->malloc_(len * sizeof(char));
if (!buf)
return NULL;
int c;
// The |i < len| is necessary for files that lie about their length,
// e.g. /dev/zero and /dev/random. See bug 669434.
while (i < len && (c = fast_getc(fp)) != EOF)
buf[i++] = c;
}
JS_ASSERT(i <= len);
len = i;
size_t decodelen = len;
jschar *decodebuf = (jschar *)cx->malloc_(decodelen * sizeof(jschar));
if (JS_DecodeUTF8(cx, buf, len, decodebuf, &decodelen)) {
uint32_t tcflags = JS_OPTIONS_TO_TCFLAGS(cx) | TCF_NEED_SCRIPT_GLOBAL;
script = frontend::CompileScript(cx, obj, NULL, principals, NULL,
tcflags, decodebuf, decodelen,
filename, 1, cx->findVersion());
} else {
script = NULL;
}
cx->free_(buf);
cx->free_(decodebuf);
return script;
}
JS_PUBLIC_API(JSScript *)
JS_CompileUTF8File(JSContext *cx, JSObject *obj, const char *filename)
{
JS_THREADSAFE_ASSERT(cx->compartment != cx->runtime->atomsCompartment);
CHECK_REQUEST(cx);
assertSameCompartment(cx, obj);
AutoLastFrameCheck lfc(cx);
FILE *fp;
if (!filename || strcmp(filename, "-") == 0) {
fp = stdin;
} else {
fp = fopen(filename, "r");
if (!fp) {
JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL, JSMSG_CANT_OPEN,
filename, "No such file or directory");
return NULL;
}
}
JSScript *script = CompileUTF8FileHelper(cx, obj, NULL, filename, fp);
if (fp != stdin)
fclose(fp);
return script;
}
JS_PUBLIC_API(JSScript *)
JS_CompileUTF8FileHandleForPrincipals(JSContext *cx, JSObject *obj, const char *filename,
FILE *file, JSPrincipals *principals)
{
JS_THREADSAFE_ASSERT(cx->compartment != cx->runtime->atomsCompartment);
CHECK_REQUEST(cx);
assertSameCompartment(cx, obj, principals);
AutoLastFrameCheck lfc(cx);
return CompileUTF8FileHelper(cx, obj, principals, filename, file);
}
JS_PUBLIC_API(JSScript *)
JS_CompileUTF8FileHandleForPrincipalsVersion(JSContext *cx, JSObject *obj, const char *filename,
FILE *file, JSPrincipals *principals, JSVersion version)
{
AutoVersionAPI ava(cx, version);
return JS_CompileUTF8FileHandleForPrincipals(cx, obj, filename, file, principals);
}
JS_PUBLIC_API(JSScript *)
JS_CompileUTF8FileHandle(JSContext *cx, JSObject *obj, const char *filename, FILE *file)
{
JS_THREADSAFE_ASSERT(cx->compartment != cx->runtime->atomsCompartment);
return JS_CompileUTF8FileHandleForPrincipals(cx, obj, filename, file, NULL);
}
JS_PUBLIC_API(JSObject *)
JS_GetGlobalFromScript(JSScript *script)
{
JS_ASSERT(!script->isCachedEval);
JS_ASSERT(script->globalObject);
return script->globalObject;
}
static JSFunction *
CompileUCFunctionForPrincipalsCommon(JSContext *cx, JSObject *obj,
JSPrincipals *principals, const char *name,
uintN nargs, const char **argnames,
const jschar *chars, size_t length,
const char *filename, uintN lineno, JSVersion version)
{
JS_THREADSAFE_ASSERT(cx->compartment != cx->runtime->atomsCompartment);
CHECK_REQUEST(cx);
assertSameCompartment(cx, obj, principals);
AutoLastFrameCheck lfc(cx);
JSAtom *funAtom;
if (!name) {
funAtom = NULL;
} else {
funAtom = js_Atomize(cx, name, strlen(name));
if (!funAtom)
return NULL;
}
Bindings bindings(cx);
for (uintN i = 0; i < nargs; i++) {
uint16_t dummy;
JSAtom *argAtom = js_Atomize(cx, argnames[i], strlen(argnames[i]));
if (!argAtom || !bindings.addArgument(cx, argAtom, &dummy))
return NULL;
}
JSFunction *fun = js_NewFunction(cx, NULL, NULL, 0, JSFUN_INTERPRETED, obj, funAtom);
if (!fun)
return NULL;
if (!frontend::CompileFunctionBody(cx, fun, principals, NULL, &bindings,
chars, length, filename, lineno, version))
{
return NULL;
}
if (obj && funAtom &&
!obj->defineGeneric(cx, ATOM_TO_JSID(funAtom), ObjectValue(*fun), NULL, NULL,
JSPROP_ENUMERATE))
{
return NULL;
}
return fun;
}
JS_PUBLIC_API(JSFunction *)
JS_CompileUCFunctionForPrincipalsVersion(JSContext *cx, JSObject *obj,
JSPrincipals *principals, const char *name,
uintN nargs, const char **argnames,
const jschar *chars, size_t length,
const char *filename, uintN lineno,
JSVersion version)
{
AutoVersionAPI avi(cx, version);
return CompileUCFunctionForPrincipalsCommon(cx, obj, principals, name, nargs, argnames, chars,
length, filename, lineno, avi.version());
}
JS_PUBLIC_API(JSFunction *)
JS_CompileUCFunctionForPrincipals(JSContext *cx, JSObject *obj,
JSPrincipals *principals, const char *name,
uintN nargs, const char **argnames,
const jschar *chars, size_t length,
const char *filename, uintN lineno)
{
return CompileUCFunctionForPrincipalsCommon(cx, obj, principals, name, nargs, argnames, chars,
length, filename, lineno, cx->findVersion());
}
JS_PUBLIC_API(JSFunction *)
JS_CompileUCFunction(JSContext *cx, JSObject *obj, const char *name,
uintN nargs, const char **argnames,
const jschar *chars, size_t length,
const char *filename, uintN lineno)
{
JS_THREADSAFE_ASSERT(cx->compartment != cx->runtime->atomsCompartment);
return JS_CompileUCFunctionForPrincipals(cx, obj, NULL, name, nargs, argnames,
chars, length, filename, lineno);
}
JS_PUBLIC_API(JSFunction *)
JS_CompileFunctionForPrincipals(JSContext *cx, JSObject *obj,
JSPrincipals *principals, const char *name,
uintN nargs, const char **argnames,
const char *bytes, size_t length,
const char *filename, uintN lineno)
{
JS_THREADSAFE_ASSERT(cx->compartment != cx->runtime->atomsCompartment);
jschar *chars = InflateString(cx, bytes, &length);
if (!chars)
return NULL;
JSFunction *fun = JS_CompileUCFunctionForPrincipals(cx, obj, principals, name,
nargs, argnames, chars, length,
filename, lineno);
cx->free_(chars);
return fun;
}
JS_PUBLIC_API(JSFunction *)
JS_CompileFunction(JSContext *cx, JSObject *obj, const char *name,
uintN nargs, const char **argnames,
const char *bytes, size_t length,
const char *filename, uintN lineno)
{
JS_THREADSAFE_ASSERT(cx->compartment != cx->runtime->atomsCompartment);
return JS_CompileFunctionForPrincipals(cx, obj, NULL, name, nargs, argnames, bytes, length,
filename, lineno);
}
JS_PUBLIC_API(JSString *)
JS_DecompileScript(JSContext *cx, JSScript *script, const char *name, uintN indent)
{
JS_THREADSAFE_ASSERT(cx->compartment != cx->runtime->atomsCompartment);
JSPrinter *jp;
JSString *str;
CHECK_REQUEST(cx);
#ifdef DEBUG
if (cx->compartment != script->compartment())
CompartmentChecker::fail(cx->compartment, script->compartment());
#endif
jp = js_NewPrinter(cx, name, NULL,
indent & ~JS_DONT_PRETTY_PRINT,
!(indent & JS_DONT_PRETTY_PRINT),
false, false);
if (!jp)
return NULL;
if (js_DecompileScript(jp, script))
str = js_GetPrinterOutput(jp);
else
str = NULL;
js_DestroyPrinter(jp);
return str;
}
JS_PUBLIC_API(JSString *)
JS_DecompileFunction(JSContext *cx, JSFunction *fun, uintN indent)
{
JS_THREADSAFE_ASSERT(cx->compartment != cx->runtime->atomsCompartment);
CHECK_REQUEST(cx);
assertSameCompartment(cx, fun);
return js_DecompileToString(cx, "JS_DecompileFunction", fun,
indent & ~JS_DONT_PRETTY_PRINT,
!(indent & JS_DONT_PRETTY_PRINT),
false, false, js_DecompileFunction);
}
JS_PUBLIC_API(JSString *)
JS_DecompileFunctionBody(JSContext *cx, JSFunction *fun, uintN indent)
{
JS_THREADSAFE_ASSERT(cx->compartment != cx->runtime->atomsCompartment);
CHECK_REQUEST(cx);
assertSameCompartment(cx, fun);
return js_DecompileToString(cx, "JS_DecompileFunctionBody", fun,
indent & ~JS_DONT_PRETTY_PRINT,
!(indent & JS_DONT_PRETTY_PRINT),
false, false, js_DecompileFunctionBody);
}
JS_PUBLIC_API(JSBool)
JS_ExecuteScript(JSContext *cx, JSObject *obj, JSScript *script, jsval *rval)
{
JS_THREADSAFE_ASSERT(cx->compartment != cx->runtime->atomsCompartment);
CHECK_REQUEST(cx);
assertSameCompartment(cx, obj, script);
AutoLastFrameCheck lfc(cx);
return Execute(cx, script, *obj, rval);
}
JS_PUBLIC_API(JSBool)
JS_ExecuteScriptVersion(JSContext *cx, JSObject *obj, JSScript *script, jsval *rval,
JSVersion version)
{
AutoVersionAPI ava(cx, version);
return JS_ExecuteScript(cx, obj, script, rval);
}
bool
EvaluateUCScriptForPrincipalsCommon(JSContext *cx, JSObject *obj,
JSPrincipals *principals, JSPrincipals *originPrincipals,
const jschar *chars, uintN length,
const char *filename, uintN lineno,
jsval *rval, JSVersion compileVersion)
{
JS_THREADSAFE_ASSERT(cx->compartment != cx->runtime->atomsCompartment);
uint32_t flags = TCF_COMPILE_N_GO | TCF_NEED_SCRIPT_GLOBAL;
if (!rval)
flags |= TCF_NO_SCRIPT_RVAL;
CHECK_REQUEST(cx);
AutoLastFrameCheck lfc(cx);
JSScript *script = frontend::CompileScript(cx, obj, NULL, principals, originPrincipals,
flags, chars, length, filename, lineno,
compileVersion);
if (!script)
return false;
JS_ASSERT(script->getVersion() == compileVersion);
return Execute(cx, script, *obj, rval);
}
JS_PUBLIC_API(JSBool)
JS_EvaluateUCScriptForPrincipals(JSContext *cx, JSObject *obj,
JSPrincipals *principals,
const jschar *chars, uintN length,
const char *filename, uintN lineno,
jsval *rval)
{
return EvaluateUCScriptForPrincipalsCommon(cx, obj, principals, NULL, chars, length,
filename, lineno, rval, cx->findVersion());
}
JS_PUBLIC_API(JSBool)
JS_EvaluateUCScriptForPrincipalsVersion(JSContext *cx, JSObject *obj,
JSPrincipals *principals,
const jschar *chars, uintN length,
const char *filename, uintN lineno,
jsval *rval, JSVersion version)
{
AutoVersionAPI avi(cx, version);
return EvaluateUCScriptForPrincipalsCommon(cx, obj, principals, NULL, chars, length,
filename, lineno, rval, avi.version());
}
extern JS_PUBLIC_API(JSBool)
JS_EvaluateUCScriptForPrincipalsVersionOrigin(JSContext *cx, JSObject *obj,
JSPrincipals *principals,
JSPrincipals *originPrincipals,
const jschar *chars, uintN length,
const char *filename, uintN lineno,
jsval *rval, JSVersion version)
{
AutoVersionAPI avi(cx, version);
return EvaluateUCScriptForPrincipalsCommon(cx, obj, principals, originPrincipals,
chars, length, filename, lineno, rval,
avi.version());
}
JS_PUBLIC_API(JSBool)
JS_EvaluateUCScript(JSContext *cx, JSObject *obj, const jschar *chars, uintN length,
const char *filename, uintN lineno, jsval *rval)
{
JS_THREADSAFE_ASSERT(cx->compartment != cx->runtime->atomsCompartment);
return JS_EvaluateUCScriptForPrincipals(cx, obj, NULL, chars, length, filename, lineno, rval);
}
/* Ancient uintN nbytes is part of API/ABI, so use size_t length local. */
JS_PUBLIC_API(JSBool)
JS_EvaluateScriptForPrincipals(JSContext *cx, JSObject *obj, JSPrincipals *principals,
const char *bytes, uintN nbytes,
const char *filename, uintN lineno, jsval *rval)
{
JS_THREADSAFE_ASSERT(cx->compartment != cx->runtime->atomsCompartment);
size_t length = nbytes;
jschar *chars = InflateString(cx, bytes, &length);
if (!chars)
return JS_FALSE;
JSBool ok = JS_EvaluateUCScriptForPrincipals(cx, obj, principals, chars, length,
filename, lineno, rval);
cx->free_(chars);
return ok;
}
JS_PUBLIC_API(JSBool)
JS_EvaluateScriptForPrincipalsVersion(JSContext *cx, JSObject *obj, JSPrincipals *principals,
const char *bytes, uintN nbytes,
const char *filename, uintN lineno, jsval *rval, JSVersion version)
{
AutoVersionAPI avi(cx, version);
return JS_EvaluateScriptForPrincipals(cx, obj, principals, bytes, nbytes, filename, lineno,
rval);
}
JS_PUBLIC_API(JSBool)
JS_EvaluateScript(JSContext *cx, JSObject *obj, const char *bytes, uintN nbytes,
const char *filename, uintN lineno, jsval *rval)
{
JS_THREADSAFE_ASSERT(cx->compartment != cx->runtime->atomsCompartment);
return JS_EvaluateScriptForPrincipals(cx, obj, NULL, bytes, nbytes, filename, lineno, rval);
}
JS_PUBLIC_API(JSBool)
JS_CallFunction(JSContext *cx, JSObject *obj, JSFunction *fun, uintN argc, jsval *argv,
jsval *rval)
{
JS_THREADSAFE_ASSERT(cx->compartment != cx->runtime->atomsCompartment);
CHECK_REQUEST(cx);
assertSameCompartment(cx, obj, fun, JSValueArray(argv, argc));
AutoLastFrameCheck lfc(cx);
return Invoke(cx, ObjectOrNullValue(obj), ObjectValue(*fun), argc, argv, rval);
}
JS_PUBLIC_API(JSBool)
JS_CallFunctionName(JSContext *cx, JSObject *obj, const char *name, uintN argc, jsval *argv,
jsval *rval)
{
JS_THREADSAFE_ASSERT(cx->compartment != cx->runtime->atomsCompartment);
CHECK_REQUEST(cx);
assertSameCompartment(cx, obj, JSValueArray(argv, argc));
AutoLastFrameCheck lfc(cx);
Value v;
JSAtom *atom = js_Atomize(cx, name, strlen(name));
return atom &&
js_GetMethod(cx, obj, ATOM_TO_JSID(atom), JSGET_NO_METHOD_BARRIER, &v) &&
Invoke(cx, ObjectOrNullValue(obj), v, argc, argv, rval);
}
JS_PUBLIC_API(JSBool)
JS_CallFunctionValue(JSContext *cx, JSObject *obj, jsval fval, uintN argc, jsval *argv,
jsval *rval)
{
JS_THREADSAFE_ASSERT(cx->compartment != cx->runtime->atomsCompartment);
CHECK_REQUEST(cx);
assertSameCompartment(cx, obj, fval, JSValueArray(argv, argc));
AutoLastFrameCheck lfc(cx);
return Invoke(cx, ObjectOrNullValue(obj), fval, argc, argv, rval);
}
namespace JS {
JS_PUBLIC_API(bool)
Call(JSContext *cx, jsval thisv, jsval fval, uintN argc, jsval *argv, jsval *rval)
{
CHECK_REQUEST(cx);
assertSameCompartment(cx, thisv, fval, JSValueArray(argv, argc));
AutoLastFrameCheck lfc(cx);
return Invoke(cx, thisv, fval, argc, argv, rval);
}
} // namespace JS
JS_PUBLIC_API(JSObject *)
JS_New(JSContext *cx, JSObject *ctor, uintN argc, jsval *argv)
{
CHECK_REQUEST(cx);
assertSameCompartment(cx, ctor, JSValueArray(argv, argc));
AutoLastFrameCheck lfc(cx);
// This is not a simple variation of JS_CallFunctionValue because JSOP_NEW
// is not a simple variation of JSOP_CALL. We have to determine what class
// of object to create, create it, and clamp the return value to an object,
// among other details. InvokeConstructor does the hard work.
InvokeArgsGuard args;
if (!cx->stack.pushInvokeArgs(cx, argc, &args))
return NULL;
args.calleev().setObject(*ctor);
args.thisv().setNull();
memcpy(args.array(), argv, argc * sizeof(jsval));
if (!InvokeConstructor(cx, args))
return NULL;
if (!args.rval().isObject()) {
/*
* Although constructors may return primitives (via proxies), this
* API is asking for an object, so we report an error.
*/
JSAutoByteString bytes;
if (js_ValueToPrintable(cx, args.rval(), &bytes)) {
JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL, JSMSG_BAD_NEW_RESULT,
bytes.ptr());
}
return NULL;
}
return &args.rval().toObject();
}
JS_PUBLIC_API(JSOperationCallback)
JS_SetOperationCallback(JSContext *cx, JSOperationCallback callback)
{
#ifdef JS_THREADSAFE
JS_ASSERT(CURRENT_THREAD_IS_ME(cx->thread()));
#endif
JSOperationCallback old = cx->operationCallback;
cx->operationCallback = callback;
return old;
}
JS_PUBLIC_API(JSOperationCallback)
JS_GetOperationCallback(JSContext *cx)
{
return cx->operationCallback;
}
JS_PUBLIC_API(void)
JS_TriggerOperationCallback(JSContext *cx)
{
#ifdef JS_THREADSAFE
AutoLockGC lock(cx->runtime);
#endif
TriggerOperationCallback(cx);
}
JS_PUBLIC_API(void)
JS_TriggerAllOperationCallbacks(JSRuntime *rt)
{
#ifdef JS_THREADSAFE
AutoLockGC lock(rt);
#endif
TriggerAllOperationCallbacks(rt);
}
JS_PUBLIC_API(JSBool)
JS_IsRunning(JSContext *cx)
{
#ifdef JS_THREADSAFE
if (!cx->thread())
return false;
#endif
StackFrame *fp = cx->maybefp();
while (fp && fp->isDummyFrame())
fp = fp->prev();
return fp != NULL;
}
JS_PUBLIC_API(JSBool)
JS_SaveFrameChain(JSContext *cx)
{
CHECK_REQUEST(cx);
return cx->stack.saveFrameChain();
}
JS_PUBLIC_API(void)
JS_RestoreFrameChain(JSContext *cx)
{
CHECK_REQUEST(cx);
cx->stack.restoreFrameChain();
}
#ifdef MOZ_TRACE_JSCALLS
JS_PUBLIC_API(void)
JS_SetFunctionCallback(JSContext *cx, JSFunctionCallback fcb)
{
cx->functionCallback = fcb;
}
JS_PUBLIC_API(JSFunctionCallback)
JS_GetFunctionCallback(JSContext *cx)
{
return cx->functionCallback;
}
#endif
/************************************************************************/
JS_PUBLIC_API(JSString *)
JS_NewStringCopyN(JSContext *cx, const char *s, size_t n)
{
CHECK_REQUEST(cx);
return js_NewStringCopyN(cx, s, n);
}
JS_PUBLIC_API(JSString *)
JS_NewStringCopyZ(JSContext *cx, const char *s)
{
size_t n;
jschar *js;
JSString *str;
CHECK_REQUEST(cx);
if (!s)
return cx->runtime->emptyString;
n = strlen(s);
js = InflateString(cx, s, &n);
if (!js)
return NULL;
str = js_NewString(cx, js, n);
if (!str)
cx->free_(js);
return str;
}
JS_PUBLIC_API(JSBool)
JS_StringHasBeenInterned(JSContext *cx, JSString *str)
{
CHECK_REQUEST(cx);
if (!str->isAtom())
return false;
return AtomIsInterned(cx, &str->asAtom());
}
JS_PUBLIC_API(JSString *)
JS_InternJSString(JSContext *cx, JSString *str)
{
CHECK_REQUEST(cx);
JSAtom *atom = js_AtomizeString(cx, str, InternAtom);
JS_ASSERT_IF(atom, JS_StringHasBeenInterned(cx, atom));
return atom;
}
JS_PUBLIC_API(JSString *)
JS_InternString(JSContext *cx, const char *s)
{
CHECK_REQUEST(cx);
JSAtom *atom = js_Atomize(cx, s, strlen(s), InternAtom);
JS_ASSERT_IF(atom, JS_StringHasBeenInterned(cx, atom));
return atom;
}
JS_PUBLIC_API(JSString *)
JS_NewUCString(JSContext *cx, jschar *chars, size_t length)
{
CHECK_REQUEST(cx);
return js_NewString(cx, chars, length);
}
JS_PUBLIC_API(JSString *)
JS_NewUCStringCopyN(JSContext *cx, const jschar *s, size_t n)
{
CHECK_REQUEST(cx);
return js_NewStringCopyN(cx, s, n);
}
JS_PUBLIC_API(JSString *)
JS_NewUCStringCopyZ(JSContext *cx, const jschar *s)
{
CHECK_REQUEST(cx);
if (!s)
return cx->runtime->emptyString;
return js_NewStringCopyZ(cx, s);
}
JS_PUBLIC_API(JSString *)
JS_InternUCStringN(JSContext *cx, const jschar *s, size_t length)
{
CHECK_REQUEST(cx);
JSAtom *atom = js_AtomizeChars(cx, s, length, InternAtom);
JS_ASSERT_IF(atom, JS_StringHasBeenInterned(cx, atom));
return atom;
}
JS_PUBLIC_API(JSString *)
JS_InternUCString(JSContext *cx, const jschar *s)
{
return JS_InternUCStringN(cx, s, js_strlen(s));
}
JS_PUBLIC_API(size_t)
JS_GetStringLength(JSString *str)
{
return str->length();
}
JS_PUBLIC_API(const jschar *)
JS_GetStringCharsZ(JSContext *cx, JSString *str)
{
CHECK_REQUEST(cx);
assertSameCompartment(cx, str);
return str->getCharsZ(cx);
}
JS_PUBLIC_API(const jschar *)
JS_GetStringCharsZAndLength(JSContext *cx, JSString *str, size_t *plength)
{
CHECK_REQUEST(cx);
assertSameCompartment(cx, str);
*plength = str->length();
return str->getCharsZ(cx);
}
JS_PUBLIC_API(const jschar *)
JS_GetStringCharsAndLength(JSContext *cx, JSString *str, size_t *plength)
{
CHECK_REQUEST(cx);
assertSameCompartment(cx, str);
*plength = str->length();
return str->getChars(cx);
}
JS_PUBLIC_API(const jschar *)
JS_GetInternedStringChars(JSString *str)
{
return str->asAtom().chars();
}
JS_PUBLIC_API(const jschar *)
JS_GetInternedStringCharsAndLength(JSString *str, size_t *plength)
{
JSAtom &atom = str->asAtom();
*plength = atom.length();
return atom.chars();
}
extern JS_PUBLIC_API(JSFlatString *)
JS_FlattenString(JSContext *cx, JSString *str)
{
CHECK_REQUEST(cx);
assertSameCompartment(cx, str);
return str->getCharsZ(cx) ? (JSFlatString *)str : NULL;
}
extern JS_PUBLIC_API(const jschar *)
JS_GetFlatStringChars(JSFlatString *str)
{
return str->chars();
}
JS_PUBLIC_API(JSBool)
JS_CompareStrings(JSContext *cx, JSString *str1, JSString *str2, int32_t *result)
{
CHECK_REQUEST(cx);
return CompareStrings(cx, str1, str2, result);
}
JS_PUBLIC_API(JSBool)
JS_StringEqualsAscii(JSContext *cx, JSString *str, const char *asciiBytes, JSBool *match)
{
CHECK_REQUEST(cx);
JSLinearString *linearStr = str->ensureLinear(cx);
if (!linearStr)
return false;
*match = StringEqualsAscii(linearStr, asciiBytes);
return true;
}
JS_PUBLIC_API(JSBool)
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)
{
JSLinearString *linearStr = str->ensureLinear(cx);
if (!linearStr)
return size_t(-1);
return PutEscapedString(buffer, size, linearStr, quote);
}
JS_PUBLIC_API(JSBool)
JS_FileEscapedString(FILE *fp, JSString *str, char quote)
{
JSLinearString *linearStr = str->ensureLinear(NULL);
return linearStr && FileEscapedString(fp, linearStr, quote);
}
JS_PUBLIC_API(JSString *)
JS_NewGrowableString(JSContext *cx, jschar *chars, size_t length)
{
CHECK_REQUEST(cx);
return js_NewString(cx, chars, length);
}
JS_PUBLIC_API(JSString *)
JS_NewDependentString(JSContext *cx, JSString *str, size_t start, size_t length)
{
CHECK_REQUEST(cx);
return js_NewDependentString(cx, str, start, length);
}
JS_PUBLIC_API(JSString *)
JS_ConcatStrings(JSContext *cx, JSString *left, JSString *right)
{
CHECK_REQUEST(cx);
return js_ConcatStrings(cx, left, right);
}
JS_PUBLIC_API(const jschar *)
JS_UndependString(JSContext *cx, JSString *str)
{
CHECK_REQUEST(cx);
return str->getCharsZ(cx);
}
JS_PUBLIC_API(JSBool)
JS_MakeStringImmutable(JSContext *cx, JSString *str)
{
CHECK_REQUEST(cx);
return !!str->ensureFixed(cx);
}
JS_PUBLIC_API(JSBool)
JS_EncodeCharacters(JSContext *cx, const jschar *src, size_t srclen, char *dst, size_t *dstlenp)
{
size_t n;
if (!dst) {
n = GetDeflatedStringLength(cx, src, srclen);
if (n == (size_t)-1) {
*dstlenp = 0;
return JS_FALSE;
}
*dstlenp = n;
return JS_TRUE;
}
return DeflateStringToBuffer(cx, src, srclen, dst, dstlenp);
}
JS_PUBLIC_API(JSBool)
JS_DecodeBytes(JSContext *cx, const char *src, size_t srclen, jschar *dst, size_t *dstlenp)
{
return InflateStringToBuffer(cx, src, srclen, dst, dstlenp);
}
JS_PUBLIC_API(JSBool)
JS_DecodeUTF8(JSContext *cx, const char *src, size_t srclen, jschar *dst,
size_t *dstlenp)
{
return InflateUTF8StringToBuffer(cx, src, srclen, dst, dstlenp);
}
JS_PUBLIC_API(char *)
JS_EncodeString(JSContext *cx, JSString *str)
{
const jschar *chars = str->getChars(cx);
if (!chars)
return NULL;
return DeflateString(cx, chars, str->length());
}
JS_PUBLIC_API(size_t)
JS_GetStringEncodingLength(JSContext *cx, JSString *str)
{
const jschar *chars = str->getChars(cx);
if (!chars)
return size_t(-1);
return GetDeflatedStringLength(cx, chars, str->length());
}
JS_PUBLIC_API(size_t)
JS_EncodeStringToBuffer(JSString *str, char *buffer, size_t length)
{
/*
* FIXME bug 612141 - fix DeflateStringToBuffer interface so the result
* would allow to distinguish between insufficient buffer and encoding
* error.
*/
size_t writtenLength = length;
const jschar *chars = str->getChars(NULL);
if (!chars)
return size_t(-1);
if (DeflateStringToBuffer(NULL, chars, str->length(), buffer, &writtenLength)) {
JS_ASSERT(writtenLength <= length);
return writtenLength;
}
JS_ASSERT(writtenLength <= length);
size_t necessaryLength = GetDeflatedStringLength(NULL, chars, str->length());
if (necessaryLength == size_t(-1))
return size_t(-1);
if (writtenLength != length) {
/* Make sure that the buffer contains only valid UTF-8 sequences. */
JS_ASSERT(js_CStringsAreUTF8);
PodZero(buffer + writtenLength, length - writtenLength);
}
return necessaryLength;
}
JS_PUBLIC_API(JSBool)
JS_Stringify(JSContext *cx, jsval *vp, JSObject *replacer, jsval space,
JSONWriteCallback callback, void *data)
{
CHECK_REQUEST(cx);
assertSameCompartment(cx, replacer, space);
StringBuffer sb(cx);
if (!js_Stringify(cx, vp, replacer, space, sb))
return false;
if (sb.empty()) {
JSAtom *nullAtom = cx->runtime->atomState.nullAtom;
return callback(nullAtom->chars(), nullAtom->length(), data);
}
return callback(sb.begin(), sb.length(), data);
}
JS_PUBLIC_API(JSBool)
JS_ParseJSON(JSContext *cx, const jschar *chars, uint32_t len, jsval *vp)
{
CHECK_REQUEST(cx);
return ParseJSONWithReviver(cx, chars, len, NullValue(), vp);
}
JS_PUBLIC_API(JSBool)
JS_ParseJSONWithReviver(JSContext *cx, const jschar *chars, uint32_t len, jsval reviver, jsval *vp)
{
CHECK_REQUEST(cx);
return ParseJSONWithReviver(cx, chars, len, reviver, vp);
}
JS_PUBLIC_API(JSBool)
JS_ReadStructuredClone(JSContext *cx, const uint64_t *buf, size_t nbytes,
uint32_t version, jsval *vp,
const JSStructuredCloneCallbacks *optionalCallbacks,
void *closure)
{
CHECK_REQUEST(cx);
if (version > JS_STRUCTURED_CLONE_VERSION) {
JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL, JSMSG_BAD_CLONE_VERSION);
return false;
}
const JSStructuredCloneCallbacks *callbacks =
optionalCallbacks ?
optionalCallbacks :
cx->runtime->structuredCloneCallbacks;
return ReadStructuredClone(cx, buf, nbytes, vp, callbacks, closure);
}
JS_PUBLIC_API(JSBool)
JS_WriteStructuredClone(JSContext *cx, jsval v, uint64_t **bufp, size_t *nbytesp,
const JSStructuredCloneCallbacks *optionalCallbacks,
void *closure)
{
CHECK_REQUEST(cx);
const JSStructuredCloneCallbacks *callbacks =
optionalCallbacks ?
optionalCallbacks :
cx->runtime->structuredCloneCallbacks;
return WriteStructuredClone(cx, v, (uint64_t **) bufp, nbytesp, callbacks, closure);
}
JS_PUBLIC_API(JSBool)
JS_StructuredClone(JSContext *cx, jsval v, jsval *vp,
const JSStructuredCloneCallbacks *optionalCallbacks,
void *closure)
{
CHECK_REQUEST(cx);
const JSStructuredCloneCallbacks *callbacks =
optionalCallbacks ?
optionalCallbacks :
cx->runtime->structuredCloneCallbacks;
JSAutoStructuredCloneBuffer buf;
return buf.write(cx, v, callbacks, closure) &&
buf.read(cx, vp, callbacks, closure);
}
void
JSAutoStructuredCloneBuffer::clear()
{
if (data_) {
Foreground::free_(data_);
data_ = NULL;
nbytes_ = 0;
version_ = 0;
}
}
void
JSAutoStructuredCloneBuffer::adopt(uint64_t *data, size_t nbytes, uint32_t version)
{
clear();
data_ = data;
nbytes_ = nbytes;
version_ = version;
}
bool
JSAutoStructuredCloneBuffer::copy(const uint64_t *srcData, size_t nbytes, uint32_t version)
{
uint64_t *newData = static_cast<uint64_t *>(OffTheBooks::malloc_(nbytes));
if (!newData)
return false;
memcpy(newData, srcData, nbytes);
clear();
data_ = newData;
nbytes_ = nbytes;
version_ = version;
return true;
}
void
JSAutoStructuredCloneBuffer::steal(uint64_t **datap, size_t *nbytesp, uint32_t *versionp)
{
*datap = data_;
*nbytesp = nbytes_;
if (versionp)
*versionp = version_;
data_ = NULL;
nbytes_ = 0;
version_ = 0;
}
bool
JSAutoStructuredCloneBuffer::read(JSContext *cx, jsval *vp,
const JSStructuredCloneCallbacks *optionalCallbacks,
void *closure) const
{
JS_ASSERT(cx);
JS_ASSERT(data_);
return !!JS_ReadStructuredClone(cx, data_, nbytes_, version_, vp,
optionalCallbacks, closure);
}
bool
JSAutoStructuredCloneBuffer::write(JSContext *cx, jsval v,
const JSStructuredCloneCallbacks *optionalCallbacks,
void *closure)
{
clear();
bool ok = !!JS_WriteStructuredClone(cx, v, &data_, &nbytes_,
optionalCallbacks, closure);
if (!ok) {
data_ = NULL;
nbytes_ = 0;
version_ = JS_STRUCTURED_CLONE_VERSION;
}
return ok;
}
void
JSAutoStructuredCloneBuffer::swap(JSAutoStructuredCloneBuffer &other)
{
uint64_t *data = other.data_;
size_t nbytes = other.nbytes_;
uint32_t version = other.version_;
other.data_ = this->data_;
other.nbytes_ = this->nbytes_;
other.version_ = this->version_;
this->data_ = data;
this->nbytes_ = nbytes;
this->version_ = version;
}
JS_PUBLIC_API(void)
JS_SetStructuredCloneCallbacks(JSRuntime *rt, const JSStructuredCloneCallbacks *callbacks)
{
rt->structuredCloneCallbacks = callbacks;
}
JS_PUBLIC_API(JSBool)
JS_ReadUint32Pair(JSStructuredCloneReader *r, uint32_t *p1, uint32_t *p2)
{
return r->input().readPair((uint32_t *) p1, (uint32_t *) p2);
}
JS_PUBLIC_API(JSBool)
JS_ReadBytes(JSStructuredCloneReader *r, void *p, size_t len)
{
return r->input().readBytes(p, len);
}
JS_PUBLIC_API(JSBool)
JS_WriteUint32Pair(JSStructuredCloneWriter *w, uint32_t tag, uint32_t data)
{
return w->output().writePair(tag, data);
}
JS_PUBLIC_API(JSBool)
JS_WriteBytes(JSStructuredCloneWriter *w, const void *p, size_t len)
{
return w->output().writeBytes(p, len);
}
/*
* The following determines whether C Strings are to be treated as UTF-8
* or ISO-8859-1. For correct operation, it must be set prior to the
* first call to JS_NewRuntime.
*/
#ifndef JS_C_STRINGS_ARE_UTF8
JSBool js_CStringsAreUTF8 = JS_FALSE;
#endif
JS_PUBLIC_API(JSBool)
JS_CStringsAreUTF8()
{
return js_CStringsAreUTF8;
}
JS_PUBLIC_API(void)
JS_SetCStringsAreUTF8()
{
JS_ASSERT(!js_NewRuntimeWasCalled);
#ifndef JS_C_STRINGS_ARE_UTF8
js_CStringsAreUTF8 = JS_TRUE;
#endif
}
/************************************************************************/
JS_PUBLIC_API(void)
JS_ReportError(JSContext *cx, const char *format, ...)
{
va_list ap;
va_start(ap, format);
js_ReportErrorVA(cx, JSREPORT_ERROR, format, ap);
va_end(ap);
}
JS_PUBLIC_API(void)
JS_ReportErrorNumber(JSContext *cx, JSErrorCallback errorCallback,
void *userRef, const uintN errorNumber, ...)
{
va_list ap;
va_start(ap, errorNumber);
js_ReportErrorNumberVA(cx, JSREPORT_ERROR, errorCallback, userRef,
errorNumber, JS_TRUE, ap);
va_end(ap);
}
JS_PUBLIC_API(void)
JS_ReportErrorNumberUC(JSContext *cx, JSErrorCallback errorCallback,
void *userRef, const uintN errorNumber, ...)
{
va_list ap;
va_start(ap, errorNumber);
js_ReportErrorNumberVA(cx, JSREPORT_ERROR, errorCallback, userRef,
errorNumber, JS_FALSE, ap);
va_end(ap);
}
JS_PUBLIC_API(JSBool)
JS_ReportWarning(JSContext *cx, const char *format, ...)
{
va_list ap;
JSBool ok;
va_start(ap, format);
ok = js_ReportErrorVA(cx, JSREPORT_WARNING, format, ap);
va_end(ap);
return ok;
}
JS_PUBLIC_API(JSBool)
JS_ReportErrorFlagsAndNumber(JSContext *cx, uintN flags,
JSErrorCallback errorCallback, void *userRef,
const uintN errorNumber, ...)
{
va_list ap;
JSBool ok;
va_start(ap, errorNumber);
ok = js_ReportErrorNumberVA(cx, flags, errorCallback, userRef,
errorNumber, JS_TRUE, ap);
va_end(ap);
return ok;
}
JS_PUBLIC_API(JSBool)
JS_ReportErrorFlagsAndNumberUC(JSContext *cx, uintN flags,
JSErrorCallback errorCallback, void *userRef,
const uintN errorNumber, ...)
{
va_list ap;
JSBool ok;
va_start(ap, errorNumber);
ok = js_ReportErrorNumberVA(cx, flags, errorCallback, userRef,
errorNumber, JS_FALSE, ap);
va_end(ap);
return ok;
}
JS_PUBLIC_API(void)
JS_ReportOutOfMemory(JSContext *cx)
{
js_ReportOutOfMemory(cx);
}
JS_PUBLIC_API(void)
JS_ReportAllocationOverflow(JSContext *cx)
{
js_ReportAllocationOverflow(cx);
}
JS_PUBLIC_API(JSErrorReporter)
JS_SetErrorReporter(JSContext *cx, JSErrorReporter er)
{
JSErrorReporter older;
older = cx->errorReporter;
cx->errorReporter = er;
return older;
}
/************************************************************************/
/*
* Dates.
*/
JS_PUBLIC_API(JSObject *)
JS_NewDateObject(JSContext *cx, int year, int mon, int mday, int hour, int min, int sec)
{
CHECK_REQUEST(cx);
return js_NewDateObject(cx, year, mon, mday, hour, min, sec);
}
JS_PUBLIC_API(JSObject *)
JS_NewDateObjectMsec(JSContext *cx, jsdouble msec)
{
CHECK_REQUEST(cx);
return js_NewDateObjectMsec(cx, msec);
}
JS_PUBLIC_API(JSBool)
JS_ObjectIsDate(JSContext *cx, JSObject *obj)
{
JS_ASSERT(obj);
return obj->isDate();
}
/************************************************************************/
/*
* Regular Expressions.
*/
JS_PUBLIC_API(JSObject *)
JS_NewRegExpObject(JSContext *cx, JSObject *obj, char *bytes, size_t length, uintN flags)
{
CHECK_REQUEST(cx);
jschar *chars = InflateString(cx, bytes, &length);
if (!chars)
return NULL;
RegExpStatics *res = obj->asGlobal()->getRegExpStatics();
RegExpObject *reobj = RegExpObject::create(cx, res, chars, length, RegExpFlag(flags), NULL);
cx->free_(chars);
return reobj;
}
JS_PUBLIC_API(JSObject *)
JS_NewUCRegExpObject(JSContext *cx, JSObject *obj, jschar *chars, size_t length, uintN flags)
{
CHECK_REQUEST(cx);
RegExpStatics *res = obj->asGlobal()->getRegExpStatics();
return RegExpObject::create(cx, res, chars, length, RegExpFlag(flags), NULL);
}
JS_PUBLIC_API(void)
JS_SetRegExpInput(JSContext *cx, JSObject *obj, JSString *input, JSBool multiline)
{
CHECK_REQUEST(cx);
assertSameCompartment(cx, input);
obj->asGlobal()->getRegExpStatics()->reset(cx, input, !!multiline);
}
JS_PUBLIC_API(void)
JS_ClearRegExpStatics(JSContext *cx, JSObject *obj)
{
CHECK_REQUEST(cx);
JS_ASSERT(obj);
obj->asGlobal()->getRegExpStatics()->clear();
}
JS_PUBLIC_API(JSBool)
JS_ExecuteRegExp(JSContext *cx, JSObject *obj, JSObject *reobj, jschar *chars, size_t length,
size_t *indexp, JSBool test, jsval *rval)
{
CHECK_REQUEST(cx);
RegExpStatics *res = obj->asGlobal()->getRegExpStatics();
return ExecuteRegExp(cx, res, reobj->asRegExp(), NULL, chars, length,
indexp, test ? RegExpTest : RegExpExec, rval);
}
JS_PUBLIC_API(JSObject *)
JS_NewRegExpObjectNoStatics(JSContext *cx, char *bytes, size_t length, uintN flags)
{
CHECK_REQUEST(cx);
jschar *chars = InflateString(cx, bytes, &length);
if (!chars)
return NULL;
RegExpObject *reobj = RegExpObject::createNoStatics(cx, chars, length, RegExpFlag(flags), NULL);
cx->free_(chars);
return reobj;
}
JS_PUBLIC_API(JSObject *)
JS_NewUCRegExpObjectNoStatics(JSContext *cx, jschar *chars, size_t length, uintN flags)
{
CHECK_REQUEST(cx);
return RegExpObject::createNoStatics(cx, chars, length, RegExpFlag(flags), NULL);
}
JS_PUBLIC_API(JSBool)
JS_ExecuteRegExpNoStatics(JSContext *cx, JSObject *obj, jschar *chars, size_t length,
size_t *indexp, JSBool test, jsval *rval)
{
CHECK_REQUEST(cx);
return ExecuteRegExp(cx, NULL, obj->asRegExp(), NULL, chars, length, indexp,
test ? RegExpTest : RegExpExec, rval);
}
JS_PUBLIC_API(JSBool)
JS_ObjectIsRegExp(JSContext *cx, JSObject *obj)
{
JS_ASSERT(obj);
return obj->isRegExp();
}
JS_PUBLIC_API(uintN)
JS_GetRegExpFlags(JSContext *cx, JSObject *obj)
{
CHECK_REQUEST(cx);
return obj->asRegExp()->getFlags();
}
JS_PUBLIC_API(JSString *)
JS_GetRegExpSource(JSContext *cx, JSObject *obj)
{
CHECK_REQUEST(cx);
return obj->asRegExp()->getSource();
}
/************************************************************************/
JS_PUBLIC_API(void)
JS_SetLocaleCallbacks(JSContext *cx, JSLocaleCallbacks *callbacks)
{
cx->localeCallbacks = callbacks;
}
JS_PUBLIC_API(JSLocaleCallbacks *)
JS_GetLocaleCallbacks(JSContext *cx)
{
return cx->localeCallbacks;
}
/************************************************************************/
JS_PUBLIC_API(JSBool)
JS_IsExceptionPending(JSContext *cx)
{
return (JSBool) cx->isExceptionPending();
}
JS_PUBLIC_API(JSBool)
JS_GetPendingException(JSContext *cx, jsval *vp)
{
CHECK_REQUEST(cx);
if (!cx->isExceptionPending())
return JS_FALSE;
*vp = cx->getPendingException();
assertSameCompartment(cx, *vp);
return JS_TRUE;
}
JS_PUBLIC_API(void)
JS_SetPendingException(JSContext *cx, jsval v)
{
CHECK_REQUEST(cx);
assertSameCompartment(cx, v);
cx->setPendingException(v);
}
JS_PUBLIC_API(void)
JS_ClearPendingException(JSContext *cx)
{
cx->clearPendingException();
}
JS_PUBLIC_API(JSBool)
JS_ReportPendingException(JSContext *cx)
{
JSBool ok;
JSPackedBool save;
CHECK_REQUEST(cx);
/*
* Set cx->generatingError to suppress the standard error-to-exception
* conversion done by all {js,JS}_Report* functions except for OOM. The
* cx->generatingError flag was added to suppress recursive divergence
* under js_ErrorToException, but it serves for our purposes here too.
*/
save = cx->generatingError;
cx->generatingError = JS_TRUE;
ok = js_ReportUncaughtException(cx);
cx->generatingError = save;
return ok;
}
struct JSExceptionState {
JSBool throwing;
jsval exception;
};
JS_PUBLIC_API(JSExceptionState *)
JS_SaveExceptionState(JSContext *cx)
{
JSExceptionState *state;
CHECK_REQUEST(cx);
state = (JSExceptionState *) cx->malloc_(sizeof(JSExceptionState));
if (state) {
state->throwing = JS_GetPendingException(cx, &state->exception);
if (state->throwing && JSVAL_IS_GCTHING(state->exception))
js_AddRoot(cx, &state->exception, "JSExceptionState.exception");
}
return state;
}
JS_PUBLIC_API(void)
JS_RestoreExceptionState(JSContext *cx, JSExceptionState *state)
{
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)
{
CHECK_REQUEST(cx);
if (state) {
if (state->throwing && JSVAL_IS_GCTHING(state->exception)) {
assertSameCompartment(cx, state->exception);
JS_RemoveValueRoot(cx, &state->exception);
}
cx->free_(state);
}
}
JS_PUBLIC_API(JSErrorReport *)
JS_ErrorFromException(JSContext *cx, jsval v)
{
CHECK_REQUEST(cx);
assertSameCompartment(cx, v);
return js_ErrorFromException(cx, v);
}
JS_PUBLIC_API(JSBool)
JS_ThrowReportedError(JSContext *cx, const char *message,
JSErrorReport *reportp)
{
return JS_IsRunning(cx) &&
js_ErrorToException(cx, message, reportp, NULL, NULL);
}
JS_PUBLIC_API(JSBool)
JS_ThrowStopIteration(JSContext *cx)
{
return js_ThrowStopIteration(cx);
}
/*
* Get the owning thread id of a context. Returns 0 if the context is not
* owned by any thread.
*/
JS_PUBLIC_API(jsword)
JS_GetContextThread(JSContext *cx)
{
#ifdef JS_THREADSAFE
return reinterpret_cast<jsword>(JS_THREAD_ID(cx));
#else
return 0;
#endif
}
/*
* Set the current thread as the owning thread of a context. Returns the
* old owning thread id, or -1 if the operation failed.
*/
JS_PUBLIC_API(jsword)
JS_SetContextThread(JSContext *cx)
{
JS_AbortIfWrongThread(cx->runtime);
#ifdef JS_THREADSAFE
JS_ASSERT(!cx->outstandingRequests);
if (cx->thread()) {
JS_ASSERT(CURRENT_THREAD_IS_ME(cx->thread()));
return reinterpret_cast<jsword>(cx->thread()->id);
}
if (!js_InitContextThreadAndLockGC(cx)) {
js_ReportOutOfMemory(cx);
return -1;
}
JS_UNLOCK_GC(cx->runtime);
#endif
return 0;
}
extern JS_PUBLIC_API(void)
JS_ClearRuntimeThread(JSRuntime *rt)
{
#ifdef JS_THREADSAFE
rt->clearOwnerThread();
#endif
}
extern JS_PUBLIC_API(void)
JS_SetRuntimeThread(JSRuntime *rt)
{
#ifdef JS_THREADSAFE
rt->setOwnerThread();
#endif
}
extern JS_NEVER_INLINE JS_PUBLIC_API(void)
JS_AbortIfWrongThread(JSRuntime *rt)
{
#ifdef JS_THREADSAFE
if (!rt->onOwnerThread())
JS_Assert("rt->onOwnerThread()", __FILE__, __LINE__);
#endif
}
JS_PUBLIC_API(jsword)
JS_ClearContextThread(JSContext *cx)
{
JS_AbortIfWrongThread(cx->runtime);
#ifdef JS_THREADSAFE
/*
* cx must have exited all requests it entered and, if cx is associated
* with a thread, this must be called only from that thread. If not, this
* is a harmless no-op.
*/
JS_ASSERT(cx->outstandingRequests == 0);
JSThread *t = cx->thread();
if (!t)
return 0;
JS_ASSERT(CURRENT_THREAD_IS_ME(t));
/*
* We must not race with a GC that accesses cx->thread for all threads,
* see bug 476934.
*/
JSRuntime *rt = cx->runtime;
AutoLockGC lock(rt);
js_WaitForGC(rt);
js_ClearContextThread(cx);
JS_ASSERT_IF(JS_CLIST_IS_EMPTY(&t->contextList), !t->data.requestDepth);
/*
* We can access t->id as long as the GC lock is held and we cannot race
* with the GC that may delete t.
*/
return reinterpret_cast<jsword>(t->id);
#else
return 0;
#endif
}
#ifdef JS_GC_ZEAL
JS_PUBLIC_API(void)
JS_SetGCZeal(JSContext *cx, uint8_t zeal, uint32_t frequency, JSBool compartment)
{
bool schedule = zeal >= js::gc::ZealAllocThreshold && zeal < js::gc::ZealVerifierThreshold;
cx->runtime->gcZeal_ = zeal;
cx->runtime->gcZealFrequency = frequency;
cx->runtime->gcNextScheduled = schedule ? frequency : 0;
cx->runtime->gcDebugCompartmentGC = !!compartment;
}
JS_PUBLIC_API(void)
JS_ScheduleGC(JSContext *cx, uint32_t count, JSBool compartment)
{
cx->runtime->gcNextScheduled = count;
cx->runtime->gcDebugCompartmentGC = !!compartment;
}
#endif
JS_FRIEND_API(void *)
js_GetCompartmentPrivate(JSCompartment *compartment)
{
return compartment->data;
}
/************************************************************************/
JS_PUBLIC_API(void)
JS_RegisterReference(void **ref)
{
}
JS_PUBLIC_API(void)
JS_ModifyReference(void **ref, void *newval)
{
// XPConnect uses the lower bits of its JSObject refs for evil purposes,
// so we need to fix this.
void *thing = *ref;
*ref = newval;
thing = (void *)((uintptr_t)thing & ~7);
if (!thing)
return;
JS_ASSERT(!static_cast<gc::Cell *>(thing)->compartment()->rt->gcRunning);
uint32_t kind = GetGCThingTraceKind(thing);
if (kind == JSTRACE_OBJECT)
JSObject::writeBarrierPre((JSObject *) thing);
else if (kind == JSTRACE_STRING)
JSString::writeBarrierPre((JSString *) thing);
else
JS_NOT_REACHED("invalid trace kind");
}
JS_PUBLIC_API(void)
JS_UnregisterReference(void **ref)
{
// For now we just want to trigger a write barrier.
JS_ModifyReference(ref, NULL);
}
JS_PUBLIC_API(void)
JS_UnregisterReferenceRT(JSRuntime *rt, void **ref)
{
// For now we just want to trigger a write barrier.
if (!rt->gcRunning)
JS_ModifyReference(ref, NULL);
}
JS_PUBLIC_API(void)
JS_RegisterValue(jsval *val)
{
}
JS_PUBLIC_API(void)
JS_ModifyValue(jsval *val, jsval newval)
{
HeapValue::writeBarrierPre(*val);
*val = newval;
}
JS_PUBLIC_API(void)
JS_UnregisterValue(jsval *val)
{
JS_ModifyValue(val, JSVAL_VOID);
}
JS_PUBLIC_API(void)
JS_UnregisterValueRT(JSRuntime *rt, jsval *val)
{
if (!rt->gcRunning)
JS_ModifyValue(val, JSVAL_VOID);
}
JS_PUBLIC_API(JSTracer *)
JS_GetIncrementalGCTracer(JSRuntime *rt)
{
return rt->gcIncrementalTracer;
}
/************************************************************************/
#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(JSBool)
JS_IndexToId(JSContext *cx, uint32_t index, jsid *id)
{
return IndexToId(cx, index, id);
}
JS_PUBLIC_API(JSBool)
JS_IsIdentifier(JSContext *cx, JSString *str, JSBool *isIdentifier)
{
assertSameCompartment(cx, str);
JSLinearString* linearStr = str->ensureLinear(cx);
if (!linearStr)
return false;
*isIdentifier = js::IsIdentifier(linearStr);
return true;
}
#ifdef JS_THREADSAFE
static PRStatus
CallOnce(void *func)
{
JSInitCallback init = JS_DATA_TO_FUNC_PTR(JSInitCallback, func);
return init() ? PR_SUCCESS : PR_FAILURE;
}
#endif
JS_PUBLIC_API(JSBool)
JS_CallOnce(JSCallOnceType *once, JSInitCallback func)
{
#ifdef JS_THREADSAFE
return PR_CallOnceWithArg(once, CallOnce, JS_FUNC_TO_DATA_PTR(void *, func)) == PR_SUCCESS;
#else
if (!*once) {
*once = true;
return func();
} else {
return JS_TRUE;
}
#endif
}
