2009-11-18 12:29:58 -08:00
|
|
|
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
|
|
|
|
* vim: set ts=8 sw=4 et tw=99:
|
|
|
|
*
|
|
|
|
* ***** 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 ***** */
|
|
|
|
|
|
|
|
#ifndef jsobjinlines_h___
|
|
|
|
#define jsobjinlines_h___
|
|
|
|
|
2010-08-29 11:57:08 -07:00
|
|
|
#include <new>
|
2010-04-14 18:57:30 -07:00
|
|
|
#include "jsdate.h"
|
2010-08-29 11:57:08 -07:00
|
|
|
#include "jsfun.h"
|
2010-04-14 17:09:17 -07:00
|
|
|
#include "jsiter.h"
|
2010-08-29 11:57:08 -07:00
|
|
|
#include "jslock.h"
|
2010-04-14 18:57:30 -07:00
|
|
|
#include "jsobj.h"
|
2010-09-01 14:09:54 -07:00
|
|
|
#include "jsprobes.h"
|
2010-08-29 11:57:08 -07:00
|
|
|
#include "jspropertytree.h"
|
2009-11-18 12:29:58 -08:00
|
|
|
#include "jsscope.h"
|
2010-06-18 17:43:02 -07:00
|
|
|
#include "jsstaticcheck.h"
|
2010-05-12 18:57:36 -07:00
|
|
|
#include "jsxml.h"
|
|
|
|
|
2010-08-29 11:57:08 -07:00
|
|
|
/* Headers included for inline implementations used by this header. */
|
|
|
|
#include "jsbool.h"
|
2010-06-16 14:13:01 -07:00
|
|
|
#include "jscntxt.h"
|
2010-08-29 11:57:08 -07:00
|
|
|
#include "jsnum.h"
|
2010-04-10 16:16:35 -07:00
|
|
|
#include "jsscopeinlines.h"
|
2010-08-29 11:57:08 -07:00
|
|
|
#include "jsstr.h"
|
2010-04-10 16:16:35 -07:00
|
|
|
|
2010-06-05 14:24:54 -07:00
|
|
|
inline void
|
|
|
|
JSObject::dropProperty(JSContext *cx, JSProperty *prop)
|
|
|
|
{
|
|
|
|
JS_ASSERT(prop);
|
|
|
|
if (isNative())
|
|
|
|
JS_UNLOCK_OBJ(cx, this);
|
|
|
|
}
|
|
|
|
|
2010-08-29 11:57:08 -07:00
|
|
|
inline void
|
|
|
|
JSObject::seal(JSContext *cx)
|
|
|
|
{
|
|
|
|
JS_ASSERT(!sealed());
|
|
|
|
if (isNative())
|
|
|
|
generateOwnShape(cx);
|
|
|
|
flags |= SEALED;
|
|
|
|
}
|
|
|
|
|
|
|
|
inline bool
|
|
|
|
JSObject::brand(JSContext *cx, uint32 slot, js::Value v)
|
|
|
|
{
|
|
|
|
JS_ASSERT(!generic());
|
|
|
|
JS_ASSERT(!branded());
|
|
|
|
JS_ASSERT(isNative());
|
|
|
|
generateOwnShape(cx);
|
|
|
|
if (js_IsPropertyCacheDisabled(cx)) // check for rt->shapeGen overflow
|
|
|
|
return false;
|
|
|
|
flags |= BRANDED;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
inline bool
|
|
|
|
JSObject::unbrand(JSContext *cx)
|
|
|
|
{
|
|
|
|
JS_ASSERT(isNative());
|
|
|
|
if (!branded())
|
|
|
|
setGeneric();
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Property read barrier for deferred cloning of compiler-created function
|
|
|
|
* objects optimized as typically non-escaping, ad-hoc methods in obj.
|
|
|
|
*/
|
|
|
|
inline bool
|
|
|
|
JSObject::methodReadBarrier(JSContext *cx, const js::Shape &shape, js::Value *vp)
|
|
|
|
{
|
|
|
|
JS_ASSERT(canHaveMethodBarrier());
|
|
|
|
JS_ASSERT(hasMethodBarrier());
|
|
|
|
JS_ASSERT(nativeContains(shape));
|
|
|
|
JS_ASSERT(shape.isMethod());
|
|
|
|
JS_ASSERT(&shape.methodObject() == &vp->toObject());
|
|
|
|
|
|
|
|
JSObject *funobj = &vp->toObject();
|
|
|
|
JSFunction *fun = GET_FUNCTION_PRIVATE(cx, funobj);
|
|
|
|
JS_ASSERT(fun == funobj && FUN_NULL_CLOSURE(fun));
|
|
|
|
|
|
|
|
funobj = CloneFunctionObject(cx, fun, funobj->getParent());
|
|
|
|
if (!funobj)
|
|
|
|
return false;
|
|
|
|
funobj->setMethodObj(*this);
|
|
|
|
|
|
|
|
vp->setObject(*funobj);
|
|
|
|
if (!js_SetPropertyHelper(cx, this, shape.id, 0, vp))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
#ifdef DEBUG
|
|
|
|
if (cx->runtime->functionMeterFilename) {
|
|
|
|
JS_FUNCTION_METER(cx, mreadbarrier);
|
|
|
|
|
|
|
|
typedef JSRuntime::FunctionCountMap HM;
|
|
|
|
HM &h = cx->runtime->methodReadBarrierCountMap;
|
|
|
|
HM::AddPtr p = h.lookupForAdd(fun);
|
|
|
|
if (!p) {
|
|
|
|
h.add(p, fun, 1);
|
|
|
|
} else {
|
|
|
|
JS_ASSERT(p->key == fun);
|
|
|
|
++p->value;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static JS_ALWAYS_INLINE bool
|
|
|
|
ChangesMethodValue(const js::Value &prev, const js::Value &v)
|
|
|
|
{
|
|
|
|
JSObject *prevObj;
|
|
|
|
return prev.isObject() && (prevObj = &prev.toObject())->isFunction() &&
|
|
|
|
(!v.isObject() || &v.toObject() != prevObj);
|
|
|
|
}
|
|
|
|
|
|
|
|
inline bool
|
|
|
|
JSObject::methodWriteBarrier(JSContext *cx, const js::Shape &shape, const js::Value &v)
|
|
|
|
{
|
|
|
|
if (flags & (BRANDED | METHOD_BARRIER)) {
|
|
|
|
const js::Value &prev = lockedGetSlot(shape.slot);
|
|
|
|
|
|
|
|
if (ChangesMethodValue(prev, v)) {
|
|
|
|
JS_FUNCTION_METER(cx, mwritebarrier);
|
|
|
|
return methodShapeChange(cx, shape);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
inline bool
|
|
|
|
JSObject::methodWriteBarrier(JSContext *cx, uint32 slot, const js::Value &v)
|
|
|
|
{
|
|
|
|
if (flags & (BRANDED | METHOD_BARRIER)) {
|
|
|
|
const js::Value &prev = lockedGetSlot(slot);
|
|
|
|
|
|
|
|
if (ChangesMethodValue(prev, v)) {
|
|
|
|
JS_FUNCTION_METER(cx, mwslotbarrier);
|
|
|
|
return methodShapeChange(cx, slot);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
inline bool
|
|
|
|
JSObject::ensureClassReservedSlots(JSContext *cx)
|
|
|
|
{
|
|
|
|
return !nativeEmpty() || ensureClassReservedSlotsForEmptyObject(cx);
|
|
|
|
}
|
|
|
|
|
2010-07-14 23:19:36 -07:00
|
|
|
inline js::Value
|
2010-04-05 18:32:16 -07:00
|
|
|
JSObject::getSlotMT(JSContext *cx, uintN slot)
|
|
|
|
{
|
2010-03-30 14:42:48 -07:00
|
|
|
#ifdef JS_THREADSAFE
|
|
|
|
/*
|
2010-08-29 11:57:08 -07:00
|
|
|
* If thread-safe, define a getSlotMT() that bypasses, for a native object,
|
|
|
|
* the lock-free "fast path" test of (obj->title.ownercx == cx), to avoid
|
|
|
|
* needlessly switching from lock-free to lock-full scope when doing GC on
|
|
|
|
* a different context from the last one to own the scope. The caller in
|
|
|
|
* this case is probably a JSClass.mark function, e.g., fun_mark, or maybe
|
|
|
|
* a finalizer.
|
2010-03-30 14:42:48 -07:00
|
|
|
*/
|
|
|
|
OBJ_CHECK_SLOT(this, slot);
|
2010-08-29 11:57:08 -07:00
|
|
|
return (title.ownercx == cx)
|
|
|
|
? this->lockedGetSlot(slot)
|
|
|
|
: js::Valueify(js_GetSlotThreadSafe(cx, this, slot));
|
2010-03-30 14:42:48 -07:00
|
|
|
#else
|
2010-04-08 11:22:04 -07:00
|
|
|
return this->lockedGetSlot(slot);
|
2010-03-30 14:42:48 -07:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
inline void
|
2010-07-14 23:19:36 -07:00
|
|
|
JSObject::setSlotMT(JSContext *cx, uintN slot, const js::Value &value)
|
2010-04-05 18:32:16 -07:00
|
|
|
{
|
2010-03-30 14:42:48 -07:00
|
|
|
#ifdef JS_THREADSAFE
|
|
|
|
/* Thread-safe way to set a slot. */
|
|
|
|
OBJ_CHECK_SLOT(this, slot);
|
2010-08-29 11:57:08 -07:00
|
|
|
if (title.ownercx == cx)
|
2010-04-08 11:22:04 -07:00
|
|
|
this->lockedSetSlot(slot, value);
|
2010-03-30 14:42:48 -07:00
|
|
|
else
|
2010-07-14 23:19:36 -07:00
|
|
|
js_SetSlotThreadSafe(cx, this, slot, js::Jsvalify(value));
|
2010-03-30 14:42:48 -07:00
|
|
|
#else
|
2010-04-08 11:22:04 -07:00
|
|
|
this->lockedSetSlot(slot, value);
|
2010-03-30 14:42:48 -07:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2010-07-14 23:19:36 -07:00
|
|
|
inline js::Value
|
2010-06-07 18:35:58 -07:00
|
|
|
JSObject::getReservedSlot(uintN index) const
|
|
|
|
{
|
|
|
|
uint32 slot = JSSLOT_START(getClass()) + index;
|
2010-07-14 23:19:36 -07:00
|
|
|
return (slot < numSlots()) ? getSlot(slot) : js::UndefinedValue();
|
2010-06-07 18:35:58 -07:00
|
|
|
}
|
|
|
|
|
2010-08-01 09:58:03 -07:00
|
|
|
inline bool
|
|
|
|
JSObject::canHaveMethodBarrier() const
|
|
|
|
{
|
|
|
|
return isObject() || isFunction() || isPrimitive() || isDate();
|
|
|
|
}
|
|
|
|
|
2010-04-14 18:57:30 -07:00
|
|
|
inline bool
|
|
|
|
JSObject::isPrimitive() const
|
|
|
|
{
|
|
|
|
return isNumber() || isString() || isBoolean();
|
|
|
|
}
|
|
|
|
|
2010-07-14 23:19:36 -07:00
|
|
|
inline const js::Value &
|
2010-04-14 18:57:30 -07:00
|
|
|
JSObject::getPrimitiveThis() const
|
|
|
|
{
|
|
|
|
JS_ASSERT(isPrimitive());
|
|
|
|
return fslots[JSSLOT_PRIMITIVE_THIS];
|
|
|
|
}
|
|
|
|
|
2010-08-29 11:57:08 -07:00
|
|
|
inline void
|
2010-07-14 23:19:36 -07:00
|
|
|
JSObject::setPrimitiveThis(const js::Value &pthis)
|
2010-04-14 18:57:30 -07:00
|
|
|
{
|
|
|
|
JS_ASSERT(isPrimitive());
|
|
|
|
fslots[JSSLOT_PRIMITIVE_THIS] = pthis;
|
|
|
|
}
|
|
|
|
|
2010-05-04 17:29:42 -07:00
|
|
|
inline void
|
|
|
|
JSObject::staticAssertArrayLengthIsInPrivateSlot()
|
2010-04-05 19:16:37 -07:00
|
|
|
{
|
|
|
|
JS_STATIC_ASSERT(JSSLOT_ARRAY_LENGTH == JSSLOT_PRIVATE);
|
|
|
|
}
|
|
|
|
|
2010-04-05 18:32:16 -07:00
|
|
|
inline uint32
|
|
|
|
JSObject::getArrayLength() const
|
|
|
|
{
|
|
|
|
JS_ASSERT(isArray());
|
2010-07-22 18:45:21 -07:00
|
|
|
return fslots[JSSLOT_ARRAY_LENGTH].toPrivateUint32();
|
2010-04-29 20:22:33 -07:00
|
|
|
}
|
|
|
|
|
2010-08-29 11:57:08 -07:00
|
|
|
inline void
|
2010-07-22 18:45:21 -07:00
|
|
|
JSObject::setArrayLength(uint32 length)
|
2010-04-29 20:22:33 -07:00
|
|
|
{
|
2010-07-22 18:45:21 -07:00
|
|
|
JS_ASSERT(isArray());
|
2010-07-14 23:19:36 -07:00
|
|
|
fslots[JSSLOT_ARRAY_LENGTH].setPrivateUint32(length);
|
2010-04-05 18:32:16 -07:00
|
|
|
}
|
|
|
|
|
2010-04-26 18:33:36 -07:00
|
|
|
inline uint32
|
|
|
|
JSObject::getDenseArrayCapacity() const
|
|
|
|
{
|
|
|
|
JS_ASSERT(isDenseArray());
|
2010-07-27 16:42:58 -07:00
|
|
|
return fslots[JSSLOT_DENSE_ARRAY_CAPACITY].toPrivateUint32();
|
2010-04-26 18:33:36 -07:00
|
|
|
}
|
|
|
|
|
2010-04-05 18:32:16 -07:00
|
|
|
inline void
|
2010-04-26 18:33:36 -07:00
|
|
|
JSObject::setDenseArrayCapacity(uint32 capacity)
|
2010-04-05 18:32:16 -07:00
|
|
|
{
|
2010-04-26 18:33:36 -07:00
|
|
|
JS_ASSERT(isDenseArray());
|
2010-07-27 16:42:58 -07:00
|
|
|
JS_ASSERT(!capacity == !dslots);
|
|
|
|
fslots[JSSLOT_DENSE_ARRAY_CAPACITY].setPrivateUint32(capacity);
|
2010-04-26 18:33:36 -07:00
|
|
|
}
|
|
|
|
|
2010-09-01 14:09:54 -07:00
|
|
|
inline size_t
|
|
|
|
JSObject::slotsAndStructSize(uint32 nslots) const
|
|
|
|
{
|
|
|
|
int ndslots;
|
|
|
|
if (isDenseArray())
|
|
|
|
ndslots = getDenseArrayCapacity() + 1;
|
|
|
|
else {
|
|
|
|
ndslots = nslots - JS_INITIAL_NSLOTS;
|
|
|
|
if (ndslots <= 0)
|
|
|
|
ndslots = 0;
|
|
|
|
else
|
|
|
|
ndslots++; /* number of total slots is stored at index -1 */
|
|
|
|
}
|
|
|
|
|
|
|
|
return sizeof(js::Value) * ndslots
|
|
|
|
+ (isFunction() && !getPrivate()) ? sizeof(JSFunction) : sizeof(JSObject);
|
|
|
|
}
|
|
|
|
|
2010-07-14 23:19:36 -07:00
|
|
|
inline const js::Value &
|
2010-04-26 18:33:36 -07:00
|
|
|
JSObject::getDenseArrayElement(uint32 i) const
|
|
|
|
{
|
|
|
|
JS_ASSERT(isDenseArray());
|
|
|
|
JS_ASSERT(i < getDenseArrayCapacity());
|
|
|
|
return dslots[i];
|
|
|
|
}
|
|
|
|
|
2010-07-14 23:19:36 -07:00
|
|
|
inline js::Value *
|
2010-05-04 20:28:38 -07:00
|
|
|
JSObject::addressOfDenseArrayElement(uint32 i)
|
|
|
|
{
|
|
|
|
JS_ASSERT(isDenseArray());
|
|
|
|
JS_ASSERT(i < getDenseArrayCapacity());
|
|
|
|
return &dslots[i];
|
|
|
|
}
|
|
|
|
|
2010-04-26 18:33:36 -07:00
|
|
|
inline void
|
2010-07-14 23:19:36 -07:00
|
|
|
JSObject::setDenseArrayElement(uint32 i, const js::Value &v)
|
2010-04-26 18:33:36 -07:00
|
|
|
{
|
|
|
|
JS_ASSERT(isDenseArray());
|
|
|
|
JS_ASSERT(i < getDenseArrayCapacity());
|
|
|
|
dslots[i] = v;
|
|
|
|
}
|
|
|
|
|
2010-07-14 23:19:36 -07:00
|
|
|
inline js::Value *
|
2010-04-26 18:33:36 -07:00
|
|
|
JSObject::getDenseArrayElements() const
|
|
|
|
{
|
|
|
|
JS_ASSERT(isDenseArray());
|
|
|
|
return dslots;
|
|
|
|
}
|
|
|
|
|
|
|
|
inline void
|
|
|
|
JSObject::freeDenseArrayElements(JSContext *cx)
|
|
|
|
{
|
2010-04-29 20:22:33 -07:00
|
|
|
JS_ASSERT(isDenseArray());
|
2010-04-26 18:33:36 -07:00
|
|
|
if (dslots) {
|
|
|
|
cx->free(dslots - 1);
|
|
|
|
dslots = NULL;
|
|
|
|
}
|
2010-04-29 20:22:33 -07:00
|
|
|
}
|
|
|
|
|
2010-08-29 11:57:08 -07:00
|
|
|
inline void
|
2010-04-29 20:22:33 -07:00
|
|
|
JSObject::voidDenseOnlyArraySlots()
|
|
|
|
{
|
|
|
|
JS_ASSERT(isDenseArray());
|
2010-07-27 16:42:58 -07:00
|
|
|
fslots[JSSLOT_DENSE_ARRAY_CAPACITY].setUndefined();
|
2010-04-05 18:32:16 -07:00
|
|
|
}
|
|
|
|
|
2010-04-11 16:45:20 -07:00
|
|
|
inline void
|
|
|
|
JSObject::setArgsLength(uint32 argc)
|
|
|
|
{
|
|
|
|
JS_ASSERT(isArguments());
|
|
|
|
JS_ASSERT(argc <= JS_ARGS_LENGTH_MAX);
|
2010-08-04 14:39:45 -07:00
|
|
|
JS_ASSERT(UINT32_MAX > (uint64(argc) << ARGS_PACKED_BITS_COUNT));
|
|
|
|
fslots[JSSLOT_ARGS_LENGTH].setInt32(argc << ARGS_PACKED_BITS_COUNT);
|
2010-04-11 16:45:20 -07:00
|
|
|
JS_ASSERT(!isArgsLengthOverridden());
|
|
|
|
}
|
|
|
|
|
|
|
|
inline uint32
|
2010-08-04 13:50:01 -07:00
|
|
|
JSObject::getArgsInitialLength() const
|
2010-04-11 16:45:20 -07:00
|
|
|
{
|
|
|
|
JS_ASSERT(isArguments());
|
2010-08-04 14:39:45 -07:00
|
|
|
uint32 argc = uint32(fslots[JSSLOT_ARGS_LENGTH].toInt32()) >> ARGS_PACKED_BITS_COUNT;
|
2010-04-11 16:45:20 -07:00
|
|
|
JS_ASSERT(argc <= JS_ARGS_LENGTH_MAX);
|
|
|
|
return argc;
|
|
|
|
}
|
|
|
|
|
|
|
|
inline void
|
|
|
|
JSObject::setArgsLengthOverridden()
|
|
|
|
{
|
|
|
|
JS_ASSERT(isArguments());
|
2010-08-04 14:39:45 -07:00
|
|
|
fslots[JSSLOT_ARGS_LENGTH].getInt32Ref() |= ARGS_LENGTH_OVERRIDDEN_BIT;
|
2010-04-11 16:45:20 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
inline bool
|
2010-05-02 21:42:09 -07:00
|
|
|
JSObject::isArgsLengthOverridden() const
|
2010-04-11 16:45:20 -07:00
|
|
|
{
|
|
|
|
JS_ASSERT(isArguments());
|
2010-07-14 23:19:36 -07:00
|
|
|
const js::Value &v = fslots[JSSLOT_ARGS_LENGTH];
|
2010-08-04 14:39:45 -07:00
|
|
|
return v.toInt32() & ARGS_LENGTH_OVERRIDDEN_BIT;
|
2010-04-11 16:45:20 -07:00
|
|
|
}
|
|
|
|
|
2010-08-29 11:57:08 -07:00
|
|
|
inline js::ArgumentsData *
|
|
|
|
JSObject::getArgsData() const
|
2010-04-11 16:45:20 -07:00
|
|
|
{
|
|
|
|
JS_ASSERT(isArguments());
|
2010-08-29 11:57:08 -07:00
|
|
|
return (js::ArgumentsData *) fslots[JSSLOT_ARGS_DATA].toPrivate();
|
2010-04-11 16:45:20 -07:00
|
|
|
}
|
|
|
|
|
2010-08-29 11:57:08 -07:00
|
|
|
inline void
|
|
|
|
JSObject::setArgsData(js::ArgumentsData *data)
|
2010-04-11 16:45:20 -07:00
|
|
|
{
|
|
|
|
JS_ASSERT(isArguments());
|
2010-08-29 11:57:08 -07:00
|
|
|
fslots[JSSLOT_ARGS_DATA].setPrivate(data);
|
|
|
|
}
|
|
|
|
|
|
|
|
inline const js::Value &
|
|
|
|
JSObject::getArgsCallee() const
|
|
|
|
{
|
|
|
|
return getArgsData()->callee;
|
|
|
|
}
|
|
|
|
|
|
|
|
inline void
|
|
|
|
JSObject::setArgsCallee(const js::Value &callee)
|
|
|
|
{
|
|
|
|
getArgsData()->callee = callee;
|
2010-04-11 16:45:20 -07:00
|
|
|
}
|
|
|
|
|
2010-07-14 23:19:36 -07:00
|
|
|
inline const js::Value &
|
2010-05-02 21:42:09 -07:00
|
|
|
JSObject::getArgsElement(uint32 i) const
|
|
|
|
{
|
|
|
|
JS_ASSERT(isArguments());
|
2010-08-29 11:57:08 -07:00
|
|
|
JS_ASSERT(i < getArgsInitialLength());
|
|
|
|
return getArgsData()->slots[i];
|
2010-05-02 21:42:09 -07:00
|
|
|
}
|
|
|
|
|
2010-07-14 23:19:36 -07:00
|
|
|
inline js::Value *
|
|
|
|
JSObject::addressOfArgsElement(uint32 i) const
|
|
|
|
{
|
|
|
|
JS_ASSERT(isArguments());
|
2010-08-29 11:57:08 -07:00
|
|
|
JS_ASSERT(i < getArgsInitialLength());
|
|
|
|
return &getArgsData()->slots[i];
|
2010-07-14 23:19:36 -07:00
|
|
|
}
|
|
|
|
|
2010-05-02 21:42:09 -07:00
|
|
|
inline void
|
2010-07-14 23:19:36 -07:00
|
|
|
JSObject::setArgsElement(uint32 i, const js::Value &v)
|
2010-05-02 21:42:09 -07:00
|
|
|
{
|
|
|
|
JS_ASSERT(isArguments());
|
2010-08-29 11:57:08 -07:00
|
|
|
JS_ASSERT(i < getArgsInitialLength());
|
|
|
|
getArgsData()->slots[i] = v;
|
2010-05-02 21:42:09 -07:00
|
|
|
}
|
|
|
|
|
2010-07-14 23:19:36 -07:00
|
|
|
inline const js::Value &
|
2010-04-14 18:57:30 -07:00
|
|
|
JSObject::getDateUTCTime() const
|
|
|
|
{
|
|
|
|
JS_ASSERT(isDate());
|
|
|
|
return fslots[JSSLOT_DATE_UTC_TIME];
|
|
|
|
}
|
|
|
|
|
|
|
|
inline void
|
2010-07-14 23:19:36 -07:00
|
|
|
JSObject::setDateUTCTime(const js::Value &time)
|
2010-04-14 18:57:30 -07:00
|
|
|
{
|
|
|
|
JS_ASSERT(isDate());
|
|
|
|
fslots[JSSLOT_DATE_UTC_TIME] = time;
|
|
|
|
}
|
|
|
|
|
2010-08-29 11:57:08 -07:00
|
|
|
inline js::Value *
|
|
|
|
JSObject::getFlatClosureUpvars() const
|
|
|
|
{
|
|
|
|
JS_ASSERT(isFunction());
|
|
|
|
JS_ASSERT(FUN_FLAT_CLOSURE(getFunctionPrivate()));
|
|
|
|
return (js::Value *) fslots[JSSLOT_FLAT_CLOSURE_UPVARS].toPrivate();
|
|
|
|
}
|
|
|
|
|
|
|
|
inline js::Value
|
|
|
|
JSObject::getFlatClosureUpvar(uint32 i) const
|
|
|
|
{
|
|
|
|
return getFlatClosureUpvars()[i];
|
|
|
|
}
|
|
|
|
|
|
|
|
inline void
|
|
|
|
JSObject::setFlatClosureUpvars(js::Value *upvars)
|
|
|
|
{
|
|
|
|
JS_ASSERT(isFunction());
|
|
|
|
JS_ASSERT(FUN_FLAT_CLOSURE(getFunctionPrivate()));
|
|
|
|
fslots[JSSLOT_FLAT_CLOSURE_UPVARS].setPrivate(upvars);
|
|
|
|
}
|
|
|
|
|
2010-08-01 09:58:03 -07:00
|
|
|
inline bool
|
|
|
|
JSObject::hasMethodObj(const JSObject& obj) const
|
|
|
|
{
|
|
|
|
return fslots[JSSLOT_FUN_METHOD_OBJ].isObject() &&
|
|
|
|
&fslots[JSSLOT_FUN_METHOD_OBJ].toObject() == &obj;
|
|
|
|
}
|
|
|
|
|
|
|
|
inline void
|
|
|
|
JSObject::setMethodObj(JSObject& obj)
|
|
|
|
{
|
|
|
|
fslots[JSSLOT_FUN_METHOD_OBJ].setObject(obj);
|
|
|
|
}
|
|
|
|
|
2010-05-07 17:52:52 -07:00
|
|
|
inline NativeIterator *
|
|
|
|
JSObject::getNativeIterator() const
|
|
|
|
{
|
|
|
|
return (NativeIterator *) getPrivate();
|
|
|
|
}
|
|
|
|
|
|
|
|
inline void
|
|
|
|
JSObject::setNativeIterator(NativeIterator *ni)
|
|
|
|
{
|
|
|
|
setPrivate(ni);
|
|
|
|
}
|
|
|
|
|
2010-05-12 18:57:36 -07:00
|
|
|
inline jsval
|
|
|
|
JSObject::getNamePrefix() const
|
|
|
|
{
|
|
|
|
JS_ASSERT(isNamespace() || isQName());
|
2010-07-14 23:19:36 -07:00
|
|
|
return js::Jsvalify(fslots[JSSLOT_NAME_PREFIX]);
|
2010-05-12 18:57:36 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
inline void
|
|
|
|
JSObject::setNamePrefix(jsval prefix)
|
|
|
|
{
|
|
|
|
JS_ASSERT(isNamespace() || isQName());
|
2010-07-14 23:19:36 -07:00
|
|
|
fslots[JSSLOT_NAME_PREFIX] = js::Valueify(prefix);
|
2010-05-12 18:57:36 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
inline jsval
|
|
|
|
JSObject::getNameURI() const
|
|
|
|
{
|
|
|
|
JS_ASSERT(isNamespace() || isQName());
|
2010-07-14 23:19:36 -07:00
|
|
|
return js::Jsvalify(fslots[JSSLOT_NAME_URI]);
|
2010-05-12 18:57:36 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
inline void
|
|
|
|
JSObject::setNameURI(jsval uri)
|
|
|
|
{
|
|
|
|
JS_ASSERT(isNamespace() || isQName());
|
2010-07-14 23:19:36 -07:00
|
|
|
fslots[JSSLOT_NAME_URI] = js::Valueify(uri);
|
2010-05-12 18:57:36 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
inline jsval
|
|
|
|
JSObject::getNamespaceDeclared() const
|
|
|
|
{
|
|
|
|
JS_ASSERT(isNamespace());
|
2010-07-14 23:19:36 -07:00
|
|
|
return js::Jsvalify(fslots[JSSLOT_NAMESPACE_DECLARED]);
|
2010-05-12 18:57:36 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
inline void
|
|
|
|
JSObject::setNamespaceDeclared(jsval decl)
|
|
|
|
{
|
|
|
|
JS_ASSERT(isNamespace());
|
2010-07-14 23:19:36 -07:00
|
|
|
fslots[JSSLOT_NAMESPACE_DECLARED] = js::Valueify(decl);
|
2010-05-12 18:57:36 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
inline jsval
|
|
|
|
JSObject::getQNameLocalName() const
|
|
|
|
{
|
|
|
|
JS_ASSERT(isQName());
|
2010-07-14 23:19:36 -07:00
|
|
|
return js::Jsvalify(fslots[JSSLOT_QNAME_LOCAL_NAME]);
|
2010-05-12 18:57:36 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
inline void
|
|
|
|
JSObject::setQNameLocalName(jsval name)
|
|
|
|
{
|
|
|
|
JS_ASSERT(isQName());
|
2010-07-14 23:19:36 -07:00
|
|
|
fslots[JSSLOT_QNAME_LOCAL_NAME] = js::Valueify(name);
|
2010-05-12 18:57:36 -07:00
|
|
|
}
|
|
|
|
|
2010-06-08 14:09:40 -07:00
|
|
|
inline JSObject *
|
|
|
|
JSObject::getWithThis() const
|
|
|
|
{
|
2010-07-14 23:19:36 -07:00
|
|
|
return &fslots[JSSLOT_WITH_THIS].toObject();
|
2010-06-08 14:09:40 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
inline void
|
|
|
|
JSObject::setWithThis(JSObject *thisp)
|
|
|
|
{
|
2010-07-14 23:19:36 -07:00
|
|
|
fslots[JSSLOT_WITH_THIS].setObject(*thisp);
|
2010-06-08 14:09:40 -07:00
|
|
|
}
|
|
|
|
|
2009-11-18 12:29:58 -08:00
|
|
|
inline void
|
2010-08-29 11:57:08 -07:00
|
|
|
JSObject::init(js::Class *aclasp, JSObject *proto, JSObject *parent,
|
|
|
|
const js::Value &privateSlotValue, JSContext *cx)
|
2009-11-18 12:29:58 -08:00
|
|
|
{
|
2010-08-29 11:57:08 -07:00
|
|
|
JS_STATIC_ASSERT(JSSLOT_PRIVATE + 3 == JS_INITIAL_NSLOTS);
|
|
|
|
|
|
|
|
clasp = aclasp;
|
|
|
|
flags = 0;
|
|
|
|
freeslot = JSSLOT_START(aclasp);
|
2009-11-18 12:29:58 -08:00
|
|
|
|
2010-08-29 11:57:08 -07:00
|
|
|
#ifdef DEBUG
|
|
|
|
/*
|
|
|
|
* NB: objShape must not be set here; rather, the caller must call setMap
|
|
|
|
* or setSharedNonNativeMap after calling init. To defend this requirement
|
|
|
|
* we set map to null in DEBUG builds, and set objShape to a value we then
|
|
|
|
* assert obj->shape() never returns.
|
|
|
|
*/
|
|
|
|
map = NULL;
|
|
|
|
objShape = JSObjectMap::INVALID_SHAPE;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
setProto(proto);
|
|
|
|
setParent(parent);
|
|
|
|
fslots[JSSLOT_PRIVATE] = privateSlotValue;
|
|
|
|
fslots[JSSLOT_PRIVATE + 1].setUndefined();
|
|
|
|
fslots[JSSLOT_PRIVATE + 2].setUndefined();
|
|
|
|
|
|
|
|
dslots = NULL;
|
|
|
|
|
|
|
|
#ifdef JS_THREADSAFE
|
|
|
|
js_InitTitle(cx, &title);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
emptyShape = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
inline void
|
|
|
|
JSObject::finish(JSContext *cx)
|
2009-11-18 12:29:58 -08:00
|
|
|
{
|
2010-08-29 11:57:08 -07:00
|
|
|
#ifdef DEBUG
|
|
|
|
if (isNative())
|
|
|
|
JS_LOCK_RUNTIME_VOID(cx->runtime, cx->runtime->liveObjectProps -= propertyCount());
|
|
|
|
#endif
|
|
|
|
if (hasSlotsArray())
|
|
|
|
freeSlotsArray(cx);
|
|
|
|
#ifdef JS_THREADSAFE
|
|
|
|
js_FinishTitle(cx, &title);
|
|
|
|
#endif
|
|
|
|
}
|
2009-11-18 12:29:58 -08:00
|
|
|
|
2010-08-29 11:57:08 -07:00
|
|
|
inline void
|
|
|
|
JSObject::initSharingEmptyShape(js::Class *aclasp,
|
|
|
|
JSObject *proto,
|
|
|
|
JSObject *parent,
|
|
|
|
const js::Value &privateSlotValue,
|
|
|
|
JSContext *cx)
|
|
|
|
{
|
|
|
|
init(aclasp, proto, parent, privateSlotValue, cx);
|
|
|
|
|
|
|
|
js::EmptyShape *empty = proto->emptyShape;
|
|
|
|
JS_ASSERT(empty->getClass() == aclasp);
|
|
|
|
setMap(empty);
|
2009-11-18 12:29:58 -08:00
|
|
|
}
|
|
|
|
|
2009-12-30 03:06:26 -08:00
|
|
|
inline void
|
|
|
|
JSObject::freeSlotsArray(JSContext *cx)
|
|
|
|
{
|
|
|
|
JS_ASSERT(hasSlotsArray());
|
2010-07-14 23:19:36 -07:00
|
|
|
JS_ASSERT(dslots[-1].toPrivateUint32() > JS_INITIAL_NSLOTS);
|
2009-12-30 03:06:26 -08:00
|
|
|
cx->free(dslots - 1);
|
|
|
|
}
|
|
|
|
|
2010-01-14 09:33:14 -08:00
|
|
|
inline bool
|
2010-08-29 11:57:08 -07:00
|
|
|
JSObject::hasProperty(JSContext *cx, jsid id, bool *foundp, uintN flags)
|
|
|
|
{
|
|
|
|
JSObject *pobj;
|
|
|
|
JSProperty *prop;
|
|
|
|
JSAutoResolveFlags rf(cx, flags);
|
|
|
|
if (!lookupProperty(cx, id, &pobj, &prop))
|
|
|
|
return false;
|
|
|
|
*foundp = !!prop;
|
|
|
|
if (prop)
|
|
|
|
pobj->dropProperty(cx, prop);
|
2010-01-14 09:33:14 -08:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2010-08-29 11:57:08 -07:00
|
|
|
inline bool
|
|
|
|
JSObject::isCallable()
|
|
|
|
{
|
|
|
|
return isFunction() || getClass()->call;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline bool
|
|
|
|
js_IsCallable(const js::Value &v)
|
2010-01-14 09:33:14 -08:00
|
|
|
{
|
2010-08-29 11:57:08 -07:00
|
|
|
return v.isObject() && v.toObject().isCallable();
|
|
|
|
}
|
|
|
|
|
2010-09-01 20:19:03 -07:00
|
|
|
inline size_t
|
|
|
|
JSObject::flagsOffset()
|
|
|
|
{
|
|
|
|
static size_t offset = 0;
|
|
|
|
if (offset)
|
|
|
|
return offset;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We can't address a bitfield, so instead we create a struct, set only
|
|
|
|
* the field we care about, then search for it.
|
|
|
|
*/
|
|
|
|
JSObject fakeObj;
|
|
|
|
memset(&fakeObj, 0, sizeof(fakeObj));
|
|
|
|
fakeObj.flags = 1;
|
|
|
|
for (unsigned testOffset = 0; testOffset < sizeof(fakeObj); testOffset += sizeof(uint32)) {
|
|
|
|
uint32 *ptr = reinterpret_cast<uint32 *>(reinterpret_cast<char *>(&fakeObj) + testOffset);
|
|
|
|
if (*ptr) {
|
|
|
|
JS_ASSERT(*ptr == 1);
|
|
|
|
offset = testOffset;
|
|
|
|
return offset;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
JS_NOT_REACHED("memory weirdness");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-03-28 20:32:20 -07:00
|
|
|
namespace js {
|
|
|
|
|
2010-07-14 23:19:36 -07:00
|
|
|
class AutoPropDescArrayRooter : private AutoGCRooter
|
2010-03-28 20:32:20 -07:00
|
|
|
{
|
|
|
|
public:
|
2010-07-14 23:19:36 -07:00
|
|
|
AutoPropDescArrayRooter(JSContext *cx)
|
2010-03-28 20:32:20 -07:00
|
|
|
: AutoGCRooter(cx, DESCRIPTORS), descriptors(cx)
|
|
|
|
{ }
|
|
|
|
|
2010-07-14 23:19:36 -07:00
|
|
|
PropDesc *append() {
|
|
|
|
if (!descriptors.append(PropDesc()))
|
2010-03-28 20:32:20 -07:00
|
|
|
return NULL;
|
|
|
|
return &descriptors.back();
|
|
|
|
}
|
|
|
|
|
2010-07-14 23:19:36 -07:00
|
|
|
PropDesc& operator[](size_t i) {
|
2010-03-28 20:32:20 -07:00
|
|
|
JS_ASSERT(i < descriptors.length());
|
|
|
|
return descriptors[i];
|
|
|
|
}
|
|
|
|
|
|
|
|
friend void AutoGCRooter::trace(JSTracer *trc);
|
|
|
|
|
|
|
|
private:
|
2010-07-14 23:19:36 -07:00
|
|
|
PropDescArray descriptors;
|
2010-03-28 20:32:20 -07:00
|
|
|
};
|
|
|
|
|
2010-07-14 23:19:36 -07:00
|
|
|
class AutoPropertyDescriptorRooter : private AutoGCRooter, public PropertyDescriptor
|
2010-05-18 19:21:43 -07:00
|
|
|
{
|
|
|
|
public:
|
2010-07-14 23:19:36 -07:00
|
|
|
AutoPropertyDescriptorRooter(JSContext *cx) : AutoGCRooter(cx, DESCRIPTOR) {
|
2010-05-18 19:21:43 -07:00
|
|
|
obj = NULL;
|
|
|
|
attrs = 0;
|
2010-07-14 23:19:36 -07:00
|
|
|
getter = setter = (PropertyOp) NULL;
|
|
|
|
value.setUndefined();
|
2010-05-18 19:21:43 -07:00
|
|
|
}
|
|
|
|
|
2010-08-29 11:57:08 -07:00
|
|
|
AutoPropertyDescriptorRooter(JSContext *cx, PropertyDescriptor *desc)
|
|
|
|
: AutoGCRooter(cx, DESCRIPTOR)
|
|
|
|
{
|
2010-06-23 14:35:10 -07:00
|
|
|
obj = desc->obj;
|
|
|
|
attrs = desc->attrs;
|
|
|
|
getter = desc->getter;
|
|
|
|
setter = desc->setter;
|
|
|
|
value = desc->value;
|
|
|
|
}
|
|
|
|
|
2010-05-18 19:21:43 -07:00
|
|
|
friend void AutoGCRooter::trace(JSTracer *trc);
|
|
|
|
};
|
|
|
|
|
2010-04-10 16:16:35 -07:00
|
|
|
static inline bool
|
2010-06-12 09:29:04 -07:00
|
|
|
InitScopeForObject(JSContext* cx, JSObject* obj, js::Class *clasp, JSObject* proto)
|
2010-04-10 16:16:35 -07:00
|
|
|
{
|
2010-06-12 09:29:04 -07:00
|
|
|
JS_ASSERT(clasp->isNative());
|
2010-04-10 16:16:35 -07:00
|
|
|
JS_ASSERT(proto == obj->getProto());
|
|
|
|
|
2010-08-29 11:57:08 -07:00
|
|
|
/* Share proto's emptyShape only if obj is similar to proto. */
|
|
|
|
js::EmptyShape *empty = NULL;
|
2010-04-10 16:16:35 -07:00
|
|
|
|
2010-08-29 11:57:08 -07:00
|
|
|
if (proto) {
|
2010-04-10 16:16:35 -07:00
|
|
|
JS_LOCK_OBJ(cx, proto);
|
2010-08-29 11:57:08 -07:00
|
|
|
if (proto->canProvideEmptyShape(clasp)) {
|
|
|
|
empty = proto->getEmptyShape(cx, clasp);
|
|
|
|
JS_UNLOCK_OBJ(cx, proto);
|
|
|
|
if (!empty)
|
2010-04-10 16:16:35 -07:00
|
|
|
goto bad;
|
|
|
|
} else {
|
2010-08-29 11:57:08 -07:00
|
|
|
JS_UNLOCK_OBJ(cx, proto);
|
2010-04-10 16:16:35 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-08-29 11:57:08 -07:00
|
|
|
if (!empty) {
|
2010-06-18 17:43:02 -07:00
|
|
|
uint32 freeslot = JSSLOT_FREE(clasp);
|
2010-08-29 11:57:08 -07:00
|
|
|
JS_ASSERT(freeslot >= JSSLOT_PRIVATE);
|
|
|
|
|
|
|
|
empty = js::EmptyShape::create(cx, clasp);
|
|
|
|
if (!empty)
|
|
|
|
goto bad;
|
2010-06-18 17:43:02 -07:00
|
|
|
if (freeslot > JS_INITIAL_NSLOTS && !obj->allocSlots(cx, freeslot))
|
2010-04-10 16:16:35 -07:00
|
|
|
goto bad;
|
2010-08-29 11:57:08 -07:00
|
|
|
obj->freeslot = freeslot;
|
2010-04-10 16:16:35 -07:00
|
|
|
}
|
|
|
|
|
2010-08-29 11:57:08 -07:00
|
|
|
obj->setMap(empty);
|
2010-04-10 16:16:35 -07:00
|
|
|
return true;
|
|
|
|
|
|
|
|
bad:
|
|
|
|
/* The GC nulls map initially. It should still be null on error. */
|
|
|
|
JS_ASSERT(!obj->map);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2010-06-18 17:43:02 -07:00
|
|
|
/*
|
|
|
|
* Helper optimized for creating a native instance of the given class (not the
|
2010-08-09 09:11:22 -07:00
|
|
|
* class's prototype object). Use this in preference to NewObject, but use
|
|
|
|
* NewBuiltinClassInstance if you need the default class prototype as proto,
|
|
|
|
* and its parent global as parent.
|
2010-06-18 17:43:02 -07:00
|
|
|
*/
|
2010-04-10 16:16:35 -07:00
|
|
|
static inline JSObject *
|
2010-07-14 23:19:36 -07:00
|
|
|
NewNativeClassInstance(JSContext *cx, Class *clasp, JSObject *proto, JSObject *parent)
|
2010-06-18 17:43:02 -07:00
|
|
|
{
|
|
|
|
JS_ASSERT(proto);
|
|
|
|
JS_ASSERT(proto->isNative());
|
|
|
|
JS_ASSERT(parent);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Allocate an object from the GC heap and initialize all its fields before
|
2010-08-09 09:11:22 -07:00
|
|
|
* doing any operation that can potentially trigger GC.
|
2010-06-18 17:43:02 -07:00
|
|
|
*/
|
|
|
|
JSObject* obj = js_NewGCObject(cx);
|
2010-08-09 09:11:22 -07:00
|
|
|
|
2010-06-18 17:43:02 -07:00
|
|
|
if (obj) {
|
|
|
|
/*
|
|
|
|
* Default parent to the parent of the prototype, which was set from
|
|
|
|
* the parent of the prototype's constructor.
|
|
|
|
*/
|
2010-08-29 11:57:08 -07:00
|
|
|
obj->init(clasp, proto, parent, JSObject::defaultPrivate(clasp), cx);
|
2010-06-18 17:43:02 -07:00
|
|
|
|
|
|
|
JS_LOCK_OBJ(cx, proto);
|
2010-08-29 11:57:08 -07:00
|
|
|
JS_ASSERT(proto->canProvideEmptyShape(clasp));
|
|
|
|
js::EmptyShape *empty = proto->getEmptyShape(cx, clasp);
|
2010-06-18 17:43:02 -07:00
|
|
|
JS_UNLOCK_OBJ(cx, proto);
|
|
|
|
|
2010-08-29 11:57:08 -07:00
|
|
|
if (empty)
|
|
|
|
obj->setMap(empty);
|
|
|
|
else
|
2010-06-18 17:43:02 -07:00
|
|
|
obj = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return obj;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
FindClassPrototype(JSContext *cx, JSObject *scope, JSProtoKey protoKey, JSObject **protop,
|
2010-07-14 23:19:36 -07:00
|
|
|
Class *clasp);
|
2010-06-18 17:43:02 -07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Helper used to create Boolean, Date, RegExp, etc. instances of built-in
|
2010-07-14 23:19:36 -07:00
|
|
|
* classes with class prototypes of the same Class. See, e.g., jsdate.cpp,
|
2010-06-18 17:43:02 -07:00
|
|
|
* jsregexp.cpp, and js_PrimitiveToObject in jsobj.cpp. Use this to get the
|
|
|
|
* right default proto and parent for clasp in cx.
|
|
|
|
*/
|
|
|
|
static inline JSObject *
|
2010-07-14 23:19:36 -07:00
|
|
|
NewBuiltinClassInstance(JSContext *cx, Class *clasp)
|
2010-06-18 17:43:02 -07:00
|
|
|
{
|
|
|
|
VOUCH_DOES_NOT_REQUIRE_STACK();
|
|
|
|
|
|
|
|
JSProtoKey protoKey = JSCLASS_CACHED_PROTO_KEY(clasp);
|
|
|
|
JS_ASSERT(protoKey != JSProto_Null);
|
|
|
|
|
|
|
|
/* NB: inline-expanded and specialized version of js_GetClassPrototype. */
|
2010-06-28 16:38:54 -07:00
|
|
|
JSObject *global;
|
2010-08-22 16:00:20 -07:00
|
|
|
if (!cx->hasfp()) {
|
2010-06-28 16:38:54 -07:00
|
|
|
global = cx->globalObject;
|
|
|
|
OBJ_TO_INNER_OBJECT(cx, global);
|
|
|
|
if (!global)
|
|
|
|
return NULL;
|
|
|
|
} else {
|
2010-08-22 16:00:20 -07:00
|
|
|
global = cx->fp()->getScopeChain()->getGlobal();
|
2010-06-28 16:38:54 -07:00
|
|
|
}
|
2010-06-18 17:43:02 -07:00
|
|
|
JS_ASSERT(global->getClass()->flags & JSCLASS_IS_GLOBAL);
|
|
|
|
|
2010-07-14 23:19:36 -07:00
|
|
|
const Value &v = global->getReservedSlot(JSProto_LIMIT + protoKey);
|
2010-06-18 17:43:02 -07:00
|
|
|
JSObject *proto;
|
2010-07-14 23:19:36 -07:00
|
|
|
if (v.isObject()) {
|
|
|
|
proto = &v.toObject();
|
2010-06-18 17:43:02 -07:00
|
|
|
JS_ASSERT(proto->getParent() == global);
|
|
|
|
} else {
|
|
|
|
if (!FindClassPrototype(cx, global, protoKey, &proto, clasp))
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NewNativeClassInstance(cx, clasp, proto, global);
|
|
|
|
}
|
|
|
|
|
2010-08-09 09:11:22 -07:00
|
|
|
static inline JSProtoKey
|
|
|
|
GetClassProtoKey(js::Class *clasp)
|
|
|
|
{
|
|
|
|
JSProtoKey key = JSCLASS_CACHED_PROTO_KEY(clasp);
|
|
|
|
if (key != JSProto_Null)
|
|
|
|
return key;
|
|
|
|
if (clasp->flags & JSCLASS_IS_ANONYMOUS)
|
|
|
|
return JSProto_Object;
|
|
|
|
return JSProto_Null;
|
|
|
|
}
|
|
|
|
|
|
|
|
namespace WithProto {
|
|
|
|
enum e {
|
|
|
|
Class = 0,
|
|
|
|
Given = 1
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2010-06-18 17:43:02 -07:00
|
|
|
/*
|
2010-08-09 09:11:22 -07:00
|
|
|
* Create an instance of any class, native or not, JSFunction-sized or not.
|
|
|
|
*
|
|
|
|
* If withProto is 'Class':
|
|
|
|
* If proto is null:
|
|
|
|
* for a built-in class:
|
|
|
|
* use the memoized original value of the class constructor .prototype
|
|
|
|
* property object
|
|
|
|
* else if available
|
|
|
|
* the current value of .prototype
|
|
|
|
* else
|
|
|
|
* Object.prototype.
|
|
|
|
*
|
|
|
|
* If parent is null, default it to proto->getParent() if proto is non
|
|
|
|
* null, else to null.
|
|
|
|
*
|
|
|
|
* If withProto is 'Given':
|
|
|
|
* We allocate an object with exactly the given proto. A null parent
|
|
|
|
* defaults to proto->getParent() if proto is non-null (else to null).
|
|
|
|
*
|
|
|
|
* If isFunction is true, return a JSFunction-sized object. If isFunction is
|
|
|
|
* false, return a normal object.
|
|
|
|
*
|
|
|
|
* Note that as a template, there will be lots of instantiations, which means
|
|
|
|
* the internals will be specialized based on the template parameters.
|
2010-06-18 17:43:02 -07:00
|
|
|
*/
|
2010-08-09 09:11:22 -07:00
|
|
|
namespace detail
|
|
|
|
{
|
|
|
|
template <bool withProto, bool isFunction>
|
|
|
|
static JS_ALWAYS_INLINE JSObject *
|
|
|
|
NewObject(JSContext *cx, js::Class *clasp, JSObject *proto, JSObject *parent)
|
2010-04-10 16:16:35 -07:00
|
|
|
{
|
2010-08-09 09:11:22 -07:00
|
|
|
/* Bootstrap the ur-object, and make it the default prototype object. */
|
|
|
|
if (withProto == WithProto::Class && !proto) {
|
|
|
|
JSProtoKey protoKey = GetClassProtoKey(clasp);
|
|
|
|
if (!js_GetClassPrototype(cx, parent, protoKey, &proto, clasp))
|
|
|
|
return NULL;
|
|
|
|
if (!proto && !js_GetClassPrototype(cx, parent, JSProto_Object, &proto))
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-04-10 16:16:35 -07:00
|
|
|
/*
|
|
|
|
* Allocate an object from the GC heap and initialize all its fields before
|
|
|
|
* doing any operation that can potentially trigger GC. Functions have a
|
|
|
|
* larger non-standard allocation size.
|
2010-08-09 09:11:22 -07:00
|
|
|
*
|
|
|
|
* The should be specialized by the template.
|
2010-04-10 16:16:35 -07:00
|
|
|
*/
|
2010-08-29 11:57:08 -07:00
|
|
|
JSObject* obj = isFunction ? js_NewGCFunction(cx) : js_NewGCObject(cx);
|
2010-04-10 16:16:35 -07:00
|
|
|
if (!obj)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Default parent to the parent of the prototype, which was set from
|
|
|
|
* the parent of the prototype's constructor.
|
|
|
|
*/
|
2010-08-29 11:57:08 -07:00
|
|
|
obj->init(clasp, proto,
|
2010-04-10 16:16:35 -07:00
|
|
|
(!parent && proto) ? proto->getParent() : parent,
|
2010-08-29 11:57:08 -07:00
|
|
|
JSObject::defaultPrivate(clasp),
|
|
|
|
cx);
|
2010-04-10 16:16:35 -07:00
|
|
|
|
2010-06-12 09:29:04 -07:00
|
|
|
if (clasp->isNative()) {
|
|
|
|
if (!InitScopeForObject(cx, obj, clasp, proto)) {
|
2010-04-10 16:16:35 -07:00
|
|
|
obj = NULL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
} else {
|
2010-08-29 11:57:08 -07:00
|
|
|
obj->setSharedNonNativeMap();
|
2010-04-10 16:16:35 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
out:
|
2010-09-01 14:09:54 -07:00
|
|
|
Probes::createObject(cx, obj);
|
2010-04-10 16:16:35 -07:00
|
|
|
return obj;
|
|
|
|
}
|
2010-08-09 09:11:22 -07:00
|
|
|
}
|
2010-04-10 16:16:35 -07:00
|
|
|
|
2010-08-09 09:11:22 -07:00
|
|
|
static JS_ALWAYS_INLINE JSObject *
|
2010-08-12 05:07:20 -07:00
|
|
|
NewFunction(JSContext *cx, JSObject *parent)
|
2010-04-10 16:16:35 -07:00
|
|
|
{
|
2010-08-12 05:07:20 -07:00
|
|
|
return detail::NewObject<WithProto::Class, true>(cx, &js_FunctionClass, NULL, parent);
|
2010-04-10 16:16:35 -07:00
|
|
|
}
|
|
|
|
|
2010-08-09 09:11:22 -07:00
|
|
|
template <WithProto::e withProto>
|
|
|
|
static JS_ALWAYS_INLINE JSObject *
|
|
|
|
NewNonFunction(JSContext *cx, js::Class *clasp, JSObject *proto, JSObject *parent)
|
|
|
|
{
|
|
|
|
return detail::NewObject<withProto, false>(cx, clasp, proto, parent);
|
|
|
|
}
|
|
|
|
|
|
|
|
template <WithProto::e withProto>
|
|
|
|
static JS_ALWAYS_INLINE JSObject *
|
2010-07-14 23:19:36 -07:00
|
|
|
NewObject(JSContext *cx, js::Class *clasp, JSObject *proto, JSObject *parent)
|
2010-04-10 16:16:35 -07:00
|
|
|
{
|
2010-08-12 05:07:20 -07:00
|
|
|
return (clasp == &js_FunctionClass)
|
|
|
|
? detail::NewObject<withProto, true>(cx, clasp, proto, parent)
|
|
|
|
: detail::NewObject<withProto, false>(cx, clasp, proto, parent);
|
2010-04-10 16:16:35 -07:00
|
|
|
}
|
|
|
|
|
2010-06-18 17:43:02 -07:00
|
|
|
} /* namespace js */
|
2010-03-28 20:32:20 -07:00
|
|
|
|
2009-11-18 12:29:58 -08:00
|
|
|
#endif /* jsobjinlines_h___ */
|