2009-06-10 18:29:44 -07:00
|
|
|
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
|
2008-09-04 21:56:37 -07:00
|
|
|
* vim: set ts=8 sw=4 et tw=99:
|
2007-03-22 10:30:00 -07:00
|
|
|
*
|
|
|
|
* ***** 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 ***** */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* JS function support.
|
|
|
|
*/
|
|
|
|
#include <string.h>
|
2011-10-10 23:00:28 -07:00
|
|
|
|
|
|
|
#include "mozilla/Util.h"
|
|
|
|
|
2007-03-22 10:30:00 -07:00
|
|
|
#include "jstypes.h"
|
2009-03-18 11:38:16 -07:00
|
|
|
#include "jsstdint.h"
|
2010-10-01 16:46:54 -07:00
|
|
|
#include "jsutil.h"
|
2007-03-22 10:30:00 -07:00
|
|
|
#include "jsapi.h"
|
|
|
|
#include "jsarray.h"
|
|
|
|
#include "jsatom.h"
|
2009-08-14 11:43:16 -07:00
|
|
|
#include "jsbool.h"
|
2008-10-08 15:08:33 -07:00
|
|
|
#include "jsbuiltins.h"
|
2007-03-22 10:30:00 -07:00
|
|
|
#include "jscntxt.h"
|
2008-09-05 10:19:17 -07:00
|
|
|
#include "jsversion.h"
|
2007-03-22 10:30:00 -07:00
|
|
|
#include "jsfun.h"
|
|
|
|
#include "jsgc.h"
|
2011-04-15 16:56:08 -07:00
|
|
|
#include "jsgcmark.h"
|
2007-03-22 10:30:00 -07:00
|
|
|
#include "jsinterp.h"
|
|
|
|
#include "jslock.h"
|
|
|
|
#include "jsnum.h"
|
|
|
|
#include "jsobj.h"
|
|
|
|
#include "jsopcode.h"
|
2010-08-29 11:57:08 -07:00
|
|
|
#include "jspropertytree.h"
|
2010-06-23 14:35:10 -07:00
|
|
|
#include "jsproxy.h"
|
2007-03-22 10:30:00 -07:00
|
|
|
#include "jsscope.h"
|
|
|
|
#include "jsscript.h"
|
|
|
|
#include "jsstr.h"
|
|
|
|
#include "jsexn.h"
|
2009-09-09 11:46:32 -07:00
|
|
|
#include "jstracer.h"
|
2011-10-17 14:54:28 -07:00
|
|
|
|
2011-10-17 14:54:30 -07:00
|
|
|
#include "frontend/BytecodeCompiler.h"
|
2011-10-27 07:15:40 -07:00
|
|
|
#include "frontend/BytecodeEmitter.h"
|
2011-10-17 14:54:28 -07:00
|
|
|
#include "frontend/TokenStream.h"
|
2011-09-08 10:53:43 -07:00
|
|
|
#include "vm/CallObject.h"
|
2011-07-27 16:03:34 -07:00
|
|
|
#include "vm/Debugger.h"
|
2007-03-22 10:30:00 -07:00
|
|
|
|
|
|
|
#if JS_HAS_GENERATORS
|
|
|
|
# include "jsiter.h"
|
|
|
|
#endif
|
|
|
|
|
2008-02-08 16:01:45 -08:00
|
|
|
#if JS_HAS_XDR
|
|
|
|
# include "jsxdrapi.h"
|
|
|
|
#endif
|
|
|
|
|
2010-08-27 15:54:30 -07:00
|
|
|
#ifdef JS_METHODJIT
|
|
|
|
#include "methodjit/MethodJIT.h"
|
|
|
|
#endif
|
|
|
|
|
2009-07-13 14:55:04 -07:00
|
|
|
#include "jsatominlines.h"
|
2010-08-11 23:26:59 -07:00
|
|
|
#include "jsfuninlines.h"
|
2010-10-29 08:05:55 -07:00
|
|
|
#include "jsinferinlines.h"
|
2010-03-30 14:42:48 -07:00
|
|
|
#include "jsobjinlines.h"
|
2010-11-16 15:34:24 -08:00
|
|
|
#include "jsscriptinlines.h"
|
2011-09-08 10:53:43 -07:00
|
|
|
#include "vm/CallObject-inl.h"
|
2011-04-25 19:40:00 -07:00
|
|
|
#include "vm/ArgumentsObject-inl.h"
|
2011-04-13 09:27:37 -07:00
|
|
|
#include "vm/Stack-inl.h"
|
|
|
|
|
2011-10-10 23:00:28 -07:00
|
|
|
using namespace mozilla;
|
2010-01-22 14:49:18 -08:00
|
|
|
using namespace js;
|
2010-09-24 10:54:39 -07:00
|
|
|
using namespace js::gc;
|
2010-10-29 08:05:55 -07:00
|
|
|
using namespace js::types;
|
2010-01-22 14:49:18 -08:00
|
|
|
|
2010-08-02 23:52:12 -07:00
|
|
|
inline JSObject *
|
|
|
|
JSObject::getThrowTypeError() const
|
|
|
|
{
|
2011-04-18 13:50:47 -07:00
|
|
|
return getGlobal()->getThrowTypeError();
|
2010-08-02 23:52:12 -07:00
|
|
|
}
|
|
|
|
|
2007-03-22 10:30:00 -07:00
|
|
|
JSBool
|
2011-04-13 09:27:37 -07:00
|
|
|
js_GetArgsValue(JSContext *cx, StackFrame *fp, Value *vp)
|
2007-03-22 10:30:00 -07:00
|
|
|
{
|
|
|
|
JSObject *argsobj;
|
2010-08-09 22:43:33 -07:00
|
|
|
if (fp->hasOverriddenArgs()) {
|
2010-08-12 15:46:03 -07:00
|
|
|
JS_ASSERT(fp->hasCallObj());
|
2011-09-15 11:44:10 -07:00
|
|
|
return fp->callObj().getProperty(cx, cx->runtime->atomState.argumentsAtom, vp);
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
|
|
|
argsobj = js_GetArgsObject(cx, fp);
|
|
|
|
if (!argsobj)
|
|
|
|
return JS_FALSE;
|
2010-07-14 23:19:36 -07:00
|
|
|
vp->setObject(*argsobj);
|
2007-03-22 10:30:00 -07:00
|
|
|
return JS_TRUE;
|
|
|
|
}
|
|
|
|
|
2011-04-25 19:40:00 -07:00
|
|
|
js::ArgumentsObject *
|
2011-11-18 12:54:40 -08:00
|
|
|
ArgumentsObject::create(JSContext *cx, uint32 argc, JSObject &callee, StackFrame *fp)
|
2009-08-14 11:43:16 -07:00
|
|
|
{
|
2011-06-30 09:26:56 -07:00
|
|
|
JS_ASSERT(argc <= StackSpace::ARGS_LENGTH_MAX);
|
2011-04-25 19:40:00 -07:00
|
|
|
|
2011-05-09 13:06:53 -07:00
|
|
|
JSObject *proto = callee.getGlobal()->getOrCreateObjectPrototype(cx);
|
|
|
|
if (!proto)
|
2010-03-30 00:44:28 -07:00
|
|
|
return NULL;
|
|
|
|
|
2010-12-18 20:44:51 -08:00
|
|
|
TypeObject *type = proto->getNewType(cx);
|
|
|
|
if (!type)
|
|
|
|
return NULL;
|
|
|
|
|
2011-10-11 15:28:54 -07:00
|
|
|
bool strict = callee.toFunction()->inStrictMode();
|
2011-10-13 20:21:36 -07:00
|
|
|
Class *clasp = strict ? &StrictArgumentsObjectClass : &NormalArgumentsObjectClass;
|
2011-11-10 17:50:05 -08:00
|
|
|
Shape *emptyArgumentsShape =
|
|
|
|
EmptyShape::lookupInitialShape(cx, clasp, proto,
|
2011-11-18 12:54:40 -08:00
|
|
|
proto->getParent(), FINALIZE_OBJECT4,
|
|
|
|
BaseShape::INDEXED);
|
2011-03-07 18:42:04 -08:00
|
|
|
if (!emptyArgumentsShape)
|
|
|
|
return NULL;
|
|
|
|
|
2010-08-29 11:57:08 -07:00
|
|
|
ArgumentsData *data = (ArgumentsData *)
|
2011-03-31 01:14:12 -07:00
|
|
|
cx->malloc_(offsetof(ArgumentsData, slots) + argc * sizeof(Value));
|
2010-08-29 11:57:08 -07:00
|
|
|
if (!data)
|
2010-03-30 00:44:28 -07:00
|
|
|
return NULL;
|
2011-10-25 16:07:42 -07:00
|
|
|
|
|
|
|
data->callee.init(ObjectValue(callee));
|
|
|
|
InitValueRange(data->slots, argc, false);
|
2010-08-29 11:57:08 -07:00
|
|
|
|
2011-11-02 13:34:19 -07:00
|
|
|
/* We have everything needed to fill in the object, so make the object. */
|
2011-11-18 12:54:40 -08:00
|
|
|
JS_STATIC_ASSERT(NormalArgumentsObject::RESERVED_SLOTS == 3);
|
|
|
|
JS_STATIC_ASSERT(StrictArgumentsObject::RESERVED_SLOTS == 3);
|
2011-11-18 14:59:31 -08:00
|
|
|
JSObject *obj = JSObject::create(cx, FINALIZE_OBJECT4, emptyArgumentsShape, type, NULL);
|
2011-11-02 13:34:19 -07:00
|
|
|
if (!obj)
|
|
|
|
return NULL;
|
2011-04-25 19:40:00 -07:00
|
|
|
|
|
|
|
ArgumentsObject *argsobj = obj->asArguments();
|
2010-08-29 11:57:08 -07:00
|
|
|
|
2011-04-25 19:40:00 -07:00
|
|
|
JS_ASSERT(UINT32_MAX > (uint64(argc) << PACKED_BITS_COUNT));
|
2011-10-25 16:07:42 -07:00
|
|
|
argsobj->initInitialLength(argc);
|
|
|
|
argsobj->initData(data);
|
2011-11-18 12:54:40 -08:00
|
|
|
argsobj->setStackFrame(strict ? NULL : fp);
|
2010-08-11 23:26:59 -07:00
|
|
|
|
2011-11-18 12:54:40 -08:00
|
|
|
JS_ASSERT(argsobj->numFixedSlots() >= NormalArgumentsObject::RESERVED_SLOTS);
|
|
|
|
JS_ASSERT(argsobj->numFixedSlots() >= StrictArgumentsObject::RESERVED_SLOTS);
|
2011-10-10 17:14:38 -07:00
|
|
|
|
2009-08-14 11:43:16 -07:00
|
|
|
return argsobj;
|
|
|
|
}
|
|
|
|
|
2010-10-01 21:00:55 -07:00
|
|
|
struct STATIC_SKIP_INFERENCE PutArg
|
2009-08-14 11:43:16 -07:00
|
|
|
{
|
2011-10-25 16:07:42 -07:00
|
|
|
PutArg(JSCompartment *comp, HeapValue *dst) : dst(dst), compartment(comp) {}
|
|
|
|
HeapValue *dst;
|
|
|
|
JSCompartment *compartment;
|
2011-04-07 20:35:02 -07:00
|
|
|
bool operator()(uintN, Value *src) {
|
2011-10-25 16:07:42 -07:00
|
|
|
JS_ASSERT(dst->isMagic(JS_ARGS_HOLE) || dst->isUndefined());
|
2010-08-09 22:43:33 -07:00
|
|
|
if (!dst->isMagic(JS_ARGS_HOLE))
|
2011-10-25 16:07:42 -07:00
|
|
|
dst->set(compartment, *src);
|
2010-08-09 22:43:33 -07:00
|
|
|
++dst;
|
2011-04-07 20:35:02 -07:00
|
|
|
return true;
|
2009-08-14 11:43:16 -07:00
|
|
|
}
|
2010-08-09 22:43:33 -07:00
|
|
|
};
|
|
|
|
|
2007-03-22 10:30:00 -07:00
|
|
|
JSObject *
|
2011-04-13 09:27:37 -07:00
|
|
|
js_GetArgsObject(JSContext *cx, StackFrame *fp)
|
2007-03-22 10:30:00 -07:00
|
|
|
{
|
|
|
|
/*
|
2011-07-01 14:08:03 -07:00
|
|
|
* Arguments and Call objects are owned by the enclosing non-eval function
|
|
|
|
* frame, thus any eval frames must be skipped before testing hasArgsObj.
|
2007-03-22 10:30:00 -07:00
|
|
|
*/
|
2011-07-01 14:08:03 -07:00
|
|
|
JS_ASSERT(fp->isFunctionFrame());
|
2011-05-13 08:56:26 -07:00
|
|
|
while (fp->isEvalInFunction())
|
2010-08-09 22:43:33 -07:00
|
|
|
fp = fp->prev();
|
2007-03-22 10:30:00 -07:00
|
|
|
|
2011-06-06 08:32:41 -07:00
|
|
|
/*
|
|
|
|
* Mark all functions which have ever had arguments objects constructed,
|
|
|
|
* which will prevent lazy arguments optimizations in the method JIT.
|
|
|
|
*/
|
2011-07-21 07:28:01 -07:00
|
|
|
if (!fp->script()->createdArgs)
|
|
|
|
types::MarkArgumentsCreated(cx, fp->script());
|
2011-06-06 08:32:41 -07:00
|
|
|
|
2007-03-22 10:30:00 -07:00
|
|
|
/* Create an arguments object for fp only if it lacks one. */
|
2011-07-01 14:08:03 -07:00
|
|
|
JS_ASSERT_IF(fp->fun()->isHeavyweight(), fp->hasCallObj());
|
2010-08-12 15:46:03 -07:00
|
|
|
if (fp->hasArgsObj())
|
2010-08-09 22:43:33 -07:00
|
|
|
return &fp->argsObj();
|
2007-03-22 10:30:00 -07:00
|
|
|
|
2011-04-25 19:40:00 -07:00
|
|
|
ArgumentsObject *argsobj =
|
2011-11-18 12:54:40 -08:00
|
|
|
ArgumentsObject::create(cx, fp->numActualArgs(), fp->callee(), fp);
|
2009-08-04 03:55:58 -07:00
|
|
|
if (!argsobj)
|
2009-08-14 11:43:16 -07:00
|
|
|
return argsobj;
|
2009-08-04 03:55:58 -07:00
|
|
|
|
2010-08-11 23:27:33 -07:00
|
|
|
/*
|
2010-08-29 11:57:08 -07:00
|
|
|
* Strict mode functions have arguments objects that copy the initial
|
|
|
|
* actual parameter values. It is the caller's responsibility to get the
|
|
|
|
* arguments object before any parameters are modified! (The emitter
|
|
|
|
* ensures this by synthesizing an arguments access at the start of any
|
|
|
|
* strict mode function that contains an assignment to a parameter, or
|
|
|
|
* that calls eval.) Non-strict mode arguments use the frame pointer to
|
|
|
|
* retrieve up-to-date parameter values.
|
2010-08-11 23:27:33 -07:00
|
|
|
*/
|
2010-08-29 11:57:08 -07:00
|
|
|
if (argsobj->isStrictArguments())
|
2011-10-25 16:07:42 -07:00
|
|
|
fp->forEachCanonicalActualArg(PutArg(cx->compartment, argsobj->data()->slots));
|
2010-08-29 11:57:08 -07:00
|
|
|
else
|
2011-09-08 10:53:43 -07:00
|
|
|
argsobj->setStackFrame(fp);
|
2010-08-11 23:27:33 -07:00
|
|
|
|
2010-08-09 22:43:33 -07:00
|
|
|
fp->setArgsObj(*argsobj);
|
2007-03-22 10:30:00 -07:00
|
|
|
return argsobj;
|
|
|
|
}
|
|
|
|
|
2009-08-14 11:43:16 -07:00
|
|
|
void
|
2011-04-13 09:27:37 -07:00
|
|
|
js_PutArgsObject(StackFrame *fp)
|
2007-03-22 10:30:00 -07:00
|
|
|
{
|
2011-04-25 19:40:00 -07:00
|
|
|
ArgumentsObject &argsobj = fp->argsObj();
|
2010-08-09 22:43:33 -07:00
|
|
|
if (argsobj.isNormalArguments()) {
|
2011-09-08 10:53:43 -07:00
|
|
|
JS_ASSERT(argsobj.maybeStackFrame() == fp);
|
2011-10-25 16:07:42 -07:00
|
|
|
JSCompartment *comp = fp->scopeChain().compartment();
|
|
|
|
fp->forEachCanonicalActualArg(PutArg(comp, argsobj.data()->slots));
|
2011-09-08 10:53:43 -07:00
|
|
|
argsobj.setStackFrame(NULL);
|
2010-08-11 23:27:33 -07:00
|
|
|
} else {
|
2011-09-08 10:53:43 -07:00
|
|
|
JS_ASSERT(!argsobj.maybeStackFrame());
|
2010-08-11 23:27:33 -07:00
|
|
|
}
|
2009-08-14 11:43:16 -07:00
|
|
|
}
|
2007-03-22 10:30:00 -07:00
|
|
|
|
2010-08-29 11:57:08 -07:00
|
|
|
#ifdef JS_TRACER
|
|
|
|
|
2009-08-14 11:43:16 -07:00
|
|
|
/*
|
|
|
|
* Traced versions of js_GetArgsObject and js_PutArgsObject.
|
|
|
|
*/
|
2009-08-14 11:54:26 -07:00
|
|
|
JSObject * JS_FASTCALL
|
2011-05-11 14:04:25 -07:00
|
|
|
js_NewArgumentsOnTrace(JSContext *cx, uint32 argc, JSObject *callee)
|
2009-08-14 11:43:16 -07:00
|
|
|
{
|
2011-11-18 12:54:40 -08:00
|
|
|
ArgumentsObject *argsobj = ArgumentsObject::create(cx, argc, *callee, NULL);
|
2009-09-17 17:44:19 -07:00
|
|
|
if (!argsobj)
|
|
|
|
return NULL;
|
2010-08-11 23:27:33 -07:00
|
|
|
|
2010-08-29 11:57:08 -07:00
|
|
|
if (argsobj->isStrictArguments()) {
|
2010-08-11 23:27:33 -07:00
|
|
|
/*
|
|
|
|
* Strict mode callers must copy arguments into the created arguments
|
2010-08-29 11:57:08 -07:00
|
|
|
* object. The trace-JITting code is in TraceRecorder::newArguments.
|
2010-08-11 23:27:33 -07:00
|
|
|
*/
|
2011-09-08 10:53:43 -07:00
|
|
|
JS_ASSERT(!argsobj->maybeStackFrame());
|
2010-08-11 23:27:33 -07:00
|
|
|
} else {
|
2011-09-08 10:53:43 -07:00
|
|
|
argsobj->setOnTrace();
|
2010-08-11 23:27:33 -07:00
|
|
|
}
|
|
|
|
|
2009-09-09 11:40:21 -07:00
|
|
|
return argsobj;
|
2009-08-14 11:43:16 -07:00
|
|
|
}
|
2011-05-11 14:04:25 -07:00
|
|
|
JS_DEFINE_CALLINFO_3(extern, OBJECT, js_NewArgumentsOnTrace, CONTEXT, UINT32, OBJECT,
|
2010-08-06 17:19:22 -07:00
|
|
|
0, nanojit::ACCSET_STORE_ANY)
|
2007-03-22 10:30:00 -07:00
|
|
|
|
2009-08-14 11:43:16 -07:00
|
|
|
/* FIXME change the return type to void. */
|
|
|
|
JSBool JS_FASTCALL
|
2011-04-25 19:40:00 -07:00
|
|
|
js_PutArgumentsOnTrace(JSContext *cx, JSObject *obj, Value *argv)
|
2009-08-14 11:43:16 -07:00
|
|
|
{
|
2011-04-25 19:40:00 -07:00
|
|
|
NormalArgumentsObject *argsobj = obj->asNormalArguments();
|
|
|
|
|
2011-09-08 10:53:43 -07:00
|
|
|
JS_ASSERT(argsobj->onTrace());
|
2010-08-09 22:43:33 -07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* TraceRecorder::putActivationObjects builds a single, contiguous array of
|
|
|
|
* the arguments, regardless of whether #actuals > #formals so there is no
|
|
|
|
* need to worry about actual vs. formal arguments.
|
|
|
|
*/
|
2011-04-25 19:40:00 -07:00
|
|
|
Value *srcend = argv + argsobj->initialLength();
|
2011-10-25 16:07:42 -07:00
|
|
|
HeapValue *dst = argsobj->data()->slots;
|
|
|
|
JSCompartment *comp = cx->compartment;
|
2011-04-25 19:40:00 -07:00
|
|
|
for (Value *src = argv; src < srcend; ++src, ++dst) {
|
2010-08-09 22:43:33 -07:00
|
|
|
if (!dst->isMagic(JS_ARGS_HOLE))
|
2011-10-25 16:07:42 -07:00
|
|
|
dst->set(comp, *src);
|
2010-08-09 22:43:33 -07:00
|
|
|
}
|
|
|
|
|
2011-09-08 10:53:43 -07:00
|
|
|
argsobj->clearOnTrace();
|
2009-08-14 11:43:16 -07:00
|
|
|
return true;
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
2010-08-09 22:43:33 -07:00
|
|
|
JS_DEFINE_CALLINFO_3(extern, BOOL, js_PutArgumentsOnTrace, CONTEXT, OBJECT, VALUEPTR, 0,
|
2010-07-27 22:33:42 -07:00
|
|
|
nanojit::ACCSET_STORE_ANY)
|
2009-08-14 11:43:16 -07:00
|
|
|
|
2010-08-29 11:57:08 -07:00
|
|
|
#endif /* JS_TRACER */
|
|
|
|
|
2007-03-22 10:30:00 -07:00
|
|
|
static JSBool
|
2010-07-14 23:19:36 -07:00
|
|
|
args_delProperty(JSContext *cx, JSObject *obj, jsid id, Value *vp)
|
2007-03-22 10:30:00 -07:00
|
|
|
{
|
2011-04-25 19:40:00 -07:00
|
|
|
ArgumentsObject *argsobj = obj->asArguments();
|
2010-07-14 23:19:36 -07:00
|
|
|
if (JSID_IS_INT(id)) {
|
|
|
|
uintN arg = uintN(JSID_TO_INT(id));
|
2011-04-25 19:40:00 -07:00
|
|
|
if (arg < argsobj->initialLength())
|
|
|
|
argsobj->setElement(arg, MagicValue(JS_ARGS_HOLE));
|
2010-07-14 23:19:36 -07:00
|
|
|
} else if (JSID_IS_ATOM(id, cx->runtime->atomState.lengthAtom)) {
|
2011-04-25 19:40:00 -07:00
|
|
|
argsobj->markLengthOverridden();
|
2010-07-14 23:19:36 -07:00
|
|
|
} else if (JSID_IS_ATOM(id, cx->runtime->atomState.calleeAtom)) {
|
2011-04-25 19:40:00 -07:00
|
|
|
argsobj->asNormalArguments()->clearCallee();
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
2009-08-04 03:55:58 -07:00
|
|
|
return true;
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static JSBool
|
2010-07-14 23:19:36 -07:00
|
|
|
ArgGetter(JSContext *cx, JSObject *obj, jsid id, Value *vp)
|
2007-03-22 10:30:00 -07:00
|
|
|
{
|
2010-08-06 17:19:22 -07:00
|
|
|
LeaveTrace(cx);
|
|
|
|
|
2011-04-11 01:38:27 -07:00
|
|
|
if (!obj->isNormalArguments())
|
2009-08-04 03:55:58 -07:00
|
|
|
return true;
|
2007-03-22 10:30:00 -07:00
|
|
|
|
2011-04-25 19:40:00 -07:00
|
|
|
NormalArgumentsObject *argsobj = obj->asNormalArguments();
|
2010-07-14 23:19:36 -07:00
|
|
|
if (JSID_IS_INT(id)) {
|
2009-08-04 03:55:58 -07:00
|
|
|
/*
|
|
|
|
* arg can exceed the number of arguments if a script changed the
|
|
|
|
* prototype to point to another Arguments object with a bigger argc.
|
|
|
|
*/
|
2010-07-14 23:19:36 -07:00
|
|
|
uintN arg = uintN(JSID_TO_INT(id));
|
2011-04-25 19:40:00 -07:00
|
|
|
if (arg < argsobj->initialLength()) {
|
|
|
|
JS_ASSERT(!argsobj->element(arg).isMagic(JS_ARGS_HOLE));
|
2011-09-08 10:53:43 -07:00
|
|
|
if (StackFrame *fp = argsobj->maybeStackFrame())
|
2010-08-09 22:43:33 -07:00
|
|
|
*vp = fp->canonicalActualArg(arg);
|
2010-10-06 10:09:40 -07:00
|
|
|
else
|
2011-04-25 19:40:00 -07:00
|
|
|
*vp = argsobj->element(arg);
|
2009-08-14 11:43:16 -07:00
|
|
|
}
|
2010-07-14 23:19:36 -07:00
|
|
|
} else if (JSID_IS_ATOM(id, cx->runtime->atomState.lengthAtom)) {
|
2011-04-25 19:40:00 -07:00
|
|
|
if (!argsobj->hasOverriddenLength())
|
|
|
|
vp->setInt32(argsobj->initialLength());
|
2009-08-04 03:55:58 -07:00
|
|
|
} else {
|
2010-07-14 23:19:36 -07:00
|
|
|
JS_ASSERT(JSID_IS_ATOM(id, cx->runtime->atomState.calleeAtom));
|
2011-04-25 19:40:00 -07:00
|
|
|
const Value &v = argsobj->callee();
|
2011-07-13 05:15:59 -07:00
|
|
|
if (!v.isMagic(JS_ARGS_HOLE))
|
2009-08-14 11:43:16 -07:00
|
|
|
*vp = v;
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
2009-08-04 03:55:58 -07:00
|
|
|
return true;
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static JSBool
|
2011-02-09 11:31:40 -08:00
|
|
|
ArgSetter(JSContext *cx, JSObject *obj, jsid id, JSBool strict, Value *vp)
|
2007-03-22 10:30:00 -07:00
|
|
|
{
|
2009-11-09 16:42:38 -08:00
|
|
|
#ifdef JS_TRACER
|
2009-11-09 15:36:41 -08:00
|
|
|
// To be able to set a property here on trace, we would have to make
|
|
|
|
// sure any updates also get written back to the trace native stack.
|
|
|
|
// For simplicity, we just leave trace, since this is presumably not
|
|
|
|
// a common operation.
|
2011-02-14 12:01:58 -08:00
|
|
|
LeaveTrace(cx);
|
2009-11-09 16:42:38 -08:00
|
|
|
#endif
|
2009-11-09 15:36:41 -08:00
|
|
|
|
2011-04-11 01:38:27 -07:00
|
|
|
|
|
|
|
if (!obj->isNormalArguments())
|
2009-08-04 03:55:58 -07:00
|
|
|
return true;
|
2007-03-22 10:30:00 -07:00
|
|
|
|
2011-04-25 19:40:00 -07:00
|
|
|
NormalArgumentsObject *argsobj = obj->asNormalArguments();
|
|
|
|
|
2010-07-14 23:19:36 -07:00
|
|
|
if (JSID_IS_INT(id)) {
|
|
|
|
uintN arg = uintN(JSID_TO_INT(id));
|
2011-04-25 19:40:00 -07:00
|
|
|
if (arg < argsobj->initialLength()) {
|
2011-09-08 10:53:43 -07:00
|
|
|
if (StackFrame *fp = argsobj->maybeStackFrame()) {
|
2010-09-29 18:05:54 -07:00
|
|
|
JSScript *script = fp->functionScript();
|
2010-10-29 08:05:55 -07:00
|
|
|
if (script->usesArguments) {
|
2011-05-09 07:12:47 -07:00
|
|
|
if (arg < fp->numFormalArgs())
|
2011-07-28 09:16:53 -07:00
|
|
|
TypeScript::SetArgument(cx, script, arg, *vp);
|
2010-09-29 18:05:54 -07:00
|
|
|
fp->canonicalActualArg(arg) = *vp;
|
2010-10-29 08:05:55 -07:00
|
|
|
}
|
2009-08-14 11:43:16 -07:00
|
|
|
return true;
|
|
|
|
}
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
2009-08-04 03:55:58 -07:00
|
|
|
} else {
|
2010-07-14 23:19:36 -07:00
|
|
|
JS_ASSERT(JSID_IS_ATOM(id, cx->runtime->atomState.lengthAtom) ||
|
|
|
|
JSID_IS_ATOM(id, cx->runtime->atomState.calleeAtom));
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
2009-08-14 11:43:16 -07:00
|
|
|
|
|
|
|
/*
|
2011-02-03 15:11:21 -08:00
|
|
|
* For simplicity we use delete/define to replace the property with one
|
2010-08-11 23:26:59 -07:00
|
|
|
* backed by the default Object getter and setter. Note that we rely on
|
|
|
|
* args_delProperty to clear the corresponding reserved slot so the GC can
|
2011-02-03 15:11:21 -08:00
|
|
|
* collect its value. Note also that we must define the property instead
|
|
|
|
* of setting it in case the user has changed the prototype to an object
|
|
|
|
* that has a setter for this id.
|
2009-08-14 11:43:16 -07:00
|
|
|
*/
|
2010-03-28 22:05:50 -07:00
|
|
|
AutoValueRooter tvr(cx);
|
2011-04-25 19:40:00 -07:00
|
|
|
return js_DeleteProperty(cx, argsobj, id, tvr.addr(), false) &&
|
|
|
|
js_DefineProperty(cx, argsobj, id, vp, NULL, NULL, JSPROP_ENUMERATE);
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static JSBool
|
2010-07-14 23:19:36 -07:00
|
|
|
args_resolve(JSContext *cx, JSObject *obj, jsid id, uintN flags,
|
2007-03-22 10:30:00 -07:00
|
|
|
JSObject **objp)
|
|
|
|
{
|
2009-08-14 11:43:16 -07:00
|
|
|
*objp = NULL;
|
2010-12-13 18:10:39 -08:00
|
|
|
|
2011-04-25 19:40:00 -07:00
|
|
|
NormalArgumentsObject *argsobj = obj->asNormalArguments();
|
|
|
|
|
2010-12-13 18:10:39 -08:00
|
|
|
uintN attrs = JSPROP_SHARED | JSPROP_SHADOWABLE;
|
2010-07-14 23:19:36 -07:00
|
|
|
if (JSID_IS_INT(id)) {
|
|
|
|
uint32 arg = uint32(JSID_TO_INT(id));
|
2011-04-25 19:40:00 -07:00
|
|
|
if (arg >= argsobj->initialLength() || argsobj->element(arg).isMagic(JS_ARGS_HOLE))
|
2010-12-13 18:10:39 -08:00
|
|
|
return true;
|
|
|
|
|
|
|
|
attrs |= JSPROP_ENUMERATE;
|
2010-07-14 23:19:36 -07:00
|
|
|
} else if (JSID_IS_ATOM(id, cx->runtime->atomState.lengthAtom)) {
|
2011-04-25 19:40:00 -07:00
|
|
|
if (argsobj->hasOverriddenLength())
|
2010-12-13 18:10:39 -08:00
|
|
|
return true;
|
|
|
|
} else {
|
|
|
|
if (!JSID_IS_ATOM(id, cx->runtime->atomState.calleeAtom))
|
|
|
|
return true;
|
2007-03-22 10:30:00 -07:00
|
|
|
|
2011-04-25 19:40:00 -07:00
|
|
|
if (argsobj->callee().isMagic(JS_ARGS_HOLE))
|
2010-12-13 18:10:39 -08:00
|
|
|
return true;
|
2009-08-14 11:43:16 -07:00
|
|
|
}
|
2010-12-13 18:10:39 -08:00
|
|
|
|
|
|
|
Value undef = UndefinedValue();
|
2011-04-25 19:40:00 -07:00
|
|
|
if (!js_DefineProperty(cx, argsobj, id, &undef, ArgGetter, ArgSetter, attrs))
|
2010-12-13 18:10:39 -08:00
|
|
|
return JS_FALSE;
|
|
|
|
|
2011-04-25 19:40:00 -07:00
|
|
|
*objp = argsobj;
|
2009-08-04 03:55:58 -07:00
|
|
|
return true;
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static JSBool
|
|
|
|
args_enumerate(JSContext *cx, JSObject *obj)
|
|
|
|
{
|
2011-04-25 19:40:00 -07:00
|
|
|
NormalArgumentsObject *argsobj = obj->asNormalArguments();
|
2007-03-22 10:30:00 -07:00
|
|
|
|
|
|
|
/*
|
2009-08-14 11:43:16 -07:00
|
|
|
* Trigger reflection in args_resolve using a series of js_LookupProperty
|
|
|
|
* calls.
|
2007-03-22 10:30:00 -07:00
|
|
|
*/
|
2011-04-25 19:40:00 -07:00
|
|
|
int argc = int(argsobj->initialLength());
|
2009-08-04 03:55:58 -07:00
|
|
|
for (int i = -2; i != argc; i++) {
|
|
|
|
jsid id = (i == -2)
|
|
|
|
? ATOM_TO_JSID(cx->runtime->atomState.lengthAtom)
|
|
|
|
: (i == -1)
|
|
|
|
? ATOM_TO_JSID(cx->runtime->atomState.calleeAtom)
|
2010-07-14 23:19:36 -07:00
|
|
|
: INT_TO_JSID(i);
|
2009-08-04 03:55:58 -07:00
|
|
|
|
|
|
|
JSObject *pobj;
|
|
|
|
JSProperty *prop;
|
2011-04-25 19:40:00 -07:00
|
|
|
if (!js_LookupProperty(cx, argsobj, id, &pobj, &prop))
|
2009-08-04 03:55:58 -07:00
|
|
|
return false;
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
2009-08-04 03:55:58 -07:00
|
|
|
return true;
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
|
|
|
|
2010-10-25 16:47:11 -07:00
|
|
|
static JSBool
|
2010-08-11 23:26:59 -07:00
|
|
|
StrictArgGetter(JSContext *cx, JSObject *obj, jsid id, Value *vp)
|
|
|
|
{
|
|
|
|
LeaveTrace(cx);
|
|
|
|
|
2011-04-11 01:38:27 -07:00
|
|
|
if (!obj->isStrictArguments())
|
2010-08-11 23:26:59 -07:00
|
|
|
return true;
|
|
|
|
|
2011-04-25 19:40:00 -07:00
|
|
|
StrictArgumentsObject *argsobj = obj->asStrictArguments();
|
|
|
|
|
2010-08-11 23:26:59 -07:00
|
|
|
if (JSID_IS_INT(id)) {
|
|
|
|
/*
|
|
|
|
* arg can exceed the number of arguments if a script changed the
|
|
|
|
* prototype to point to another Arguments object with a bigger argc.
|
|
|
|
*/
|
|
|
|
uintN arg = uintN(JSID_TO_INT(id));
|
2011-04-25 19:40:00 -07:00
|
|
|
if (arg < argsobj->initialLength()) {
|
|
|
|
const Value &v = argsobj->element(arg);
|
2010-08-11 23:27:33 -07:00
|
|
|
if (!v.isMagic(JS_ARGS_HOLE))
|
|
|
|
*vp = v;
|
2010-08-11 23:26:59 -07:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
JS_ASSERT(JSID_IS_ATOM(id, cx->runtime->atomState.lengthAtom));
|
2011-04-25 19:40:00 -07:00
|
|
|
if (!argsobj->hasOverriddenLength())
|
|
|
|
vp->setInt32(argsobj->initialLength());
|
2010-08-11 23:26:59 -07:00
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2010-10-25 16:47:11 -07:00
|
|
|
static JSBool
|
2011-02-09 11:31:40 -08:00
|
|
|
StrictArgSetter(JSContext *cx, JSObject *obj, jsid id, JSBool strict, Value *vp)
|
2010-08-11 23:26:59 -07:00
|
|
|
{
|
2011-04-11 01:38:27 -07:00
|
|
|
if (!obj->isStrictArguments())
|
2010-08-11 23:26:59 -07:00
|
|
|
return true;
|
|
|
|
|
2011-04-25 19:40:00 -07:00
|
|
|
StrictArgumentsObject *argsobj = obj->asStrictArguments();
|
|
|
|
|
2010-08-11 23:26:59 -07:00
|
|
|
if (JSID_IS_INT(id)) {
|
|
|
|
uintN arg = uintN(JSID_TO_INT(id));
|
2011-04-25 19:40:00 -07:00
|
|
|
if (arg < argsobj->initialLength()) {
|
|
|
|
argsobj->setElement(arg, *vp);
|
2010-08-11 23:26:59 -07:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
JS_ASSERT(JSID_IS_ATOM(id, cx->runtime->atomState.lengthAtom));
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* For simplicity we use delete/set to replace the property with one
|
|
|
|
* backed by the default Object getter and setter. Note that we rely on
|
|
|
|
* args_delProperty to clear the corresponding reserved slot so the GC can
|
|
|
|
* collect its value.
|
|
|
|
*/
|
|
|
|
AutoValueRooter tvr(cx);
|
2011-04-25 19:40:00 -07:00
|
|
|
return js_DeleteProperty(cx, argsobj, id, tvr.addr(), strict) &&
|
2011-07-27 15:44:43 -07:00
|
|
|
js_SetPropertyHelper(cx, argsobj, id, 0, vp, strict);
|
2010-08-11 23:26:59 -07:00
|
|
|
}
|
|
|
|
|
2010-10-25 16:47:11 -07:00
|
|
|
static JSBool
|
2010-08-11 23:26:59 -07:00
|
|
|
strictargs_resolve(JSContext *cx, JSObject *obj, jsid id, uintN flags, JSObject **objp)
|
|
|
|
{
|
|
|
|
*objp = NULL;
|
2010-12-13 18:10:39 -08:00
|
|
|
|
2011-04-25 19:40:00 -07:00
|
|
|
StrictArgumentsObject *argsobj = obj->asStrictArguments();
|
|
|
|
|
2010-12-13 18:10:39 -08:00
|
|
|
uintN attrs = JSPROP_SHARED | JSPROP_SHADOWABLE;
|
|
|
|
PropertyOp getter = StrictArgGetter;
|
2011-02-09 11:31:40 -08:00
|
|
|
StrictPropertyOp setter = StrictArgSetter;
|
2010-12-13 18:10:39 -08:00
|
|
|
|
2010-08-11 23:26:59 -07:00
|
|
|
if (JSID_IS_INT(id)) {
|
|
|
|
uint32 arg = uint32(JSID_TO_INT(id));
|
2011-04-25 19:40:00 -07:00
|
|
|
if (arg >= argsobj->initialLength() || argsobj->element(arg).isMagic(JS_ARGS_HOLE))
|
2010-12-13 18:10:39 -08:00
|
|
|
return true;
|
2010-08-11 23:26:59 -07:00
|
|
|
|
2010-12-13 18:10:39 -08:00
|
|
|
attrs |= JSPROP_ENUMERATE;
|
|
|
|
} else if (JSID_IS_ATOM(id, cx->runtime->atomState.lengthAtom)) {
|
2011-04-25 19:40:00 -07:00
|
|
|
if (argsobj->hasOverriddenLength())
|
2010-12-13 18:10:39 -08:00
|
|
|
return true;
|
|
|
|
} else {
|
|
|
|
if (!JSID_IS_ATOM(id, cx->runtime->atomState.calleeAtom) &&
|
|
|
|
!JSID_IS_ATOM(id, cx->runtime->atomState.callerAtom)) {
|
|
|
|
return true;
|
2010-08-11 23:26:59 -07:00
|
|
|
}
|
|
|
|
|
2010-12-13 18:10:39 -08:00
|
|
|
attrs = JSPROP_PERMANENT | JSPROP_GETTER | JSPROP_SETTER | JSPROP_SHARED;
|
2011-04-25 19:40:00 -07:00
|
|
|
getter = CastAsPropertyOp(argsobj->getThrowTypeError());
|
|
|
|
setter = CastAsStrictPropertyOp(argsobj->getThrowTypeError());
|
2010-08-11 23:26:59 -07:00
|
|
|
}
|
|
|
|
|
2010-12-13 18:10:39 -08:00
|
|
|
Value undef = UndefinedValue();
|
2011-04-25 19:40:00 -07:00
|
|
|
if (!js_DefineProperty(cx, argsobj, id, &undef, getter, setter, attrs))
|
2010-12-13 18:10:39 -08:00
|
|
|
return false;
|
|
|
|
|
2011-04-25 19:40:00 -07:00
|
|
|
*objp = argsobj;
|
2010-08-11 23:26:59 -07:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2010-10-25 16:47:11 -07:00
|
|
|
static JSBool
|
2010-08-11 23:26:59 -07:00
|
|
|
strictargs_enumerate(JSContext *cx, JSObject *obj)
|
|
|
|
{
|
2011-04-25 19:40:00 -07:00
|
|
|
StrictArgumentsObject *argsobj = obj->asStrictArguments();
|
2010-08-11 23:26:59 -07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Trigger reflection in strictargs_resolve using a series of
|
2010-10-22 17:04:22 -07:00
|
|
|
* js_LookupProperty calls.
|
2010-08-11 23:26:59 -07:00
|
|
|
*/
|
|
|
|
JSObject *pobj;
|
|
|
|
JSProperty *prop;
|
|
|
|
|
|
|
|
// length
|
2011-04-25 19:40:00 -07:00
|
|
|
if (!js_LookupProperty(cx, argsobj, ATOM_TO_JSID(cx->runtime->atomState.lengthAtom), &pobj, &prop))
|
2010-08-11 23:26:59 -07:00
|
|
|
return false;
|
|
|
|
|
|
|
|
// callee
|
2011-04-25 19:40:00 -07:00
|
|
|
if (!js_LookupProperty(cx, argsobj, ATOM_TO_JSID(cx->runtime->atomState.calleeAtom), &pobj, &prop))
|
2010-08-11 23:26:59 -07:00
|
|
|
return false;
|
|
|
|
|
|
|
|
// caller
|
2011-04-25 19:40:00 -07:00
|
|
|
if (!js_LookupProperty(cx, argsobj, ATOM_TO_JSID(cx->runtime->atomState.callerAtom), &pobj, &prop))
|
2010-08-11 23:26:59 -07:00
|
|
|
return false;
|
|
|
|
|
2011-04-25 19:40:00 -07:00
|
|
|
for (uint32 i = 0, argc = argsobj->initialLength(); i < argc; i++) {
|
|
|
|
if (!js_LookupProperty(cx, argsobj, INT_TO_JSID(i), &pobj, &prop))
|
2010-08-11 23:26:59 -07:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2010-08-29 11:57:08 -07:00
|
|
|
static void
|
|
|
|
args_finalize(JSContext *cx, JSObject *obj)
|
|
|
|
{
|
2011-04-25 19:40:00 -07:00
|
|
|
cx->free_(reinterpret_cast<void *>(obj->asArguments()->data()));
|
2010-08-29 11:57:08 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
args_trace(JSTracer *trc, JSObject *obj)
|
|
|
|
{
|
2011-04-25 19:40:00 -07:00
|
|
|
ArgumentsObject *argsobj = obj->asArguments();
|
2011-09-08 10:53:43 -07:00
|
|
|
if (argsobj->onTrace()) {
|
2011-04-25 19:40:00 -07:00
|
|
|
JS_ASSERT(!argsobj->isStrictArguments());
|
2010-08-29 11:57:08 -07:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2011-04-25 19:40:00 -07:00
|
|
|
ArgumentsData *data = argsobj->data();
|
2011-10-25 16:07:42 -07:00
|
|
|
MarkValue(trc, data->callee, js_callee_str);
|
2011-04-25 19:40:00 -07:00
|
|
|
MarkValueRange(trc, argsobj->initialLength(), data->slots, js_arguments_str);
|
2010-08-29 11:57:08 -07:00
|
|
|
|
2011-11-18 12:54:40 -08:00
|
|
|
/*
|
|
|
|
* If a generator's arguments or call object escapes, and the generator
|
|
|
|
* frame is not executing, the generator object needs to be marked because
|
|
|
|
* it is not otherwise reachable. An executing generator is rooted by its
|
|
|
|
* invocation. To distinguish the two cases (which imply different access
|
|
|
|
* paths to the generator object), we use the JSFRAME_FLOATING_GENERATOR
|
|
|
|
* flag, which is only set on the StackFrame kept in the generator object's
|
|
|
|
* JSGenerator.
|
|
|
|
*/
|
|
|
|
#if JS_HAS_GENERATORS
|
|
|
|
StackFrame *fp = argsobj->maybeStackFrame();
|
|
|
|
if (fp && fp->isFloatingGenerator())
|
|
|
|
MarkObject(trc, js_FloatingFrameToGenerator(fp)->obj, "generator object");
|
|
|
|
#endif
|
2010-08-29 11:57:08 -07:00
|
|
|
}
|
2007-03-22 10:30:00 -07:00
|
|
|
|
|
|
|
/*
|
2011-04-25 19:40:00 -07:00
|
|
|
* The classes below collaborate to lazily reflect and synchronize actual
|
|
|
|
* argument values, argument count, and callee function object stored in a
|
|
|
|
* StackFrame with their corresponding property values in the frame's
|
2007-03-22 10:30:00 -07:00
|
|
|
* arguments object.
|
|
|
|
*/
|
2011-09-02 17:23:26 -07:00
|
|
|
Class js::NormalArgumentsObjectClass = {
|
2010-07-13 14:39:03 -07:00
|
|
|
"Arguments",
|
2011-11-18 12:54:40 -08:00
|
|
|
JSCLASS_NEW_RESOLVE |
|
2011-09-02 17:23:26 -07:00
|
|
|
JSCLASS_HAS_RESERVED_SLOTS(NormalArgumentsObject::RESERVED_SLOTS) |
|
2011-03-05 14:50:11 -08:00
|
|
|
JSCLASS_HAS_CACHED_PROTO(JSProto_Object),
|
2011-09-20 11:40:24 -07:00
|
|
|
JS_PropertyStub, /* addProperty */
|
2010-06-12 09:29:04 -07:00
|
|
|
args_delProperty,
|
2011-09-20 11:40:24 -07:00
|
|
|
JS_PropertyStub, /* getProperty */
|
|
|
|
JS_StrictPropertyStub, /* setProperty */
|
2010-06-12 09:29:04 -07:00
|
|
|
args_enumerate,
|
2011-04-25 19:40:00 -07:00
|
|
|
reinterpret_cast<JSResolveOp>(args_resolve),
|
2011-09-20 11:40:24 -07:00
|
|
|
JS_ConvertStub,
|
|
|
|
args_finalize, /* finalize */
|
|
|
|
NULL, /* reserved0 */
|
|
|
|
NULL, /* checkAccess */
|
|
|
|
NULL, /* call */
|
|
|
|
NULL, /* construct */
|
|
|
|
NULL, /* xdrObject */
|
|
|
|
NULL, /* hasInstance */
|
2011-03-05 14:50:11 -08:00
|
|
|
args_trace
|
2007-03-22 10:30:00 -07:00
|
|
|
};
|
|
|
|
|
2010-08-11 23:26:59 -07:00
|
|
|
/*
|
|
|
|
* Strict mode arguments is significantly less magical than non-strict mode
|
|
|
|
* arguments, so it is represented by a different class while sharing some
|
|
|
|
* functionality.
|
|
|
|
*/
|
2011-09-02 17:23:26 -07:00
|
|
|
Class js::StrictArgumentsObjectClass = {
|
2010-08-11 23:26:59 -07:00
|
|
|
"Arguments",
|
2011-11-18 12:54:40 -08:00
|
|
|
JSCLASS_NEW_RESOLVE |
|
2011-09-02 17:23:26 -07:00
|
|
|
JSCLASS_HAS_RESERVED_SLOTS(StrictArgumentsObject::RESERVED_SLOTS) |
|
2011-03-05 14:50:11 -08:00
|
|
|
JSCLASS_HAS_CACHED_PROTO(JSProto_Object),
|
2011-09-20 11:40:24 -07:00
|
|
|
JS_PropertyStub, /* addProperty */
|
2010-08-11 23:26:59 -07:00
|
|
|
args_delProperty,
|
2011-09-20 11:40:24 -07:00
|
|
|
JS_PropertyStub, /* getProperty */
|
|
|
|
JS_StrictPropertyStub, /* setProperty */
|
2010-08-11 23:26:59 -07:00
|
|
|
strictargs_enumerate,
|
|
|
|
reinterpret_cast<JSResolveOp>(strictargs_resolve),
|
2011-09-20 11:40:24 -07:00
|
|
|
JS_ConvertStub,
|
|
|
|
args_finalize, /* finalize */
|
|
|
|
NULL, /* reserved0 */
|
|
|
|
NULL, /* checkAccess */
|
|
|
|
NULL, /* call */
|
|
|
|
NULL, /* construct */
|
|
|
|
NULL, /* xdrObject */
|
|
|
|
NULL, /* hasInstance */
|
2011-03-05 14:50:11 -08:00
|
|
|
args_trace
|
2010-08-11 23:26:59 -07:00
|
|
|
};
|
|
|
|
|
2009-06-04 18:58:47 -07:00
|
|
|
/*
|
2011-04-13 09:27:37 -07:00
|
|
|
* A Declarative Environment object stores its active StackFrame pointer in
|
2009-06-04 18:58:47 -07:00
|
|
|
* its private slot, just as Call and Arguments objects do.
|
|
|
|
*/
|
2011-09-02 17:23:26 -07:00
|
|
|
Class js::DeclEnvClass = {
|
2009-04-14 03:54:37 -07:00
|
|
|
js_Object_str,
|
2011-10-12 22:29:43 -07:00
|
|
|
JSCLASS_HAS_PRIVATE |
|
|
|
|
JSCLASS_HAS_RESERVED_SLOTS(CallObject::DECL_ENV_RESERVED_SLOTS) |
|
|
|
|
JSCLASS_HAS_CACHED_PROTO(JSProto_Object),
|
2011-09-20 11:40:24 -07:00
|
|
|
JS_PropertyStub, /* addProperty */
|
|
|
|
JS_PropertyStub, /* delProperty */
|
|
|
|
JS_PropertyStub, /* getProperty */
|
|
|
|
JS_StrictPropertyStub, /* setProperty */
|
|
|
|
JS_EnumerateStub,
|
|
|
|
JS_ResolveStub,
|
|
|
|
JS_ConvertStub
|
2009-04-14 03:54:37 -07:00
|
|
|
};
|
|
|
|
|
2010-06-18 17:43:02 -07:00
|
|
|
static inline JSObject *
|
2011-04-13 09:27:37 -07:00
|
|
|
NewDeclEnvObject(JSContext *cx, StackFrame *fp)
|
2010-06-18 17:43:02 -07:00
|
|
|
{
|
2011-10-07 20:09:09 -07:00
|
|
|
types::TypeObject *type = cx->compartment->getEmptyType(cx);
|
|
|
|
if (!type)
|
|
|
|
return NULL;
|
|
|
|
|
2011-10-13 20:21:36 -07:00
|
|
|
JSObject *parent = fp->scopeChain().getGlobal();
|
2011-11-10 17:50:05 -08:00
|
|
|
Shape *emptyDeclEnvShape = EmptyShape::lookupInitialShape(cx, &DeclEnvClass, NULL,
|
|
|
|
parent, FINALIZE_OBJECT2);
|
2011-03-07 18:42:04 -08:00
|
|
|
if (!emptyDeclEnvShape)
|
2011-03-04 07:50:32 -08:00
|
|
|
return NULL;
|
2011-11-02 13:34:19 -07:00
|
|
|
|
2011-11-18 14:59:31 -08:00
|
|
|
JSObject *envobj = JSObject::create(cx, FINALIZE_OBJECT2, emptyDeclEnvShape, type, NULL);
|
2011-11-02 13:34:19 -07:00
|
|
|
if (!envobj)
|
|
|
|
return NULL;
|
2011-10-10 17:14:38 -07:00
|
|
|
envobj->setPrivate(fp);
|
2011-03-04 07:50:32 -08:00
|
|
|
|
2011-11-09 09:52:59 -08:00
|
|
|
if (!envobj->setInternalScopeChain(cx, &fp->scopeChain()))
|
2011-11-08 16:56:00 -08:00
|
|
|
return NULL;
|
2011-10-12 22:29:43 -07:00
|
|
|
|
2010-06-18 17:43:02 -07:00
|
|
|
return envobj;
|
|
|
|
}
|
|
|
|
|
2011-03-14 11:30:36 -07:00
|
|
|
namespace js {
|
|
|
|
|
2011-09-08 10:53:43 -07:00
|
|
|
CallObject *
|
2011-04-13 09:27:37 -07:00
|
|
|
CreateFunCallObject(JSContext *cx, StackFrame *fp)
|
2007-03-22 10:30:00 -07:00
|
|
|
{
|
2011-03-14 11:30:36 -07:00
|
|
|
JS_ASSERT(fp->isNonEvalFunctionFrame());
|
|
|
|
JS_ASSERT(!fp->hasCallObj());
|
2007-03-22 10:30:00 -07:00
|
|
|
|
2011-03-14 11:30:36 -07:00
|
|
|
JSObject *scopeChain = &fp->scopeChain();
|
|
|
|
JS_ASSERT_IF(scopeChain->isWith() || scopeChain->isBlock() || scopeChain->isCall(),
|
|
|
|
scopeChain->getPrivate() != fp);
|
2007-03-22 10:30:00 -07:00
|
|
|
|
2009-02-18 23:57:24 -08:00
|
|
|
/*
|
2011-03-14 11:30:36 -07:00
|
|
|
* For a named function expression Call's parent points to an environment
|
|
|
|
* object holding function's name.
|
2009-02-18 23:57:24 -08:00
|
|
|
*/
|
2011-09-01 12:20:30 -07:00
|
|
|
if (JSAtom *lambdaName = CallObjectLambdaName(fp->fun())) {
|
2011-03-14 11:30:36 -07:00
|
|
|
scopeChain = NewDeclEnvObject(cx, fp);
|
|
|
|
if (!scopeChain)
|
2009-04-22 23:22:42 -07:00
|
|
|
return NULL;
|
2009-04-16 15:26:26 -07:00
|
|
|
|
2011-01-21 05:10:16 -08:00
|
|
|
if (!DefineNativeProperty(cx, scopeChain, ATOM_TO_JSID(lambdaName),
|
2011-07-13 05:15:59 -07:00
|
|
|
ObjectValue(fp->callee()), NULL, NULL,
|
2011-01-21 05:10:16 -08:00
|
|
|
JSPROP_PERMANENT | JSPROP_READONLY, 0, 0)) {
|
2009-05-13 17:11:23 -07:00
|
|
|
return NULL;
|
|
|
|
}
|
2009-04-14 03:54:37 -07:00
|
|
|
}
|
2009-04-18 11:10:59 -07:00
|
|
|
|
2011-09-08 10:53:43 -07:00
|
|
|
CallObject *callobj = CallObject::create(cx, fp->script(), *scopeChain, &fp->callee());
|
2010-01-15 11:32:14 -08:00
|
|
|
if (!callobj)
|
2007-03-22 10:30:00 -07:00
|
|
|
return NULL;
|
2008-06-30 10:17:33 -07:00
|
|
|
|
2011-09-08 10:53:43 -07:00
|
|
|
callobj->setStackFrame(fp);
|
2011-03-14 11:30:36 -07:00
|
|
|
fp->setScopeChainWithOwnCallObj(*callobj);
|
|
|
|
return callobj;
|
|
|
|
}
|
2007-03-22 10:30:00 -07:00
|
|
|
|
2011-09-08 10:53:43 -07:00
|
|
|
CallObject *
|
2011-04-13 09:27:37 -07:00
|
|
|
CreateEvalCallObject(JSContext *cx, StackFrame *fp)
|
2011-03-14 11:30:36 -07:00
|
|
|
{
|
2011-09-08 10:53:43 -07:00
|
|
|
CallObject *callobj = CallObject::create(cx, fp->script(), fp->scopeChain(), NULL);
|
2011-03-14 11:30:36 -07:00
|
|
|
if (!callobj)
|
2011-04-14 13:45:06 -07:00
|
|
|
return NULL;
|
2011-03-14 11:30:36 -07:00
|
|
|
|
2011-09-08 10:53:43 -07:00
|
|
|
callobj->setStackFrame(fp);
|
2011-03-14 11:30:36 -07:00
|
|
|
fp->setScopeChainWithOwnCallObj(*callobj);
|
2007-03-22 10:30:00 -07:00
|
|
|
return callobj;
|
|
|
|
}
|
|
|
|
|
2011-03-14 11:30:36 -07:00
|
|
|
} // namespace js
|
|
|
|
|
2010-01-15 11:32:14 -08:00
|
|
|
JSObject * JS_FASTCALL
|
|
|
|
js_CreateCallObjectOnTrace(JSContext *cx, JSFunction *fun, JSObject *callee, JSObject *scopeChain)
|
|
|
|
{
|
|
|
|
JS_ASSERT(!js_IsNamedLambda(fun));
|
2010-08-09 22:43:33 -07:00
|
|
|
JS_ASSERT(scopeChain);
|
2010-10-12 11:38:06 -07:00
|
|
|
JS_ASSERT(callee);
|
2011-09-08 10:53:43 -07:00
|
|
|
return CallObject::create(cx, fun->script(), *scopeChain, callee);
|
2010-01-15 11:32:14 -08:00
|
|
|
}
|
|
|
|
|
2010-03-01 18:47:17 -08:00
|
|
|
JS_DEFINE_CALLINFO_4(extern, OBJECT, js_CreateCallObjectOnTrace, CONTEXT, FUNCTION, OBJECT, OBJECT,
|
2010-07-27 22:33:42 -07:00
|
|
|
0, nanojit::ACCSET_STORE_ANY)
|
2010-01-15 11:32:14 -08:00
|
|
|
|
2009-08-14 11:43:16 -07:00
|
|
|
void
|
2011-04-13 09:27:37 -07:00
|
|
|
js_PutCallObject(StackFrame *fp)
|
2007-03-22 10:30:00 -07:00
|
|
|
{
|
2011-09-08 10:53:43 -07:00
|
|
|
CallObject &callobj = fp->callObj().asCall();
|
|
|
|
JS_ASSERT(callobj.maybeStackFrame() == fp);
|
2011-03-14 11:30:36 -07:00
|
|
|
JS_ASSERT_IF(fp->isEvalFrame(), fp->isStrictEvalFrame());
|
2011-09-08 10:53:43 -07:00
|
|
|
JS_ASSERT(fp->isEvalFrame() == callobj.isForEval());
|
2011-01-05 12:54:04 -08:00
|
|
|
|
2009-08-14 11:43:16 -07:00
|
|
|
/* Get the arguments object to snapshot fp's actual argument values. */
|
2010-08-12 15:46:03 -07:00
|
|
|
if (fp->hasArgsObj()) {
|
2010-08-09 22:43:33 -07:00
|
|
|
if (!fp->hasOverriddenArgs())
|
2011-10-25 16:07:42 -07:00
|
|
|
callobj.initArguments(ObjectValue(fp->argsObj()));
|
2011-04-13 09:27:37 -07:00
|
|
|
js_PutArgsObject(fp);
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
|
|
|
|
2011-01-05 11:55:18 -08:00
|
|
|
JSScript *script = fp->script();
|
|
|
|
Bindings &bindings = script->bindings;
|
2010-11-16 15:34:24 -08:00
|
|
|
|
2011-09-08 10:53:43 -07:00
|
|
|
if (callobj.isForEval()) {
|
2011-01-05 12:54:04 -08:00
|
|
|
JS_ASSERT(script->strictModeCode);
|
|
|
|
JS_ASSERT(bindings.countArgs() == 0);
|
2009-08-04 03:55:58 -07:00
|
|
|
|
2011-01-05 12:54:04 -08:00
|
|
|
/* This could be optimized as below, but keep it simple for now. */
|
2011-09-08 10:53:43 -07:00
|
|
|
callobj.copyValues(0, NULL, bindings.countVars(), fp->slots());
|
2011-01-05 12:54:04 -08:00
|
|
|
} else {
|
2011-01-05 11:55:18 -08:00
|
|
|
JSFunction *fun = fp->fun();
|
2011-10-11 15:28:54 -07:00
|
|
|
JS_ASSERT(script == callobj.getCalleeFunction()->script());
|
2011-01-05 11:55:18 -08:00
|
|
|
JS_ASSERT(script == fun->script());
|
2010-08-27 15:54:30 -07:00
|
|
|
|
2011-01-10 20:33:53 -08:00
|
|
|
uintN n = bindings.countArgsAndVars();
|
|
|
|
if (n > 0) {
|
2011-01-05 11:55:18 -08:00
|
|
|
uint32 nvars = bindings.countVars();
|
|
|
|
uint32 nargs = bindings.countArgs();
|
|
|
|
JS_ASSERT(fun->nargs == nargs);
|
|
|
|
JS_ASSERT(nvars + nargs == n);
|
|
|
|
|
|
|
|
JSScript *script = fun->script();
|
|
|
|
if (script->usesEval
|
2010-10-02 01:21:17 -07:00
|
|
|
#ifdef JS_METHODJIT
|
2011-01-05 11:55:18 -08:00
|
|
|
|| script->debugMode
|
2010-10-02 01:21:17 -07:00
|
|
|
#endif
|
2011-01-05 11:55:18 -08:00
|
|
|
) {
|
2011-09-08 10:53:43 -07:00
|
|
|
callobj.copyValues(nargs, fp->formalArgs(), nvars, fp->slots());
|
2011-01-05 11:55:18 -08:00
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* For each arg & var that is closed over, copy it from the stack
|
2011-10-25 16:07:42 -07:00
|
|
|
* into the call object. We use initArg/VarUnchecked because,
|
|
|
|
* when you call a getter on a call object, js_NativeGetInline
|
|
|
|
* caches the return value in the slot, so we can't assert that
|
|
|
|
* it's undefined.
|
2011-01-05 11:55:18 -08:00
|
|
|
*/
|
|
|
|
uint32 nclosed = script->nClosedArgs;
|
|
|
|
for (uint32 i = 0; i < nclosed; i++) {
|
|
|
|
uint32 e = script->getClosedArg(i);
|
2011-08-05 10:25:23 -07:00
|
|
|
#ifdef JS_GC_ZEAL
|
2011-09-08 10:53:43 -07:00
|
|
|
callobj.setArg(e, fp->formalArg(e));
|
2011-08-05 10:25:23 -07:00
|
|
|
#else
|
2011-10-25 16:07:42 -07:00
|
|
|
callobj.initArgUnchecked(e, fp->formalArg(e));
|
2011-08-05 10:25:23 -07:00
|
|
|
#endif
|
2011-01-05 11:55:18 -08:00
|
|
|
}
|
2010-09-13 22:33:44 -07:00
|
|
|
|
2011-01-05 11:55:18 -08:00
|
|
|
nclosed = script->nClosedVars;
|
|
|
|
for (uint32 i = 0; i < nclosed; i++) {
|
|
|
|
uint32 e = script->getClosedVar(i);
|
2011-08-05 10:25:23 -07:00
|
|
|
#ifdef JS_GC_ZEAL
|
2011-09-08 10:53:43 -07:00
|
|
|
callobj.setVar(e, fp->slots()[e]);
|
2011-08-05 10:25:23 -07:00
|
|
|
#else
|
2011-10-25 16:07:42 -07:00
|
|
|
callobj.initVarUnchecked(e, fp->slots()[e]);
|
2011-08-05 10:25:23 -07:00
|
|
|
#endif
|
2011-01-05 11:55:18 -08:00
|
|
|
}
|
2010-08-27 15:54:30 -07:00
|
|
|
}
|
2011-09-03 11:04:45 -07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Update the args and vars for the active call if this is an outer
|
|
|
|
* function in a script nesting.
|
|
|
|
*/
|
|
|
|
types::TypeScriptNesting *nesting = script->nesting();
|
|
|
|
if (nesting && script->isOuterFunction) {
|
2011-09-08 10:53:43 -07:00
|
|
|
nesting->argArray = callobj.argArray();
|
|
|
|
nesting->varArray = callobj.varArray();
|
2011-09-03 11:04:45 -07:00
|
|
|
}
|
2010-08-27 15:54:30 -07:00
|
|
|
}
|
2008-06-30 10:17:33 -07:00
|
|
|
|
2011-09-02 17:23:26 -07:00
|
|
|
/* Clear private pointers to fp, which is about to go away. */
|
2011-01-05 11:55:18 -08:00
|
|
|
if (js_IsNamedLambda(fun)) {
|
2011-11-09 09:52:59 -08:00
|
|
|
JSObject *env = callobj.internalScopeChain();
|
2009-06-04 18:58:47 -07:00
|
|
|
|
2011-09-02 17:23:26 -07:00
|
|
|
JS_ASSERT(env->isDeclEnv());
|
2011-01-05 11:55:18 -08:00
|
|
|
JS_ASSERT(env->getPrivate() == fp);
|
|
|
|
env->setPrivate(NULL);
|
|
|
|
}
|
2009-06-04 18:58:47 -07:00
|
|
|
}
|
|
|
|
|
2011-09-08 10:53:43 -07:00
|
|
|
callobj.setStackFrame(NULL);
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
|
|
|
|
2010-01-15 11:32:14 -08:00
|
|
|
JSBool JS_FASTCALL
|
2011-09-08 10:53:43 -07:00
|
|
|
js_PutCallObjectOnTrace(JSObject *obj, uint32 nargs, Value *argv,
|
2010-07-14 23:19:36 -07:00
|
|
|
uint32 nvars, Value *slots)
|
2010-01-15 11:32:14 -08:00
|
|
|
{
|
2011-09-08 10:53:43 -07:00
|
|
|
CallObject &callobj = obj->asCall();
|
|
|
|
JS_ASSERT(!callobj.maybeStackFrame());
|
2010-01-15 11:32:14 -08:00
|
|
|
|
|
|
|
uintN n = nargs + nvars;
|
|
|
|
if (n != 0)
|
2011-09-08 10:53:43 -07:00
|
|
|
callobj.copyValues(nargs, argv, nvars, slots);
|
2010-01-15 11:32:14 -08:00
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2011-04-13 09:27:37 -07:00
|
|
|
JS_DEFINE_CALLINFO_5(extern, BOOL, js_PutCallObjectOnTrace, OBJECT, UINT32, VALUEPTR,
|
2010-07-27 22:33:42 -07:00
|
|
|
UINT32, VALUEPTR, 0, nanojit::ACCSET_STORE_ANY)
|
2010-01-15 11:32:14 -08:00
|
|
|
|
2010-12-29 20:21:18 -08:00
|
|
|
namespace js {
|
2008-03-29 08:48:41 -07:00
|
|
|
|
|
|
|
static JSBool
|
2010-12-29 20:21:18 -08:00
|
|
|
GetCallArguments(JSContext *cx, JSObject *obj, jsid id, Value *vp)
|
2008-03-29 08:48:41 -07:00
|
|
|
{
|
2011-09-08 10:53:43 -07:00
|
|
|
CallObject &callobj = obj->asCall();
|
|
|
|
|
|
|
|
StackFrame *fp = callobj.maybeStackFrame();
|
2010-12-29 20:21:18 -08:00
|
|
|
if (fp && !fp->hasOverriddenArgs()) {
|
|
|
|
JSObject *argsobj = js_GetArgsObject(cx, fp);
|
|
|
|
if (!argsobj)
|
|
|
|
return false;
|
|
|
|
vp->setObject(*argsobj);
|
2009-02-25 11:09:21 -08:00
|
|
|
} else {
|
2011-09-08 10:53:43 -07:00
|
|
|
*vp = callobj.getArguments();
|
2009-02-25 11:09:21 -08:00
|
|
|
}
|
2010-03-02 17:30:54 -08:00
|
|
|
return true;
|
2008-03-29 08:48:41 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static JSBool
|
2011-02-09 11:31:40 -08:00
|
|
|
SetCallArguments(JSContext *cx, JSObject *obj, jsid id, JSBool strict, Value *vp)
|
2008-03-29 08:48:41 -07:00
|
|
|
{
|
2011-09-08 10:53:43 -07:00
|
|
|
CallObject &callobj = obj->asCall();
|
|
|
|
|
|
|
|
if (StackFrame *fp = callobj.maybeStackFrame())
|
2010-12-29 20:21:18 -08:00
|
|
|
fp->setOverriddenArgs();
|
2011-09-08 10:53:43 -07:00
|
|
|
callobj.setArguments(*vp);
|
2010-12-29 20:21:18 -08:00
|
|
|
return true;
|
2008-03-29 08:48:41 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
JSBool
|
2010-11-16 15:30:57 -08:00
|
|
|
GetCallArg(JSContext *cx, JSObject *obj, jsid id, Value *vp)
|
2008-03-29 08:48:41 -07:00
|
|
|
{
|
2011-09-08 10:53:43 -07:00
|
|
|
CallObject &callobj = obj->asCall();
|
2010-12-29 20:21:18 -08:00
|
|
|
JS_ASSERT((int16) JSID_TO_INT(id) == JSID_TO_INT(id));
|
|
|
|
uintN i = (uint16) JSID_TO_INT(id);
|
|
|
|
|
2011-09-08 10:53:43 -07:00
|
|
|
if (StackFrame *fp = callobj.maybeStackFrame())
|
2010-12-29 20:21:18 -08:00
|
|
|
*vp = fp->formalArg(i);
|
|
|
|
else
|
2011-09-08 10:53:43 -07:00
|
|
|
*vp = callobj.arg(i);
|
2010-12-29 20:21:18 -08:00
|
|
|
return true;
|
2008-03-29 08:48:41 -07:00
|
|
|
}
|
|
|
|
|
2009-07-27 18:13:53 -07:00
|
|
|
JSBool
|
2011-02-09 11:31:40 -08:00
|
|
|
SetCallArg(JSContext *cx, JSObject *obj, jsid id, JSBool strict, Value *vp)
|
2008-03-29 08:48:41 -07:00
|
|
|
{
|
2011-09-08 10:53:43 -07:00
|
|
|
CallObject &callobj = obj->asCall();
|
2010-12-29 20:21:18 -08:00
|
|
|
JS_ASSERT((int16) JSID_TO_INT(id) == JSID_TO_INT(id));
|
|
|
|
uintN i = (uint16) JSID_TO_INT(id);
|
|
|
|
|
2011-09-08 10:53:43 -07:00
|
|
|
if (StackFrame *fp = callobj.maybeStackFrame())
|
2011-07-13 15:43:33 -07:00
|
|
|
fp->formalArg(i) = *vp;
|
2010-12-29 20:21:18 -08:00
|
|
|
else
|
2011-09-08 10:53:43 -07:00
|
|
|
callobj.setArg(i, *vp);
|
2010-12-29 20:21:18 -08:00
|
|
|
|
2011-09-08 10:53:43 -07:00
|
|
|
JSFunction *fun = callobj.getCalleeFunction();
|
2011-09-01 12:20:30 -07:00
|
|
|
JSScript *script = fun->script();
|
2011-10-21 14:31:01 -07:00
|
|
|
if (!script->ensureHasTypes(cx))
|
2011-09-01 12:20:30 -07:00
|
|
|
return false;
|
|
|
|
|
2011-07-28 09:16:53 -07:00
|
|
|
TypeScript::SetArgument(cx, script, i, *vp);
|
2011-02-24 21:21:43 -08:00
|
|
|
|
2010-12-29 20:21:18 -08:00
|
|
|
return true;
|
2010-03-02 17:30:54 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
JSBool
|
2010-12-29 23:46:50 -08:00
|
|
|
GetCallUpvar(JSContext *cx, JSObject *obj, jsid id, Value *vp)
|
2010-03-02 17:30:54 -08:00
|
|
|
{
|
2011-09-08 10:53:43 -07:00
|
|
|
CallObject &callobj = obj->asCall();
|
2010-12-29 20:21:18 -08:00
|
|
|
JS_ASSERT((int16) JSID_TO_INT(id) == JSID_TO_INT(id));
|
|
|
|
uintN i = (uint16) JSID_TO_INT(id);
|
|
|
|
|
2011-10-26 13:02:57 -07:00
|
|
|
*vp = callobj.getCallee()->toFunction()->getFlatClosureUpvar(i);
|
2010-12-29 20:21:18 -08:00
|
|
|
return true;
|
2010-03-02 17:30:54 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
JSBool
|
2011-02-09 11:31:40 -08:00
|
|
|
SetCallUpvar(JSContext *cx, JSObject *obj, jsid id, JSBool strict, Value *vp)
|
2010-03-02 17:30:54 -08:00
|
|
|
{
|
2011-09-08 10:53:43 -07:00
|
|
|
CallObject &callobj = obj->asCall();
|
2010-12-29 20:21:18 -08:00
|
|
|
JS_ASSERT((int16) JSID_TO_INT(id) == JSID_TO_INT(id));
|
|
|
|
uintN i = (uint16) JSID_TO_INT(id);
|
|
|
|
|
2011-10-26 13:02:57 -07:00
|
|
|
callobj.getCallee()->toFunction()->setFlatClosureUpvar(i, *vp);
|
2010-12-29 20:21:18 -08:00
|
|
|
return true;
|
2008-03-29 08:48:41 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
JSBool
|
2010-11-16 15:30:57 -08:00
|
|
|
GetCallVar(JSContext *cx, JSObject *obj, jsid id, Value *vp)
|
2009-06-09 00:51:02 -07:00
|
|
|
{
|
2011-09-08 10:53:43 -07:00
|
|
|
CallObject &callobj = obj->asCall();
|
2010-12-29 20:21:18 -08:00
|
|
|
JS_ASSERT((int16) JSID_TO_INT(id) == JSID_TO_INT(id));
|
|
|
|
uintN i = (uint16) JSID_TO_INT(id);
|
|
|
|
|
2011-09-08 10:53:43 -07:00
|
|
|
if (StackFrame *fp = callobj.maybeStackFrame())
|
2010-12-29 20:21:18 -08:00
|
|
|
*vp = fp->varSlot(i);
|
|
|
|
else
|
2011-09-08 10:53:43 -07:00
|
|
|
*vp = callobj.var(i);
|
2010-12-29 20:21:18 -08:00
|
|
|
return true;
|
2009-06-09 00:51:02 -07:00
|
|
|
}
|
|
|
|
|
2009-07-27 18:13:53 -07:00
|
|
|
JSBool
|
2011-02-09 11:31:40 -08:00
|
|
|
SetCallVar(JSContext *cx, JSObject *obj, jsid id, JSBool strict, Value *vp)
|
2008-03-29 08:48:41 -07:00
|
|
|
{
|
2011-09-08 10:53:43 -07:00
|
|
|
CallObject &callobj = obj->asCall();
|
2010-12-29 20:21:18 -08:00
|
|
|
|
|
|
|
JS_ASSERT((int16) JSID_TO_INT(id) == JSID_TO_INT(id));
|
|
|
|
uintN i = (uint16) JSID_TO_INT(id);
|
|
|
|
|
2011-01-05 15:21:59 -08:00
|
|
|
/*
|
|
|
|
* As documented in TraceRecorder::attemptTreeCall(), when recording an
|
|
|
|
* inner tree call, the recorder assumes the inner tree does not mutate
|
|
|
|
* any tracked upvars. The abort here is a pessimistic precaution against
|
|
|
|
* bug 620662, where an inner tree setting a closed stack variable in an
|
|
|
|
* outer tree is illegal, and runtime would fall off trace.
|
|
|
|
*/
|
|
|
|
#ifdef JS_TRACER
|
2011-02-01 10:18:06 -08:00
|
|
|
if (JS_ON_TRACE(cx)) {
|
|
|
|
TraceMonitor *tm = JS_TRACE_MONITOR_ON_TRACE(cx);
|
|
|
|
if (tm->recorder && tm->tracecx)
|
|
|
|
AbortRecording(cx, "upvar write in nested tree");
|
|
|
|
}
|
2011-01-05 15:21:59 -08:00
|
|
|
#endif
|
|
|
|
|
2011-09-08 10:53:43 -07:00
|
|
|
if (StackFrame *fp = callobj.maybeStackFrame())
|
2011-07-13 15:43:33 -07:00
|
|
|
fp->varSlot(i) = *vp;
|
2010-12-29 20:21:18 -08:00
|
|
|
else
|
2011-09-08 10:53:43 -07:00
|
|
|
callobj.setVar(i, *vp);
|
2010-12-29 20:21:18 -08:00
|
|
|
|
2011-09-08 10:53:43 -07:00
|
|
|
JSFunction *fun = callobj.getCalleeFunction();
|
2011-09-01 12:20:30 -07:00
|
|
|
JSScript *script = fun->script();
|
2011-10-21 14:31:01 -07:00
|
|
|
if (!script->ensureHasTypes(cx))
|
2011-09-01 12:20:30 -07:00
|
|
|
return false;
|
|
|
|
|
2011-07-28 09:16:53 -07:00
|
|
|
TypeScript::SetLocal(cx, script, i, *vp);
|
2011-02-24 21:21:43 -08:00
|
|
|
|
2010-12-29 20:21:18 -08:00
|
|
|
return true;
|
2008-03-29 08:48:41 -07:00
|
|
|
}
|
|
|
|
|
2010-11-16 15:30:57 -08:00
|
|
|
} // namespace js
|
|
|
|
|
2010-07-14 23:19:36 -07:00
|
|
|
#if JS_TRACER
|
2009-07-27 18:13:53 -07:00
|
|
|
JSBool JS_FASTCALL
|
2010-07-14 23:19:36 -07:00
|
|
|
js_SetCallArg(JSContext *cx, JSObject *obj, jsid slotid, ValueArgType arg)
|
2009-07-27 18:13:53 -07:00
|
|
|
{
|
2010-07-14 23:19:36 -07:00
|
|
|
Value argcopy = ValueArgToConstRef(arg);
|
2011-02-09 11:31:40 -08:00
|
|
|
return SetCallArg(cx, obj, slotid, false /* STRICT DUMMY */, &argcopy);
|
2009-07-27 18:13:53 -07:00
|
|
|
}
|
2010-07-14 23:19:36 -07:00
|
|
|
JS_DEFINE_CALLINFO_4(extern, BOOL, js_SetCallArg, CONTEXT, OBJECT, JSID, VALUE, 0,
|
2010-07-27 22:33:42 -07:00
|
|
|
nanojit::ACCSET_STORE_ANY)
|
2009-07-27 18:13:53 -07:00
|
|
|
|
|
|
|
JSBool JS_FASTCALL
|
2010-07-14 23:19:36 -07:00
|
|
|
js_SetCallVar(JSContext *cx, JSObject *obj, jsid slotid, ValueArgType arg)
|
2009-07-27 18:13:53 -07:00
|
|
|
{
|
2010-07-14 23:19:36 -07:00
|
|
|
Value argcopy = ValueArgToConstRef(arg);
|
2011-02-09 11:31:40 -08:00
|
|
|
return SetCallVar(cx, obj, slotid, false /* STRICT DUMMY */, &argcopy);
|
2009-07-27 18:13:53 -07:00
|
|
|
}
|
2010-07-14 23:19:36 -07:00
|
|
|
JS_DEFINE_CALLINFO_4(extern, BOOL, js_SetCallVar, CONTEXT, OBJECT, JSID, VALUE, 0,
|
2010-07-27 22:33:42 -07:00
|
|
|
nanojit::ACCSET_STORE_ANY)
|
2010-07-14 23:19:36 -07:00
|
|
|
#endif
|
2009-07-27 18:13:53 -07:00
|
|
|
|
2007-03-22 10:30:00 -07:00
|
|
|
static JSBool
|
2011-09-08 10:53:43 -07:00
|
|
|
call_resolve(JSContext *cx, JSObject *obj, jsid id, uintN flags, JSObject **objp)
|
2007-03-22 10:30:00 -07:00
|
|
|
{
|
2010-03-04 20:44:09 -08:00
|
|
|
JS_ASSERT(!obj->getProto());
|
2009-05-15 02:43:19 -07:00
|
|
|
|
2010-07-14 23:19:36 -07:00
|
|
|
if (!JSID_IS_ATOM(id))
|
2010-10-12 11:38:06 -07:00
|
|
|
return true;
|
2007-03-22 10:30:00 -07:00
|
|
|
|
2011-09-08 10:53:43 -07:00
|
|
|
JSObject *callee = obj->asCall().getCallee();
|
2010-08-29 11:57:08 -07:00
|
|
|
#ifdef DEBUG
|
2010-10-12 11:38:06 -07:00
|
|
|
if (callee) {
|
2011-10-11 15:28:54 -07:00
|
|
|
JSScript *script = callee->toFunction()->script();
|
2010-10-12 11:38:06 -07:00
|
|
|
JS_ASSERT(!script->bindings.hasBinding(cx, JSID_TO_ATOM(id)));
|
|
|
|
}
|
2010-08-29 11:57:08 -07:00
|
|
|
#endif
|
2007-03-22 10:30:00 -07:00
|
|
|
|
2007-12-11 13:40:51 -08:00
|
|
|
/*
|
|
|
|
* Resolve arguments so that we never store a particular Call object's
|
|
|
|
* arguments object reference in a Call prototype's |arguments| slot.
|
2010-10-07 13:52:58 -07:00
|
|
|
*
|
|
|
|
* Include JSPROP_ENUMERATE for consistency with all other Call object
|
2010-11-16 15:34:24 -08:00
|
|
|
* properties; see js::Bindings::add and js::Interpret's JSOP_DEFFUN
|
2010-10-07 13:52:58 -07:00
|
|
|
* rebinding-Call-property logic.
|
2007-12-11 13:40:51 -08:00
|
|
|
*/
|
2010-10-12 11:38:06 -07:00
|
|
|
if (callee && id == ATOM_TO_JSID(cx->runtime->atomState.argumentsAtom)) {
|
2011-01-21 05:10:16 -08:00
|
|
|
if (!DefineNativeProperty(cx, obj, id, UndefinedValue(),
|
|
|
|
GetCallArguments, SetCallArguments,
|
|
|
|
JSPROP_PERMANENT | JSPROP_SHARED | JSPROP_ENUMERATE,
|
|
|
|
0, 0, DNP_DONT_PURGE)) {
|
2010-10-12 11:38:06 -07:00
|
|
|
return false;
|
2007-06-15 17:29:21 -07:00
|
|
|
}
|
2007-12-11 13:40:51 -08:00
|
|
|
*objp = obj;
|
2010-10-12 11:38:06 -07:00
|
|
|
return true;
|
2007-06-15 17:29:21 -07:00
|
|
|
}
|
2009-04-05 21:17:22 -07:00
|
|
|
|
|
|
|
/* Control flow reaches here only if id was not resolved. */
|
2010-10-12 11:38:06 -07:00
|
|
|
return true;
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
|
|
|
|
2010-08-29 11:57:08 -07:00
|
|
|
static void
|
|
|
|
call_trace(JSTracer *trc, JSObject *obj)
|
|
|
|
{
|
|
|
|
JS_ASSERT(obj->isCall());
|
|
|
|
|
2011-11-18 12:54:40 -08:00
|
|
|
/* Mark any generator frame, as for arguments objects. */
|
|
|
|
#if JS_HAS_GENERATORS
|
|
|
|
StackFrame *fp = (StackFrame *) obj->getPrivate();
|
|
|
|
if (fp && fp->isFloatingGenerator())
|
|
|
|
MarkObject(trc, js_FloatingFrameToGenerator(fp)->obj, "generator object");
|
|
|
|
#endif
|
2010-08-29 11:57:08 -07:00
|
|
|
}
|
|
|
|
|
2011-09-02 17:23:26 -07:00
|
|
|
JS_PUBLIC_DATA(Class) js::CallClass = {
|
2009-04-18 11:10:59 -07:00
|
|
|
"Call",
|
2008-06-30 10:17:33 -07:00
|
|
|
JSCLASS_HAS_PRIVATE |
|
2011-09-08 10:53:43 -07:00
|
|
|
JSCLASS_HAS_RESERVED_SLOTS(CallObject::RESERVED_SLOTS) |
|
2011-03-05 14:50:11 -08:00
|
|
|
JSCLASS_NEW_RESOLVE | JSCLASS_IS_ANONYMOUS,
|
2011-09-20 11:40:24 -07:00
|
|
|
JS_PropertyStub, /* addProperty */
|
|
|
|
JS_PropertyStub, /* delProperty */
|
|
|
|
JS_PropertyStub, /* getProperty */
|
|
|
|
JS_StrictPropertyStub, /* setProperty */
|
2010-08-29 11:57:08 -07:00
|
|
|
JS_EnumerateStub,
|
2010-06-12 09:29:04 -07:00
|
|
|
(JSResolveOp)call_resolve,
|
2011-09-20 11:40:24 -07:00
|
|
|
NULL, /* convert: Leave it NULL so we notice if calls ever escape */
|
|
|
|
NULL, /* finalize */
|
|
|
|
NULL, /* reserved0 */
|
|
|
|
NULL, /* checkAccess */
|
|
|
|
NULL, /* call */
|
|
|
|
NULL, /* construct */
|
|
|
|
NULL, /* xdrObject */
|
|
|
|
NULL, /* hasInstance */
|
2011-03-05 14:50:11 -08:00
|
|
|
call_trace
|
2007-03-22 10:30:00 -07:00
|
|
|
};
|
|
|
|
|
2010-07-23 14:41:56 -07:00
|
|
|
bool
|
2011-04-13 09:27:37 -07:00
|
|
|
StackFrame::getValidCalleeObject(JSContext *cx, Value *vp)
|
2010-07-23 14:41:56 -07:00
|
|
|
{
|
2010-08-09 22:43:33 -07:00
|
|
|
if (!isFunctionFrame()) {
|
2011-06-27 15:57:50 -07:00
|
|
|
vp->setNull();
|
2010-07-23 14:41:56 -07:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2011-10-20 14:56:24 -07:00
|
|
|
JSFunction *fun = this->callee().toFunction();
|
2011-10-11 15:28:54 -07:00
|
|
|
vp->setObject(*fun);
|
2010-07-23 14:41:56 -07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Check for an escape attempt by a joined function object, which must go
|
|
|
|
* through the frame's |this| object's method read barrier for the method
|
|
|
|
* atom by which it was uniquely associated with a property.
|
|
|
|
*/
|
2010-08-09 22:43:33 -07:00
|
|
|
const Value &thisv = functionThis();
|
2011-10-11 15:28:54 -07:00
|
|
|
if (thisv.isObject() && fun->methodAtom() && !fun->isClonedMethod()) {
|
|
|
|
JSObject *thisp = &thisv.toObject();
|
|
|
|
JSObject *first_barriered_thisp = NULL;
|
2010-07-23 14:41:56 -07:00
|
|
|
|
2011-10-11 15:28:54 -07:00
|
|
|
do {
|
|
|
|
/*
|
|
|
|
* While a non-native object is responsible for handling its
|
|
|
|
* entire prototype chain, notable non-natives including dense
|
|
|
|
* and typed arrays have native prototypes, so keep going.
|
|
|
|
*/
|
|
|
|
if (!thisp->isNative())
|
|
|
|
continue;
|
2010-07-23 14:41:56 -07:00
|
|
|
|
2011-10-11 15:28:54 -07:00
|
|
|
const Shape *shape = thisp->nativeLookup(cx, ATOM_TO_JSID(fun->methodAtom()));
|
|
|
|
if (shape) {
|
2010-07-23 14:41:56 -07:00
|
|
|
/*
|
2011-10-11 15:28:54 -07:00
|
|
|
* Two cases follow: the method barrier was not crossed
|
|
|
|
* yet, so we cross it here; the method barrier *was*
|
|
|
|
* crossed but after the call, in which case we fetch
|
|
|
|
* and validate the cloned (unjoined) funobj from the
|
|
|
|
* method property's slot.
|
|
|
|
*
|
|
|
|
* In either case we must allow for the method property
|
|
|
|
* to have been replaced, or its value overwritten.
|
2010-07-23 14:41:56 -07:00
|
|
|
*/
|
2011-10-11 15:28:54 -07:00
|
|
|
if (shape->isMethod() && thisp->nativeGetMethod(shape) == fun) {
|
|
|
|
if (!thisp->methodReadBarrier(cx, *shape, vp))
|
|
|
|
return false;
|
|
|
|
overwriteCallee(vp->toObject());
|
|
|
|
return true;
|
|
|
|
}
|
2011-01-04 12:27:18 -08:00
|
|
|
|
2011-10-11 15:28:54 -07:00
|
|
|
if (shape->hasSlot()) {
|
|
|
|
Value v = thisp->getSlot(shape->slot());
|
|
|
|
JSFunction *clone;
|
|
|
|
|
|
|
|
if (IsFunctionObject(v, &clone) &&
|
|
|
|
clone->script() == fun->script() &&
|
2011-10-26 13:02:57 -07:00
|
|
|
clone->methodObj() == thisp) {
|
2011-10-11 15:28:54 -07:00
|
|
|
/*
|
|
|
|
* N.B. If the method barrier was on a function
|
|
|
|
* with singleton type, then while crossing the
|
|
|
|
* method barrier CloneFunctionObject will have
|
|
|
|
* ignored the attempt to clone the function.
|
|
|
|
*/
|
|
|
|
JS_ASSERT_IF(!clone->hasSingletonType(), clone != fun);
|
|
|
|
*vp = v;
|
|
|
|
overwriteCallee(*clone);
|
|
|
|
return true;
|
2010-07-23 14:41:56 -07:00
|
|
|
}
|
|
|
|
}
|
2011-10-11 15:28:54 -07:00
|
|
|
}
|
2010-07-23 14:41:56 -07:00
|
|
|
|
2011-01-04 12:27:18 -08:00
|
|
|
if (!first_barriered_thisp)
|
2011-10-11 15:28:54 -07:00
|
|
|
first_barriered_thisp = thisp;
|
|
|
|
} while ((thisp = thisp->getProto()) != NULL);
|
2011-01-04 12:27:18 -08:00
|
|
|
|
2011-10-11 15:28:54 -07:00
|
|
|
if (!first_barriered_thisp)
|
2011-01-04 12:27:18 -08:00
|
|
|
return true;
|
2011-10-11 15:28:54 -07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* At this point, we couldn't find an already-existing clone (or
|
|
|
|
* force to exist a fresh clone) created via thisp's method read
|
|
|
|
* barrier, so we must clone fun and store it in fp's callee to
|
|
|
|
* avoid re-cloning upon repeated foo.caller access.
|
|
|
|
*
|
|
|
|
* This must mean the code in js_DeleteProperty could not find this
|
|
|
|
* stack frame on the stack when the method was deleted. We've lost
|
|
|
|
* track of the method, so we associate it with the first barriered
|
|
|
|
* object found starting from thisp on the prototype chain.
|
|
|
|
*/
|
|
|
|
JSFunction *newfunobj = CloneFunctionObject(cx, fun);
|
|
|
|
if (!newfunobj)
|
|
|
|
return false;
|
|
|
|
newfunobj->setMethodObj(*first_barriered_thisp);
|
|
|
|
overwriteCallee(*newfunobj);
|
|
|
|
vp->setObject(*newfunobj);
|
|
|
|
return true;
|
2010-07-23 14:41:56 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2007-03-22 10:30:00 -07:00
|
|
|
static JSBool
|
2010-07-14 23:19:36 -07:00
|
|
|
fun_getProperty(JSContext *cx, JSObject *obj, jsid id, Value *vp)
|
2007-03-22 10:30:00 -07:00
|
|
|
{
|
2011-04-11 01:38:27 -07:00
|
|
|
while (!obj->isFunction()) {
|
2010-03-04 20:44:09 -08:00
|
|
|
obj = obj->getProto();
|
2007-03-22 10:30:00 -07:00
|
|
|
if (!obj)
|
2010-07-23 14:41:56 -07:00
|
|
|
return true;
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
2011-10-11 15:28:54 -07:00
|
|
|
JSFunction *fun = obj->toFunction();
|
2007-03-22 10:30:00 -07:00
|
|
|
|
2011-07-01 16:24:32 -07:00
|
|
|
/*
|
|
|
|
* Mark the function's script as uninlineable, to expand any of its
|
|
|
|
* frames on the stack before we go looking for them. This allows the
|
|
|
|
* below walk to only check each explicit frame rather than needing to
|
|
|
|
* check any calls that were inlined.
|
|
|
|
*/
|
2011-07-21 07:28:01 -07:00
|
|
|
if (fun->isInterpreted()) {
|
|
|
|
fun->script()->uninlineable = true;
|
2011-07-15 10:14:07 -07:00
|
|
|
MarkTypeObjectFlags(cx, fun, OBJECT_FLAG_UNINLINEABLE);
|
2011-07-21 07:28:01 -07:00
|
|
|
}
|
2011-07-01 16:24:32 -07:00
|
|
|
|
2011-06-17 15:55:55 -07:00
|
|
|
/* Set to early to null in case of error */
|
|
|
|
vp->setNull();
|
2011-03-26 19:07:13 -07:00
|
|
|
|
2007-03-22 10:30:00 -07:00
|
|
|
/* Find fun's top-most activation record. */
|
2011-07-01 16:24:32 -07:00
|
|
|
StackFrame *fp = js_GetTopStackFrame(cx, FRAME_EXPAND_NONE);
|
2011-06-27 13:36:11 -07:00
|
|
|
if (!fp)
|
|
|
|
return true;
|
|
|
|
|
2011-10-13 17:21:56 -07:00
|
|
|
while (!fp->isFunctionFrame() || fp->fun() != fun || fp->isEvalFrame()) {
|
2011-05-13 08:56:26 -07:00
|
|
|
fp = fp->prev();
|
2011-06-17 15:55:55 -07:00
|
|
|
if (!fp)
|
2011-06-24 14:26:00 -07:00
|
|
|
return true;
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
|
|
|
|
2011-03-26 19:07:13 -07:00
|
|
|
#ifdef JS_METHODJIT
|
2011-07-01 16:24:32 -07:00
|
|
|
if (JSID_IS_ATOM(id, cx->runtime->atomState.callerAtom) && fp && fp->prev()) {
|
2011-06-05 22:39:45 -07:00
|
|
|
/*
|
|
|
|
* If the frame was called from within an inlined frame, mark the
|
|
|
|
* innermost function as uninlineable to expand its frame and allow us
|
|
|
|
* to recover its callee object.
|
|
|
|
*/
|
2011-03-26 19:07:13 -07:00
|
|
|
JSInlinedSite *inlined;
|
2011-06-07 17:44:07 -07:00
|
|
|
fp->prev()->pcQuadratic(cx->stack, fp, &inlined);
|
2011-03-26 19:07:13 -07:00
|
|
|
if (inlined) {
|
|
|
|
JSFunction *fun = fp->prev()->jit()->inlineFrames()[inlined->inlineIndex].fun;
|
2011-07-21 07:28:01 -07:00
|
|
|
fun->script()->uninlineable = true;
|
2011-07-15 10:14:07 -07:00
|
|
|
MarkTypeObjectFlags(cx, fun, OBJECT_FLAG_UNINLINEABLE);
|
2011-03-26 19:07:13 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2011-06-17 15:55:55 -07:00
|
|
|
if (JSID_IS_ATOM(id, cx->runtime->atomState.argumentsAtom)) {
|
2007-03-22 10:30:00 -07:00
|
|
|
/* Warn if strict about f.arguments or equivalent unqualified uses. */
|
2011-06-24 14:26:00 -07:00
|
|
|
if (!JS_ReportErrorFlagsAndNumber(cx, JSREPORT_WARNING | JSREPORT_STRICT, js_GetErrorMessage,
|
2011-06-17 15:55:55 -07:00
|
|
|
NULL, JSMSG_DEPRECATED_USAGE, js_arguments_str)) {
|
2010-07-23 14:41:56 -07:00
|
|
|
return false;
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
|
|
|
|
2011-06-27 15:57:50 -07:00
|
|
|
return js_GetArgsValue(cx, fp, vp);
|
|
|
|
}
|
2007-03-22 10:30:00 -07:00
|
|
|
|
2011-06-27 15:57:50 -07:00
|
|
|
if (JSID_IS_ATOM(id, cx->runtime->atomState.callerAtom)) {
|
2011-06-17 15:55:55 -07:00
|
|
|
if (!fp->prev())
|
2011-06-24 14:26:00 -07:00
|
|
|
return true;
|
2011-05-11 14:06:33 -07:00
|
|
|
|
2011-06-17 15:55:55 -07:00
|
|
|
StackFrame *frame = js_GetScriptedCaller(cx, fp->prev());
|
2011-06-24 14:26:00 -07:00
|
|
|
if (frame && !frame->getValidCalleeObject(cx, vp))
|
2010-07-23 14:41:56 -07:00
|
|
|
return false;
|
2010-06-30 16:09:38 -07:00
|
|
|
|
2011-06-27 15:57:50 -07:00
|
|
|
if (!vp->isObject()) {
|
|
|
|
JS_ASSERT(vp->isNull());
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Censor the caller if it is from another compartment. */
|
|
|
|
JSObject &caller = vp->toObject();
|
|
|
|
if (caller.compartment() != cx->compartment) {
|
|
|
|
vp->setNull();
|
|
|
|
} else if (caller.isFunction()) {
|
2011-10-11 15:28:54 -07:00
|
|
|
JSFunction *callerFun = caller.toFunction();
|
2011-06-27 15:57:50 -07:00
|
|
|
if (callerFun->isInterpreted() && callerFun->inStrictMode()) {
|
|
|
|
JS_ReportErrorFlagsAndNumber(cx, JSREPORT_ERROR, js_GetErrorMessage, NULL,
|
|
|
|
JSMSG_CALLER_IS_STRICT);
|
|
|
|
return false;
|
2010-08-21 15:24:56 -07:00
|
|
|
}
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
|
|
|
|
2011-06-27 15:57:50 -07:00
|
|
|
return true;
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
|
|
|
|
2011-06-27 15:57:50 -07:00
|
|
|
JS_NOT_REACHED("fun_getProperty");
|
|
|
|
return false;
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
|
|
|
|
2010-08-02 23:52:12 -07:00
|
|
|
|
2008-09-04 21:56:37 -07:00
|
|
|
|
2011-10-10 23:00:28 -07:00
|
|
|
/* NB: no sentinels at ends -- use ArrayLength to bound loops.
|
2011-06-17 15:55:55 -07:00
|
|
|
* Properties censored into [[ThrowTypeError]] in strict mode. */
|
|
|
|
static const uint16 poisonPillProps[] = {
|
|
|
|
ATOM_OFFSET(arguments),
|
|
|
|
ATOM_OFFSET(caller),
|
2010-08-02 23:52:12 -07:00
|
|
|
};
|
|
|
|
|
2009-09-24 14:33:14 -07:00
|
|
|
static JSBool
|
|
|
|
fun_enumerate(JSContext *cx, JSObject *obj)
|
|
|
|
{
|
|
|
|
JS_ASSERT(obj->isFunction());
|
|
|
|
|
2010-08-13 10:42:33 -07:00
|
|
|
jsid id;
|
2010-08-29 11:57:08 -07:00
|
|
|
bool found;
|
2010-08-13 10:42:33 -07:00
|
|
|
|
2010-09-16 19:31:11 -07:00
|
|
|
if (!obj->isBoundFunction()) {
|
2010-08-13 10:42:33 -07:00
|
|
|
id = ATOM_TO_JSID(cx->runtime->atomState.classPrototypeAtom);
|
2010-08-29 11:57:08 -07:00
|
|
|
if (!obj->hasProperty(cx, id, &found, JSRESOLVE_QUALIFIED))
|
2010-08-13 10:42:33 -07:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2009-09-24 14:33:14 -07:00
|
|
|
id = ATOM_TO_JSID(cx->runtime->atomState.lengthAtom);
|
2010-08-29 11:57:08 -07:00
|
|
|
if (!obj->hasProperty(cx, id, &found, JSRESOLVE_QUALIFIED))
|
2009-09-24 14:33:14 -07:00
|
|
|
return false;
|
2011-06-17 15:55:55 -07:00
|
|
|
|
|
|
|
id = ATOM_TO_JSID(cx->runtime->atomState.nameAtom);
|
|
|
|
if (!obj->hasProperty(cx, id, &found, JSRESOLVE_QUALIFIED))
|
|
|
|
return false;
|
2009-09-24 14:33:14 -07:00
|
|
|
|
2011-10-10 23:00:28 -07:00
|
|
|
for (uintN i = 0; i < ArrayLength(poisonPillProps); i++) {
|
2011-06-17 15:55:55 -07:00
|
|
|
const uint16 offset = poisonPillProps[i];
|
|
|
|
id = ATOM_TO_JSID(OFFSET_TO_ATOM(cx->runtime, offset));
|
2010-08-29 11:57:08 -07:00
|
|
|
if (!obj->hasProperty(cx, id, &found, JSRESOLVE_QUALIFIED))
|
2010-08-02 23:52:12 -07:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2009-09-24 14:33:14 -07:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2011-02-14 12:04:07 -08:00
|
|
|
static JSObject *
|
|
|
|
ResolveInterpretedFunctionPrototype(JSContext *cx, JSObject *obj)
|
|
|
|
{
|
2011-02-15 12:07:23 -08:00
|
|
|
#ifdef DEBUG
|
2011-10-11 15:28:54 -07:00
|
|
|
JSFunction *fun = obj->toFunction();
|
2011-02-14 12:04:07 -08:00
|
|
|
JS_ASSERT(fun->isInterpreted());
|
|
|
|
JS_ASSERT(!fun->isFunctionPrototype());
|
2011-02-15 12:07:23 -08:00
|
|
|
#endif
|
2011-02-14 12:04:07 -08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Assert that fun is not a compiler-created function object, which
|
|
|
|
* must never leak to script or embedding code and then be mutated.
|
|
|
|
* Also assert that obj is not bound, per the ES5 15.3.4.5 ref above.
|
|
|
|
*/
|
|
|
|
JS_ASSERT(!IsInternalFunctionObject(obj));
|
|
|
|
JS_ASSERT(!obj->isBoundFunction());
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Make the prototype object an instance of Object with the same parent
|
|
|
|
* as the function object itself.
|
|
|
|
*/
|
2011-02-24 21:21:43 -08:00
|
|
|
JSObject *objProto;
|
2011-10-13 20:21:36 -07:00
|
|
|
if (!js_GetClassPrototype(cx, obj->getParent(), JSProto_Object, &objProto))
|
2011-02-14 12:04:07 -08:00
|
|
|
return NULL;
|
2011-11-02 13:34:19 -07:00
|
|
|
JSObject *proto = NewObjectWithGivenProto(cx, &ObjectClass, objProto, NULL);
|
2011-07-15 10:14:07 -07:00
|
|
|
if (!proto || !proto->setSingletonType(cx))
|
2011-03-16 10:02:19 -07:00
|
|
|
return NULL;
|
2011-02-24 21:21:43 -08:00
|
|
|
|
2011-02-14 12:04:07 -08:00
|
|
|
/*
|
2011-06-15 10:15:37 -07:00
|
|
|
* Per ES5 15.3.5.2 a user-defined function's .prototype property is
|
|
|
|
* initially non-configurable, non-enumerable, and writable. Per ES5 13.2
|
|
|
|
* the prototype's .constructor property is configurable, non-enumerable,
|
|
|
|
* and writable.
|
2011-02-14 12:04:07 -08:00
|
|
|
*/
|
2011-10-05 01:00:23 -07:00
|
|
|
if (!obj->defineProperty(cx, cx->runtime->atomState.classPrototypeAtom,
|
2011-09-20 11:40:24 -07:00
|
|
|
ObjectValue(*proto), JS_PropertyStub, JS_StrictPropertyStub,
|
2011-06-15 10:15:37 -07:00
|
|
|
JSPROP_PERMANENT) ||
|
2011-10-05 01:00:23 -07:00
|
|
|
!proto->defineProperty(cx, cx->runtime->atomState.constructorAtom,
|
2011-09-20 11:40:24 -07:00
|
|
|
ObjectValue(*obj), JS_PropertyStub, JS_StrictPropertyStub, 0))
|
2011-06-15 10:15:37 -07:00
|
|
|
{
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2011-02-14 12:04:07 -08:00
|
|
|
return proto;
|
|
|
|
}
|
|
|
|
|
2007-03-22 10:30:00 -07:00
|
|
|
static JSBool
|
2010-07-14 23:19:36 -07:00
|
|
|
fun_resolve(JSContext *cx, JSObject *obj, jsid id, uintN flags,
|
2007-03-22 10:30:00 -07:00
|
|
|
JSObject **objp)
|
|
|
|
{
|
2010-07-14 23:19:36 -07:00
|
|
|
if (!JSID_IS_ATOM(id))
|
2010-10-03 22:46:39 -07:00
|
|
|
return true;
|
2007-06-26 11:19:54 -07:00
|
|
|
|
2011-10-11 15:28:54 -07:00
|
|
|
JSFunction *fun = obj->toFunction();
|
2007-06-19 11:49:53 -07:00
|
|
|
|
2010-10-03 22:46:39 -07:00
|
|
|
if (JSID_IS_ATOM(id, cx->runtime->atomState.classPrototypeAtom)) {
|
|
|
|
/*
|
|
|
|
* Native or "built-in" functions do not have a .prototype property per
|
2011-06-15 10:15:37 -07:00
|
|
|
* ECMA-262, or (Object.prototype, Function.prototype, etc.) have that
|
|
|
|
* property created eagerly.
|
2010-10-03 22:46:39 -07:00
|
|
|
*
|
|
|
|
* ES5 15.3.4: the non-native function object named Function.prototype
|
2011-06-15 10:15:37 -07:00
|
|
|
* does not have a .prototype property.
|
2010-10-03 22:46:39 -07:00
|
|
|
*
|
|
|
|
* ES5 15.3.4.5: bound functions don't have a prototype property. The
|
|
|
|
* isNative() test covers this case because bound functions are native
|
|
|
|
* functions by definition/construction.
|
|
|
|
*/
|
|
|
|
if (fun->isNative() || fun->isFunctionPrototype())
|
|
|
|
return true;
|
2007-03-22 10:30:00 -07:00
|
|
|
|
2011-02-14 12:04:07 -08:00
|
|
|
if (!ResolveInterpretedFunctionPrototype(cx, obj))
|
2010-10-03 22:46:39 -07:00
|
|
|
return false;
|
2007-03-22 10:30:00 -07:00
|
|
|
*objp = obj;
|
2010-10-03 22:46:39 -07:00
|
|
|
return true;
|
2007-06-26 11:19:54 -07:00
|
|
|
}
|
|
|
|
|
2011-06-17 15:55:55 -07:00
|
|
|
if (JSID_IS_ATOM(id, cx->runtime->atomState.lengthAtom) ||
|
|
|
|
JSID_IS_ATOM(id, cx->runtime->atomState.nameAtom)) {
|
2010-06-02 23:44:24 -07:00
|
|
|
JS_ASSERT(!IsInternalFunctionObject(obj));
|
2011-06-17 15:55:55 -07:00
|
|
|
|
|
|
|
Value v;
|
|
|
|
if (JSID_IS_ATOM(id, cx->runtime->atomState.lengthAtom))
|
|
|
|
v.setInt32(fun->nargs);
|
|
|
|
else
|
|
|
|
v.setString(fun->atom ? fun->atom : cx->runtime->emptyString);
|
|
|
|
|
2011-09-20 11:40:24 -07:00
|
|
|
if (!DefineNativeProperty(cx, obj, id, v, JS_PropertyStub, JS_StrictPropertyStub,
|
2011-01-21 05:10:16 -08:00
|
|
|
JSPROP_PERMANENT | JSPROP_READONLY, 0, 0)) {
|
2010-10-03 22:46:39 -07:00
|
|
|
return false;
|
2010-06-02 23:44:24 -07:00
|
|
|
}
|
|
|
|
*objp = obj;
|
2010-10-03 22:46:39 -07:00
|
|
|
return true;
|
2010-06-02 23:44:24 -07:00
|
|
|
}
|
|
|
|
|
2011-10-10 23:00:28 -07:00
|
|
|
for (uintN i = 0; i < ArrayLength(poisonPillProps); i++) {
|
2011-06-17 15:55:55 -07:00
|
|
|
const uint16 offset = poisonPillProps[i];
|
2010-08-02 23:52:12 -07:00
|
|
|
|
2011-06-17 15:55:55 -07:00
|
|
|
if (JSID_IS_ATOM(id, OFFSET_TO_ATOM(cx->runtime, offset))) {
|
2010-08-02 23:52:12 -07:00
|
|
|
JS_ASSERT(!IsInternalFunctionObject(obj));
|
|
|
|
|
2011-02-09 11:31:40 -08:00
|
|
|
PropertyOp getter;
|
|
|
|
StrictPropertyOp setter;
|
2010-08-02 23:52:12 -07:00
|
|
|
uintN attrs = JSPROP_PERMANENT;
|
2010-12-22 18:06:08 -08:00
|
|
|
if (fun->isInterpreted() ? fun->inStrictMode() : obj->isBoundFunction()) {
|
2010-08-02 23:52:12 -07:00
|
|
|
JSObject *throwTypeError = obj->getThrowTypeError();
|
|
|
|
|
|
|
|
getter = CastAsPropertyOp(throwTypeError);
|
2011-02-09 11:31:40 -08:00
|
|
|
setter = CastAsStrictPropertyOp(throwTypeError);
|
2010-08-02 23:52:12 -07:00
|
|
|
attrs |= JSPROP_GETTER | JSPROP_SETTER;
|
|
|
|
} else {
|
|
|
|
getter = fun_getProperty;
|
2011-09-20 11:40:24 -07:00
|
|
|
setter = JS_StrictPropertyStub;
|
2010-08-02 23:52:12 -07:00
|
|
|
}
|
|
|
|
|
2011-01-21 05:10:16 -08:00
|
|
|
if (!DefineNativeProperty(cx, obj, id, UndefinedValue(), getter, setter,
|
2011-06-17 15:55:55 -07:00
|
|
|
attrs, 0, 0)) {
|
2010-10-03 22:46:39 -07:00
|
|
|
return false;
|
2010-08-02 23:52:12 -07:00
|
|
|
}
|
|
|
|
*objp = obj;
|
2010-10-03 22:46:39 -07:00
|
|
|
return true;
|
2010-08-02 23:52:12 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-10-03 22:46:39 -07:00
|
|
|
return true;
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
#if JS_HAS_XDR
|
|
|
|
|
|
|
|
/* XXX store parent and proto, if defined */
|
2009-05-06 16:03:10 -07:00
|
|
|
JSBool
|
|
|
|
js_XDRFunctionObject(JSXDRState *xdr, JSObject **objp)
|
2007-03-22 10:30:00 -07:00
|
|
|
{
|
|
|
|
JSContext *cx;
|
2008-03-29 03:34:29 -07:00
|
|
|
JSFunction *fun;
|
2009-06-04 18:58:47 -07:00
|
|
|
uint32 firstword; /* flag telling whether fun->atom is non-null,
|
|
|
|
plus for fun->u.i.skipmin, fun->u.i.wrapper,
|
|
|
|
and 14 bits reserved for future use */
|
2010-11-16 15:34:24 -08:00
|
|
|
uint32 flagsword; /* word for argument count and fun->flags */
|
2007-03-22 10:30:00 -07:00
|
|
|
|
|
|
|
cx = xdr->cx;
|
2011-09-22 03:08:55 -07:00
|
|
|
JSScript *script;
|
2007-03-22 10:30:00 -07:00
|
|
|
if (xdr->mode == JSXDR_ENCODE) {
|
2011-10-11 15:28:54 -07:00
|
|
|
fun = (*objp)->toFunction();
|
2011-08-18 10:39:44 -07:00
|
|
|
if (!fun->isInterpreted()) {
|
2010-11-11 12:40:29 -08:00
|
|
|
JSAutoByteString funNameBytes;
|
|
|
|
if (const char *name = GetFunctionNameBytes(cx, fun, &funNameBytes)) {
|
|
|
|
JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL, JSMSG_NOT_SCRIPTED_FUNCTION,
|
|
|
|
name);
|
|
|
|
}
|
2010-03-28 22:05:50 -07:00
|
|
|
return false;
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
2011-10-26 13:02:57 -07:00
|
|
|
firstword = !!fun->atom;
|
2010-11-16 15:34:24 -08:00
|
|
|
flagsword = (fun->nargs << 16) | fun->flags;
|
2011-09-22 03:08:55 -07:00
|
|
|
script = fun->script();
|
2007-03-22 10:30:00 -07:00
|
|
|
} else {
|
2011-06-10 19:03:57 -07:00
|
|
|
fun = js_NewFunction(cx, NULL, NULL, 0, JSFUN_INTERPRETED, NULL, NULL);
|
2008-03-28 15:27:36 -07:00
|
|
|
if (!fun)
|
2010-03-28 22:05:50 -07:00
|
|
|
return false;
|
2011-10-13 20:21:36 -07:00
|
|
|
if (!fun->clearParent(cx))
|
|
|
|
return false;
|
2011-10-07 20:09:09 -07:00
|
|
|
if (!fun->clearType(cx))
|
|
|
|
return false;
|
2011-09-22 03:08:55 -07:00
|
|
|
script = NULL;
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
|
|
|
|
2011-08-18 10:39:44 -07:00
|
|
|
AutoObjectRooter tvr(cx, fun);
|
2007-03-22 10:30:00 -07:00
|
|
|
|
2009-06-04 18:58:47 -07:00
|
|
|
if (!JS_XDRUint32(xdr, &firstword))
|
2010-03-28 22:05:50 -07:00
|
|
|
return false;
|
2010-07-15 18:19:50 -07:00
|
|
|
if ((firstword & 1U) && !js_XDRAtom(xdr, &fun->atom))
|
2010-03-28 22:05:50 -07:00
|
|
|
return false;
|
2010-11-16 15:34:24 -08:00
|
|
|
if (!JS_XDRUint32(xdr, &flagsword))
|
2010-03-28 22:05:50 -07:00
|
|
|
return false;
|
2007-03-22 10:30:00 -07:00
|
|
|
|
2011-08-02 10:18:30 -07:00
|
|
|
if (!js_XDRScript(xdr, &script))
|
2010-03-28 22:05:50 -07:00
|
|
|
return false;
|
2007-03-22 10:30:00 -07:00
|
|
|
|
|
|
|
if (xdr->mode == JSXDR_DECODE) {
|
2010-11-16 15:34:24 -08:00
|
|
|
fun->nargs = flagsword >> 16;
|
2009-04-05 21:17:22 -07:00
|
|
|
JS_ASSERT((flagsword & JSFUN_KINDMASK) >= JSFUN_INTERPRETED);
|
|
|
|
fun->flags = uint16(flagsword);
|
2011-10-05 14:51:37 -07:00
|
|
|
fun->setScript(script);
|
2011-09-22 03:08:55 -07:00
|
|
|
if (!script->typeSetFunction(cx, fun))
|
2011-03-07 08:25:27 -08:00
|
|
|
return false;
|
2010-11-16 15:34:24 -08:00
|
|
|
JS_ASSERT(fun->nargs == fun->script()->bindings.countArgs());
|
2010-11-16 15:30:56 -08:00
|
|
|
js_CallNewScriptHook(cx, fun->script(), fun);
|
2011-09-22 03:08:55 -07:00
|
|
|
*objp = fun;
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
|
|
|
|
2010-03-28 22:05:50 -07:00
|
|
|
return true;
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
#else /* !JS_HAS_XDR */
|
|
|
|
|
2009-05-06 16:03:10 -07:00
|
|
|
#define js_XDRFunctionObject NULL
|
2007-03-22 10:30:00 -07:00
|
|
|
|
|
|
|
#endif /* !JS_HAS_XDR */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* [[HasInstance]] internal method for Function objects: fetch the .prototype
|
|
|
|
* property of its 'this' parameter, and walks the prototype chain of v (only
|
|
|
|
* if v is an object) returning true if .prototype is found.
|
|
|
|
*/
|
|
|
|
static JSBool
|
2010-07-14 23:19:36 -07:00
|
|
|
fun_hasInstance(JSContext *cx, JSObject *obj, const Value *v, JSBool *bp)
|
2007-03-22 10:30:00 -07:00
|
|
|
{
|
2010-08-13 10:42:33 -07:00
|
|
|
while (obj->isFunction()) {
|
2010-09-16 19:31:11 -07:00
|
|
|
if (!obj->isBoundFunction())
|
2010-08-13 10:42:33 -07:00
|
|
|
break;
|
2011-10-26 13:02:57 -07:00
|
|
|
obj = obj->toFunction()->getBoundFunctionTarget();
|
2010-08-13 10:42:33 -07:00
|
|
|
}
|
|
|
|
|
2010-07-14 23:19:36 -07:00
|
|
|
Value pval;
|
2011-09-15 11:44:10 -07:00
|
|
|
if (!obj->getProperty(cx, cx->runtime->atomState.classPrototypeAtom, &pval))
|
2007-03-22 10:30:00 -07:00
|
|
|
return JS_FALSE;
|
|
|
|
|
2010-07-14 23:19:36 -07:00
|
|
|
if (pval.isPrimitive()) {
|
2007-03-22 10:30:00 -07:00
|
|
|
/*
|
|
|
|
* Throw a runtime error if instanceof is called on a function that
|
|
|
|
* has a non-object as its .prototype value.
|
|
|
|
*/
|
2010-07-14 23:19:36 -07:00
|
|
|
js_ReportValueError(cx, JSMSG_BAD_PROTOTYPE, -1, ObjectValue(*obj), NULL);
|
2007-03-22 10:30:00 -07:00
|
|
|
return JS_FALSE;
|
|
|
|
}
|
|
|
|
|
2010-07-14 23:19:36 -07:00
|
|
|
*bp = js_IsDelegate(cx, &pval.toObject(), *v);
|
|
|
|
return JS_TRUE;
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
|
|
|
|
2011-10-26 13:02:57 -07:00
|
|
|
inline void
|
|
|
|
JSFunction::trace(JSTracer *trc)
|
2007-03-22 10:30:00 -07:00
|
|
|
{
|
2011-11-14 09:13:33 -08:00
|
|
|
if (isFlatClosure() && hasFlatClosureUpvars()) {
|
2011-11-18 15:20:21 -08:00
|
|
|
if (HeapValue *upvars = getFlatClosureUpvars())
|
2011-10-26 13:02:57 -07:00
|
|
|
MarkValueRange(trc, script()->bindings.countUpvars(), upvars, "upvars");
|
|
|
|
}
|
|
|
|
|
2011-11-14 09:13:33 -08:00
|
|
|
if (isExtended()) {
|
2011-11-18 15:20:21 -08:00
|
|
|
MarkValueRange(trc, ArrayLength(toExtended()->extendedSlots),
|
2011-11-14 09:13:33 -08:00
|
|
|
toExtended()->extendedSlots, "nativeReserved");
|
2011-10-26 13:02:57 -07:00
|
|
|
}
|
2010-08-29 11:57:08 -07:00
|
|
|
|
2011-10-26 13:02:57 -07:00
|
|
|
if (atom)
|
2011-11-14 09:13:33 -08:00
|
|
|
MarkAtom(trc, atom, "atom");
|
2011-10-26 13:02:57 -07:00
|
|
|
|
|
|
|
if (isInterpreted()) {
|
|
|
|
if (script())
|
|
|
|
MarkScript(trc, script(), "script");
|
2011-11-08 13:42:27 -08:00
|
|
|
if (environment())
|
2011-11-14 09:13:33 -08:00
|
|
|
MarkObjectUnbarriered(trc, environment(), "fun_callscope");
|
2011-10-14 15:31:53 -07:00
|
|
|
}
|
2008-04-02 00:46:12 -07:00
|
|
|
}
|
|
|
|
|
2011-10-26 13:02:57 -07:00
|
|
|
static void
|
|
|
|
fun_trace(JSTracer *trc, JSObject *obj)
|
|
|
|
{
|
|
|
|
obj->toFunction()->trace(trc);
|
|
|
|
}
|
|
|
|
|
2008-04-02 00:46:12 -07:00
|
|
|
static void
|
|
|
|
fun_finalize(JSContext *cx, JSObject *obj)
|
|
|
|
{
|
2011-10-26 13:02:57 -07:00
|
|
|
if (obj->toFunction()->isFlatClosure())
|
|
|
|
obj->toFunction()->finalizeUpvars();
|
2009-07-24 03:01:37 -07:00
|
|
|
}
|
|
|
|
|
2007-03-22 10:30:00 -07:00
|
|
|
/*
|
|
|
|
* Reserve two slots in all function objects for XPConnect. Note that this
|
|
|
|
* does not bloat every instance, only those on which reserved slots are set,
|
|
|
|
* and those on which ad-hoc properties are defined.
|
|
|
|
*/
|
2011-10-04 07:06:54 -07:00
|
|
|
JS_FRIEND_DATA(Class) js::FunctionClass = {
|
2007-03-22 10:30:00 -07:00
|
|
|
js_Function_str,
|
2011-10-11 15:28:54 -07:00
|
|
|
JSCLASS_NEW_RESOLVE |
|
2011-09-29 20:29:13 -07:00
|
|
|
JSCLASS_HAS_CACHED_PROTO(JSProto_Function),
|
2011-09-20 11:40:24 -07:00
|
|
|
JS_PropertyStub, /* addProperty */
|
|
|
|
JS_PropertyStub, /* delProperty */
|
|
|
|
JS_PropertyStub, /* getProperty */
|
|
|
|
JS_StrictPropertyStub, /* setProperty */
|
2010-06-12 09:29:04 -07:00
|
|
|
fun_enumerate,
|
|
|
|
(JSResolveOp)fun_resolve,
|
2011-09-20 11:40:24 -07:00
|
|
|
JS_ConvertStub,
|
2010-06-12 09:29:04 -07:00
|
|
|
fun_finalize,
|
2011-09-20 11:40:24 -07:00
|
|
|
NULL, /* reserved0 */
|
|
|
|
NULL, /* checkAccess */
|
|
|
|
NULL, /* call */
|
|
|
|
NULL, /* construct */
|
2011-03-21 11:06:34 -07:00
|
|
|
NULL,
|
2010-06-12 09:29:04 -07:00
|
|
|
fun_hasInstance,
|
2011-03-05 14:50:11 -08:00
|
|
|
fun_trace
|
2007-03-22 10:30:00 -07:00
|
|
|
};
|
|
|
|
|
2010-06-23 14:35:10 -07:00
|
|
|
JSString *
|
|
|
|
fun_toStringHelper(JSContext *cx, JSObject *obj, uintN indent)
|
|
|
|
{
|
|
|
|
if (!obj->isFunction()) {
|
2011-10-04 07:06:54 -07:00
|
|
|
if (IsFunctionProxy(obj))
|
2011-09-08 20:29:15 -07:00
|
|
|
return Proxy::fun_toString(cx, obj, indent);
|
2010-04-11 20:55:22 -07:00
|
|
|
JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL,
|
|
|
|
JSMSG_INCOMPATIBLE_PROTO,
|
|
|
|
js_Function_str, js_toString_str,
|
2010-06-23 14:35:10 -07:00
|
|
|
"object");
|
|
|
|
return NULL;
|
2008-03-06 13:40:43 -08:00
|
|
|
}
|
2007-08-01 21:33:52 -07:00
|
|
|
|
2011-10-11 15:28:54 -07:00
|
|
|
JSFunction *fun = obj->toFunction();
|
2007-03-22 10:30:00 -07:00
|
|
|
if (!fun)
|
2010-06-23 14:35:10 -07:00
|
|
|
return NULL;
|
2011-01-28 10:19:13 -08:00
|
|
|
|
2011-03-03 15:28:25 -08:00
|
|
|
if (!indent && !cx->compartment->toSourceCache.empty()) {
|
|
|
|
ToSourceCache::Ptr p = cx->compartment->toSourceCache.ref().lookup(fun);
|
2011-01-28 10:19:13 -08:00
|
|
|
if (p)
|
|
|
|
return p->value;
|
|
|
|
}
|
|
|
|
|
|
|
|
JSString *str = JS_DecompileFunction(cx, fun, indent);
|
|
|
|
if (!str)
|
2011-03-03 15:28:25 -08:00
|
|
|
return NULL;
|
|
|
|
|
|
|
|
if (!indent) {
|
2011-04-28 15:48:51 -07:00
|
|
|
Maybe<ToSourceCache> &lazy = cx->compartment->toSourceCache;
|
2011-01-28 10:19:13 -08:00
|
|
|
|
2011-03-03 15:28:25 -08:00
|
|
|
if (lazy.empty()) {
|
|
|
|
lazy.construct();
|
|
|
|
if (!lazy.ref().init())
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!lazy.ref().put(fun, str))
|
|
|
|
return NULL;
|
|
|
|
}
|
2011-01-28 10:19:13 -08:00
|
|
|
|
|
|
|
return str;
|
2010-06-23 14:35:10 -07:00
|
|
|
}
|
|
|
|
|
2007-03-22 10:30:00 -07:00
|
|
|
static JSBool
|
2010-07-14 23:19:36 -07:00
|
|
|
fun_toString(JSContext *cx, uintN argc, Value *vp)
|
2007-03-22 10:30:00 -07:00
|
|
|
{
|
2010-07-14 23:19:36 -07:00
|
|
|
JS_ASSERT(IsFunctionObject(vp[0]));
|
2010-06-23 14:35:10 -07:00
|
|
|
uint32_t indent = 0;
|
|
|
|
|
|
|
|
if (argc != 0 && !ValueToECMAUint32(cx, vp[2], &indent))
|
|
|
|
return false;
|
|
|
|
|
2011-01-26 13:37:45 -08:00
|
|
|
JSObject *obj = ToObject(cx, &vp[1]);
|
2010-06-23 14:35:10 -07:00
|
|
|
if (!obj)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
JSString *str = fun_toStringHelper(cx, obj, indent);
|
|
|
|
if (!str)
|
|
|
|
return false;
|
|
|
|
|
2010-07-14 23:19:36 -07:00
|
|
|
vp->setString(str);
|
2010-06-23 14:35:10 -07:00
|
|
|
return true;
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
#if JS_HAS_TOSOURCE
|
|
|
|
static JSBool
|
2010-07-14 23:19:36 -07:00
|
|
|
fun_toSource(JSContext *cx, uintN argc, Value *vp)
|
2007-03-22 10:30:00 -07:00
|
|
|
{
|
2010-07-14 23:19:36 -07:00
|
|
|
JS_ASSERT(IsFunctionObject(vp[0]));
|
2010-06-23 14:35:10 -07:00
|
|
|
|
2011-01-26 13:37:45 -08:00
|
|
|
JSObject *obj = ToObject(cx, &vp[1]);
|
2010-06-23 14:35:10 -07:00
|
|
|
if (!obj)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
JSString *str = fun_toStringHelper(cx, obj, JS_DONT_PRETTY_PRINT);
|
|
|
|
if (!str)
|
|
|
|
return false;
|
|
|
|
|
2010-07-14 23:19:36 -07:00
|
|
|
vp->setString(str);
|
2010-06-23 14:35:10 -07:00
|
|
|
return true;
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2009-06-25 12:12:19 -07:00
|
|
|
JSBool
|
2010-07-14 23:19:36 -07:00
|
|
|
js_fun_call(JSContext *cx, uintN argc, Value *vp)
|
2007-03-22 10:30:00 -07:00
|
|
|
{
|
2010-07-14 23:19:36 -07:00
|
|
|
Value fval = vp[1];
|
2007-03-22 10:30:00 -07:00
|
|
|
|
2010-02-22 22:25:09 -08:00
|
|
|
if (!js_IsCallable(fval)) {
|
2011-09-08 21:02:26 -07:00
|
|
|
ReportIncompatibleMethod(cx, CallReceiverFromVp(vp), &FunctionClass);
|
2011-01-26 13:37:45 -08:00
|
|
|
return false;
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
|
|
|
|
2010-07-14 23:19:36 -07:00
|
|
|
Value *argv = vp + 2;
|
2010-10-12 11:50:03 -07:00
|
|
|
Value thisv;
|
2007-03-22 10:30:00 -07:00
|
|
|
if (argc == 0) {
|
2010-10-12 11:50:03 -07:00
|
|
|
thisv.setUndefined();
|
2007-03-22 10:30:00 -07:00
|
|
|
} else {
|
2010-10-12 11:50:03 -07:00
|
|
|
thisv = argv[0];
|
|
|
|
|
2007-03-22 10:30:00 -07:00
|
|
|
argc--;
|
|
|
|
argv++;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Allocate stack space for fval, obj, and the args. */
|
2010-03-03 17:52:26 -08:00
|
|
|
InvokeArgsGuard args;
|
2011-04-13 09:27:37 -07:00
|
|
|
if (!cx->stack.pushInvokeArgs(cx, argc, &args))
|
2007-03-22 10:30:00 -07:00
|
|
|
return JS_FALSE;
|
|
|
|
|
2010-10-12 11:50:03 -07:00
|
|
|
/* Push fval, thisv, and the args. */
|
2011-04-08 10:52:48 -07:00
|
|
|
args.calleev() = fval;
|
2010-10-12 11:50:03 -07:00
|
|
|
args.thisv() = thisv;
|
2011-09-08 21:02:26 -07:00
|
|
|
memcpy(args.array(), argv, argc * sizeof *argv);
|
2007-03-22 10:30:00 -07:00
|
|
|
|
2011-04-13 09:27:37 -07:00
|
|
|
bool ok = Invoke(cx, args);
|
2010-07-30 10:41:03 -07:00
|
|
|
*vp = args.rval();
|
2007-03-22 10:30:00 -07:00
|
|
|
return ok;
|
|
|
|
}
|
|
|
|
|
2010-07-16 12:53:37 -07:00
|
|
|
/* ES5 15.3.4.3 */
|
2009-06-25 12:12:19 -07:00
|
|
|
JSBool
|
2010-07-14 23:19:36 -07:00
|
|
|
js_fun_apply(JSContext *cx, uintN argc, Value *vp)
|
2007-03-22 10:30:00 -07:00
|
|
|
{
|
2010-07-16 12:53:37 -07:00
|
|
|
/* Step 1. */
|
2010-07-14 23:19:36 -07:00
|
|
|
Value fval = vp[1];
|
2010-02-22 22:25:09 -08:00
|
|
|
if (!js_IsCallable(fval)) {
|
2011-09-08 21:02:26 -07:00
|
|
|
ReportIncompatibleMethod(cx, CallReceiverFromVp(vp), &FunctionClass);
|
2010-07-16 12:53:37 -07:00
|
|
|
return false;
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
|
|
|
|
2010-07-16 12:53:37 -07:00
|
|
|
/* Step 2. */
|
|
|
|
if (argc < 2 || vp[3].isNullOrUndefined())
|
|
|
|
return js_fun_call(cx, (argc > 0) ? 1 : 0, vp);
|
|
|
|
|
2010-10-21 11:33:22 -07:00
|
|
|
/* N.B. Changes need to be propagated to stubs::SplatApplyArgs. */
|
|
|
|
|
2010-07-16 12:53:37 -07:00
|
|
|
/* Step 3. */
|
|
|
|
if (!vp[3].isObject()) {
|
|
|
|
JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL, JSMSG_BAD_APPLY_ARGS, js_apply_str);
|
|
|
|
return false;
|
|
|
|
}
|
2007-03-22 10:30:00 -07:00
|
|
|
|
2010-07-16 12:53:37 -07:00
|
|
|
/*
|
|
|
|
* Steps 4-5 (note erratum removing steps originally numbered 5 and 7 in
|
|
|
|
* original version of ES5).
|
|
|
|
*/
|
2010-10-22 15:40:11 -07:00
|
|
|
JSObject *aobj = &vp[3].toObject();
|
2010-07-16 12:53:37 -07:00
|
|
|
jsuint length;
|
2010-10-20 23:52:55 -07:00
|
|
|
if (!js_GetLengthProperty(cx, aobj, &length))
|
|
|
|
return false;
|
2007-03-22 10:30:00 -07:00
|
|
|
|
2010-07-16 12:53:37 -07:00
|
|
|
/* Step 6. */
|
2011-07-25 20:33:02 -07:00
|
|
|
if (length > StackSpace::ARGS_LENGTH_MAX) {
|
|
|
|
JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL, JSMSG_TOO_MANY_FUN_APPLY_ARGS);
|
|
|
|
return false;
|
|
|
|
}
|
2010-03-03 17:52:26 -08:00
|
|
|
|
|
|
|
InvokeArgsGuard args;
|
2011-07-25 20:33:02 -07:00
|
|
|
if (!cx->stack.pushInvokeArgs(cx, length, &args))
|
2010-07-16 12:53:37 -07:00
|
|
|
return false;
|
2007-03-22 10:30:00 -07:00
|
|
|
|
|
|
|
/* Push fval, obj, and aobj's elements as args. */
|
2011-04-08 10:52:48 -07:00
|
|
|
args.calleev() = fval;
|
2010-10-12 11:50:03 -07:00
|
|
|
args.thisv() = vp[2];
|
2010-07-16 12:53:37 -07:00
|
|
|
|
|
|
|
/* Steps 7-8. */
|
2011-09-08 21:02:26 -07:00
|
|
|
if (!GetElements(cx, aobj, length, args.array()))
|
2010-10-20 23:52:55 -07:00
|
|
|
return false;
|
2007-03-22 10:30:00 -07:00
|
|
|
|
2010-07-16 12:53:37 -07:00
|
|
|
/* Step 9. */
|
2011-04-13 09:27:37 -07:00
|
|
|
if (!Invoke(cx, args))
|
2010-07-16 12:53:37 -07:00
|
|
|
return false;
|
2010-07-30 10:41:03 -07:00
|
|
|
*vp = args.rval();
|
2010-07-16 12:53:37 -07:00
|
|
|
return true;
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
|
|
|
|
2011-02-09 18:17:34 -08:00
|
|
|
namespace js {
|
|
|
|
|
|
|
|
JSBool
|
2010-08-13 10:42:33 -07:00
|
|
|
CallOrConstructBoundFunction(JSContext *cx, uintN argc, Value *vp);
|
|
|
|
|
2011-02-09 18:17:34 -08:00
|
|
|
}
|
|
|
|
|
2011-10-26 13:02:57 -07:00
|
|
|
static const uint32 JSSLOT_BOUND_FUNCTION_THIS = 0;
|
|
|
|
static const uint32 JSSLOT_BOUND_FUNCTION_ARGS_COUNT = 1;
|
|
|
|
|
|
|
|
static const uint32 BOUND_FUNCTION_RESERVED_SLOTS = 2;
|
|
|
|
|
2010-08-13 10:42:33 -07:00
|
|
|
inline bool
|
2011-10-26 13:02:57 -07:00
|
|
|
JSFunction::initBoundFunction(JSContext *cx, const Value &thisArg,
|
|
|
|
const Value *args, uintN argslen)
|
2010-08-13 10:42:33 -07:00
|
|
|
{
|
|
|
|
JS_ASSERT(isFunction());
|
|
|
|
|
2011-10-14 13:51:21 -07:00
|
|
|
/*
|
|
|
|
* Convert to a dictionary to set the BOUND_FUNCTION flag and increase
|
2011-10-26 13:02:57 -07:00
|
|
|
* the slot span to cover the arguments and additional slots for the 'this'
|
|
|
|
* value and arguments count.
|
2011-10-14 13:51:21 -07:00
|
|
|
*/
|
|
|
|
if (!toDictionaryMode(cx))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
lastProperty()->base()->setObjectFlag(BaseShape::BOUND_FUNCTION);
|
|
|
|
|
2011-10-26 13:02:57 -07:00
|
|
|
if (!setSlotSpan(cx, BOUND_FUNCTION_RESERVED_SLOTS + argslen))
|
2011-10-14 13:51:21 -07:00
|
|
|
return false;
|
|
|
|
|
2011-10-26 13:02:57 -07:00
|
|
|
setSlot(JSSLOT_BOUND_FUNCTION_THIS, thisArg);
|
|
|
|
setSlot(JSSLOT_BOUND_FUNCTION_ARGS_COUNT, PrivateUint32Value(argslen));
|
|
|
|
|
2011-11-14 09:13:33 -08:00
|
|
|
copySlotRange(BOUND_FUNCTION_RESERVED_SLOTS, args, argslen, false);
|
2011-10-14 13:51:21 -07:00
|
|
|
|
2010-08-13 10:42:33 -07:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
inline JSObject *
|
2011-10-26 13:02:57 -07:00
|
|
|
JSFunction::getBoundFunctionTarget() const
|
2010-08-13 10:42:33 -07:00
|
|
|
{
|
|
|
|
JS_ASSERT(isFunction());
|
2010-09-16 19:31:11 -07:00
|
|
|
JS_ASSERT(isBoundFunction());
|
2010-08-13 10:42:33 -07:00
|
|
|
|
|
|
|
/* Bound functions abuse |parent| to store their target function. */
|
|
|
|
return getParent();
|
|
|
|
}
|
|
|
|
|
|
|
|
inline const js::Value &
|
2011-10-26 13:02:57 -07:00
|
|
|
JSFunction::getBoundFunctionThis() const
|
2010-08-13 10:42:33 -07:00
|
|
|
{
|
|
|
|
JS_ASSERT(isFunction());
|
2010-09-16 19:31:11 -07:00
|
|
|
JS_ASSERT(isBoundFunction());
|
2010-08-13 10:42:33 -07:00
|
|
|
|
2010-10-13 11:49:22 -07:00
|
|
|
return getSlot(JSSLOT_BOUND_FUNCTION_THIS);
|
2010-08-13 10:42:33 -07:00
|
|
|
}
|
|
|
|
|
2011-04-08 19:51:40 -07:00
|
|
|
inline const js::Value &
|
2011-10-26 13:02:57 -07:00
|
|
|
JSFunction::getBoundFunctionArgument(uintN which) const
|
2010-08-13 10:42:33 -07:00
|
|
|
{
|
|
|
|
JS_ASSERT(isFunction());
|
2010-09-16 19:31:11 -07:00
|
|
|
JS_ASSERT(isBoundFunction());
|
2011-04-08 19:51:40 -07:00
|
|
|
JS_ASSERT(which < getBoundFunctionArgumentCount());
|
|
|
|
|
2011-10-26 13:02:57 -07:00
|
|
|
return getSlot(BOUND_FUNCTION_RESERVED_SLOTS + which);
|
2011-04-08 19:51:40 -07:00
|
|
|
}
|
2010-08-13 10:42:33 -07:00
|
|
|
|
2011-04-08 19:51:40 -07:00
|
|
|
inline size_t
|
2011-10-26 13:02:57 -07:00
|
|
|
JSFunction::getBoundFunctionArgumentCount() const
|
2011-04-08 19:51:40 -07:00
|
|
|
{
|
|
|
|
JS_ASSERT(isFunction());
|
|
|
|
JS_ASSERT(isBoundFunction());
|
2010-10-13 11:49:22 -07:00
|
|
|
|
2011-04-08 19:51:40 -07:00
|
|
|
return getSlot(JSSLOT_BOUND_FUNCTION_ARGS_COUNT).toPrivateUint32();
|
2010-08-13 10:42:33 -07:00
|
|
|
}
|
|
|
|
|
2011-02-09 18:17:34 -08:00
|
|
|
namespace js {
|
|
|
|
|
2010-08-13 10:42:33 -07:00
|
|
|
/* ES5 15.3.4.5.1 and 15.3.4.5.2. */
|
2011-02-09 18:17:34 -08:00
|
|
|
JSBool
|
2010-08-13 10:42:33 -07:00
|
|
|
CallOrConstructBoundFunction(JSContext *cx, uintN argc, Value *vp)
|
|
|
|
{
|
2011-10-26 13:02:57 -07:00
|
|
|
JSFunction *fun = vp[0].toObject().toFunction();
|
|
|
|
JS_ASSERT(fun->isBoundFunction());
|
2010-08-13 10:42:33 -07:00
|
|
|
|
2010-08-16 12:35:04 -07:00
|
|
|
bool constructing = IsConstructing(vp);
|
2010-08-13 10:42:33 -07:00
|
|
|
|
|
|
|
/* 15.3.4.5.1 step 1, 15.3.4.5.2 step 3. */
|
2011-10-26 13:02:57 -07:00
|
|
|
uintN argslen = fun->getBoundFunctionArgumentCount();
|
2010-08-13 10:42:33 -07:00
|
|
|
|
2011-06-30 09:26:56 -07:00
|
|
|
if (argc + argslen > StackSpace::ARGS_LENGTH_MAX) {
|
2010-08-13 10:42:33 -07:00
|
|
|
js_ReportAllocationOverflow(cx);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* 15.3.4.5.1 step 3, 15.3.4.5.2 step 1. */
|
2011-10-26 13:02:57 -07:00
|
|
|
JSObject *target = fun->getBoundFunctionTarget();
|
2010-08-13 10:42:33 -07:00
|
|
|
|
|
|
|
/* 15.3.4.5.1 step 2. */
|
2011-10-26 13:02:57 -07:00
|
|
|
const Value &boundThis = fun->getBoundFunctionThis();
|
2010-08-13 10:42:33 -07:00
|
|
|
|
|
|
|
InvokeArgsGuard args;
|
2011-04-13 09:27:37 -07:00
|
|
|
if (!cx->stack.pushInvokeArgs(cx, argc + argslen, &args))
|
2010-08-13 10:42:33 -07:00
|
|
|
return false;
|
|
|
|
|
|
|
|
/* 15.3.4.5.1, 15.3.4.5.2 step 4. */
|
2011-04-08 19:51:40 -07:00
|
|
|
for (uintN i = 0; i < argslen; i++)
|
2011-10-26 13:02:57 -07:00
|
|
|
args[i] = fun->getBoundFunctionArgument(i);
|
2011-09-08 21:02:26 -07:00
|
|
|
memcpy(args.array() + argslen, vp + 2, argc * sizeof(Value));
|
2010-08-13 10:42:33 -07:00
|
|
|
|
|
|
|
/* 15.3.4.5.1, 15.3.4.5.2 step 5. */
|
2011-04-08 10:52:48 -07:00
|
|
|
args.calleev().setObject(*target);
|
2010-08-13 10:42:33 -07:00
|
|
|
|
2010-10-12 11:50:03 -07:00
|
|
|
if (!constructing)
|
|
|
|
args.thisv() = boundThis;
|
2010-08-13 10:42:33 -07:00
|
|
|
|
2011-04-13 09:27:37 -07:00
|
|
|
if (constructing ? !InvokeConstructor(cx, args) : !Invoke(cx, args))
|
2010-08-13 10:42:33 -07:00
|
|
|
return false;
|
|
|
|
|
|
|
|
*vp = args.rval();
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2011-02-09 18:17:34 -08:00
|
|
|
}
|
|
|
|
|
2011-04-08 13:31:14 -07:00
|
|
|
#if JS_HAS_GENERATORS
|
|
|
|
static JSBool
|
|
|
|
fun_isGenerator(JSContext *cx, uintN argc, Value *vp)
|
|
|
|
{
|
2011-10-11 15:28:54 -07:00
|
|
|
JSFunction *fun;
|
|
|
|
if (!IsFunctionObject(vp[1], &fun)) {
|
2011-04-08 13:31:14 -07:00
|
|
|
JS_SET_RVAL(cx, vp, BooleanValue(false));
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool result = false;
|
|
|
|
if (fun->isInterpreted()) {
|
2011-05-20 11:27:27 -07:00
|
|
|
JSScript *script = fun->script();
|
2011-04-08 13:31:14 -07:00
|
|
|
JS_ASSERT(script->length != 0);
|
|
|
|
result = script->code[0] == JSOP_GENERATOR;
|
|
|
|
}
|
|
|
|
|
|
|
|
JS_SET_RVAL(cx, vp, BooleanValue(result));
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2010-08-13 10:42:33 -07:00
|
|
|
/* ES5 15.3.4.5. */
|
2010-10-25 16:47:11 -07:00
|
|
|
static JSBool
|
2010-08-13 10:42:33 -07:00
|
|
|
fun_bind(JSContext *cx, uintN argc, Value *vp)
|
|
|
|
{
|
2011-09-08 21:02:26 -07:00
|
|
|
CallArgs args = CallArgsFromVp(argc, vp);
|
|
|
|
|
2010-08-13 10:42:33 -07:00
|
|
|
/* Step 1. */
|
2011-09-08 21:02:26 -07:00
|
|
|
Value &thisv = args.thisv();
|
2010-08-13 10:42:33 -07:00
|
|
|
|
|
|
|
/* Step 2. */
|
2011-01-26 13:37:45 -08:00
|
|
|
if (!js_IsCallable(thisv)) {
|
2011-09-08 21:02:26 -07:00
|
|
|
ReportIncompatibleMethod(cx, args, &FunctionClass);
|
2010-08-13 10:42:33 -07:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2011-01-26 13:37:45 -08:00
|
|
|
JSObject *target = &thisv.toObject();
|
|
|
|
|
2010-08-13 10:42:33 -07:00
|
|
|
/* Step 3. */
|
2011-09-08 21:02:26 -07:00
|
|
|
Value *boundArgs = NULL;
|
2010-08-13 10:42:33 -07:00
|
|
|
uintN argslen = 0;
|
2011-09-08 21:02:26 -07:00
|
|
|
if (args.length() > 1) {
|
|
|
|
boundArgs = args.array() + 1;
|
|
|
|
argslen = args.length() - 1;
|
2010-08-13 10:42:33 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Steps 15-16. */
|
|
|
|
uintN length = 0;
|
|
|
|
if (target->isFunction()) {
|
2011-10-11 15:28:54 -07:00
|
|
|
uintN nargs = target->toFunction()->nargs;
|
2010-08-13 10:42:33 -07:00
|
|
|
if (nargs > argslen)
|
|
|
|
length = nargs - argslen;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Step 4-6, 10-11. */
|
2011-10-11 15:28:54 -07:00
|
|
|
JSAtom *name = target->isFunction() ? target->toFunction()->atom : NULL;
|
2010-08-13 10:42:33 -07:00
|
|
|
|
|
|
|
JSObject *funobj =
|
2010-08-16 12:35:04 -07:00
|
|
|
js_NewFunction(cx, NULL, CallOrConstructBoundFunction, length,
|
2011-06-10 19:03:57 -07:00
|
|
|
JSFUN_CONSTRUCTOR, target, name);
|
2010-08-13 10:42:33 -07:00
|
|
|
if (!funobj)
|
|
|
|
return false;
|
|
|
|
|
2011-10-13 12:10:52 -07:00
|
|
|
/* NB: Bound functions abuse |parent| to store their target. */
|
2011-10-13 20:21:36 -07:00
|
|
|
if (!funobj->setParent(cx, target))
|
|
|
|
return false;
|
2011-10-13 12:10:52 -07:00
|
|
|
|
2010-08-13 10:42:33 -07:00
|
|
|
/* Steps 7-9. */
|
2011-09-08 21:02:26 -07:00
|
|
|
Value thisArg = args.length() >= 1 ? args[0] : UndefinedValue();
|
2011-10-26 13:02:57 -07:00
|
|
|
if (!funobj->toFunction()->initBoundFunction(cx, thisArg, boundArgs, argslen))
|
2010-08-13 10:42:33 -07:00
|
|
|
return false;
|
|
|
|
|
|
|
|
/* Steps 17, 19-21 are handled by fun_resolve. */
|
|
|
|
/* Step 18 is the default for new functions. */
|
|
|
|
|
|
|
|
/* Step 22. */
|
2011-09-08 21:02:26 -07:00
|
|
|
args.rval().setObject(*funobj);
|
2010-08-13 10:42:33 -07:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2011-03-23 14:33:02 -07:00
|
|
|
/*
|
|
|
|
* Report "malformed formal parameter" iff no illegal char or similar scanner
|
|
|
|
* error was already reported.
|
|
|
|
*/
|
|
|
|
static bool
|
|
|
|
OnBadFormal(JSContext *cx, TokenKind tt)
|
|
|
|
{
|
|
|
|
if (tt != TOK_ERROR)
|
|
|
|
JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL, JSMSG_BAD_FORMAL);
|
|
|
|
else
|
|
|
|
JS_ASSERT(cx->isExceptionPending());
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2011-06-15 11:58:45 -07:00
|
|
|
namespace js {
|
|
|
|
|
|
|
|
JSFunctionSpec function_methods[] = {
|
|
|
|
#if JS_HAS_TOSOURCE
|
|
|
|
JS_FN(js_toSource_str, fun_toSource, 0,0),
|
|
|
|
#endif
|
|
|
|
JS_FN(js_toString_str, fun_toString, 0,0),
|
|
|
|
JS_FN(js_apply_str, js_fun_apply, 2,0),
|
|
|
|
JS_FN(js_call_str, js_fun_call, 1,0),
|
|
|
|
JS_FN("bind", fun_bind, 1,0),
|
|
|
|
#if JS_HAS_GENERATORS
|
|
|
|
JS_FN("isGenerator", fun_isGenerator,0,0),
|
|
|
|
#endif
|
|
|
|
JS_FS_END
|
|
|
|
};
|
|
|
|
|
|
|
|
JSBool
|
2010-08-16 12:35:04 -07:00
|
|
|
Function(JSContext *cx, uintN argc, Value *vp)
|
2007-03-22 10:30:00 -07:00
|
|
|
{
|
2011-09-08 21:02:26 -07:00
|
|
|
CallArgs args = CallArgsFromVp(argc, vp);
|
2011-04-08 10:52:51 -07:00
|
|
|
|
2011-05-10 14:56:49 -07:00
|
|
|
/* Block this call if security callbacks forbid it. */
|
2011-09-08 21:02:26 -07:00
|
|
|
GlobalObject *global = args.callee().getGlobal();
|
2011-06-10 11:44:16 -07:00
|
|
|
if (!global->isRuntimeCodeGenEnabled(cx)) {
|
2011-05-10 14:56:49 -07:00
|
|
|
JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL, JSMSG_CSP_BLOCKED_FUNCTION);
|
2011-03-23 14:33:02 -07:00
|
|
|
return false;
|
2011-05-10 14:56:49 -07:00
|
|
|
}
|
2007-03-22 10:30:00 -07:00
|
|
|
|
2011-03-11 16:29:38 -08:00
|
|
|
Bindings bindings(cx);
|
2011-04-08 10:52:51 -07:00
|
|
|
uintN lineno;
|
|
|
|
const char *filename = CurrentScriptFileAndLine(cx, &lineno);
|
|
|
|
|
2011-09-08 21:02:26 -07:00
|
|
|
uintN n = args.length() ? args.length() - 1 : 0;
|
2007-03-22 10:30:00 -07:00
|
|
|
if (n > 0) {
|
|
|
|
/*
|
|
|
|
* Collect the function-argument arguments into one string, separated
|
|
|
|
* by commas, then make a tokenstream from that string, and scan it to
|
|
|
|
* get the arguments. We need to throw the full scanner at the
|
|
|
|
* problem, because the argument string can legitimately contain
|
|
|
|
* comments and linefeeds. XXX It might be better to concatenate
|
|
|
|
* everything up into a function definition and pass it to the
|
|
|
|
* compiler, but doing it this way is less of a delta from the old
|
|
|
|
* code. See ECMA 15.3.2.1.
|
|
|
|
*/
|
2010-08-16 12:35:04 -07:00
|
|
|
size_t args_length = 0;
|
|
|
|
for (uintN i = 0; i < n; i++) {
|
2007-03-22 10:30:00 -07:00
|
|
|
/* Collect the lengths for all the function-argument arguments. */
|
2011-09-08 21:02:26 -07:00
|
|
|
JSString *arg = js_ValueToString(cx, args[i]);
|
2007-03-22 10:30:00 -07:00
|
|
|
if (!arg)
|
2011-03-23 14:33:02 -07:00
|
|
|
return false;
|
2011-09-08 21:02:26 -07:00
|
|
|
args[i].setString(arg);
|
2007-03-22 10:30:00 -07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Check for overflow. The < test works because the maximum
|
|
|
|
* JSString length fits in 2 fewer bits than size_t has.
|
|
|
|
*/
|
2010-08-16 12:35:04 -07:00
|
|
|
size_t old_args_length = args_length;
|
2009-06-10 18:29:44 -07:00
|
|
|
args_length = old_args_length + arg->length();
|
2007-03-22 10:30:00 -07:00
|
|
|
if (args_length < old_args_length) {
|
2008-03-12 16:07:47 -07:00
|
|
|
js_ReportAllocationOverflow(cx);
|
2011-03-23 14:33:02 -07:00
|
|
|
return false;
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Add 1 for each joining comma and check for overflow (two ways). */
|
2010-08-16 12:35:04 -07:00
|
|
|
size_t old_args_length = args_length;
|
2007-03-22 10:30:00 -07:00
|
|
|
args_length = old_args_length + n - 1;
|
|
|
|
if (args_length < old_args_length ||
|
|
|
|
args_length >= ~(size_t)0 / sizeof(jschar)) {
|
2008-03-12 16:07:47 -07:00
|
|
|
js_ReportAllocationOverflow(cx);
|
2011-03-23 14:33:02 -07:00
|
|
|
return false;
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Allocate a string to hold the concatenated arguments, including room
|
2011-10-21 16:53:30 -07:00
|
|
|
* for a terminating 0. Mark cx->tempLifeAlloc for later release, to
|
|
|
|
* free collected_args and its tokenstream in one swoop.
|
2007-03-22 10:30:00 -07:00
|
|
|
*/
|
2011-09-22 13:22:30 -07:00
|
|
|
LifoAllocScope las(&cx->tempLifoAlloc());
|
|
|
|
jschar *cp = cx->tempLifoAlloc().newArray<jschar>(args_length + 1);
|
2007-03-22 10:30:00 -07:00
|
|
|
if (!cp) {
|
2011-06-03 17:54:26 -07:00
|
|
|
js_ReportOutOfMemory(cx);
|
2011-03-23 14:33:02 -07:00
|
|
|
return false;
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
2010-08-16 12:35:04 -07:00
|
|
|
jschar *collected_args = cp;
|
2007-03-22 10:30:00 -07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Concatenate the arguments into the new string, separated by commas.
|
|
|
|
*/
|
2010-08-16 12:35:04 -07:00
|
|
|
for (uintN i = 0; i < n; i++) {
|
2011-09-08 21:02:26 -07:00
|
|
|
JSString *arg = args[i].toString();
|
2010-08-16 12:35:04 -07:00
|
|
|
size_t arg_length = arg->length();
|
2010-12-06 10:26:58 -08:00
|
|
|
const jschar *arg_chars = arg->getChars(cx);
|
2011-03-23 14:33:02 -07:00
|
|
|
if (!arg_chars)
|
|
|
|
return false;
|
2010-12-06 10:26:58 -08:00
|
|
|
(void) js_strncpy(cp, arg_chars, arg_length);
|
2007-03-22 10:30:00 -07:00
|
|
|
cp += arg_length;
|
|
|
|
|
|
|
|
/* Add separating comma or terminating 0. */
|
|
|
|
*cp++ = (i + 1 < n) ? ',' : 0;
|
|
|
|
}
|
|
|
|
|
2007-10-02 16:10:09 -07:00
|
|
|
/* Initialize a tokenstream that reads from the given string. */
|
2010-08-16 12:35:04 -07:00
|
|
|
TokenStream ts(cx);
|
2011-03-23 14:33:02 -07:00
|
|
|
if (!ts.init(collected_args, args_length, filename, lineno, cx->findVersion()))
|
|
|
|
return false;
|
2007-03-22 10:30:00 -07:00
|
|
|
|
|
|
|
/* The argument string may be empty or contain no tokens. */
|
2010-08-16 12:35:04 -07:00
|
|
|
TokenKind tt = ts.getToken();
|
2007-03-22 10:30:00 -07:00
|
|
|
if (tt != TOK_EOF) {
|
|
|
|
for (;;) {
|
|
|
|
/*
|
|
|
|
* Check that it's a name. This also implicitly guards against
|
|
|
|
* TOK_ERROR, which was already reported.
|
|
|
|
*/
|
|
|
|
if (tt != TOK_NAME)
|
2011-03-23 14:33:02 -07:00
|
|
|
return OnBadFormal(cx, tt);
|
2007-03-22 10:30:00 -07:00
|
|
|
|
2007-11-19 09:15:45 -08:00
|
|
|
/* Check for a duplicate parameter name. */
|
2011-10-08 15:45:29 -07:00
|
|
|
PropertyName *name = ts.currentToken().name();
|
|
|
|
if (bindings.hasBinding(cx, name)) {
|
|
|
|
JSAutoByteString bytes;
|
|
|
|
if (!js_AtomToPrintableString(cx, name, &bytes))
|
2011-03-23 14:33:02 -07:00
|
|
|
return false;
|
2010-11-11 12:40:29 -08:00
|
|
|
if (!ReportCompileErrorNumber(cx, &ts, NULL,
|
|
|
|
JSREPORT_WARNING | JSREPORT_STRICT,
|
2011-10-08 15:45:29 -07:00
|
|
|
JSMSG_DUPLICATE_FORMAL, bytes.ptr()))
|
|
|
|
{
|
2011-03-23 14:33:02 -07:00
|
|
|
return false;
|
2010-08-16 12:35:04 -07:00
|
|
|
}
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
2010-11-16 15:34:24 -08:00
|
|
|
|
|
|
|
uint16 dummy;
|
2011-10-08 15:45:29 -07:00
|
|
|
if (!bindings.addArgument(cx, name, &dummy))
|
2011-03-23 14:33:02 -07:00
|
|
|
return false;
|
2007-03-22 10:30:00 -07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Get the next token. Stop on end of stream. Otherwise
|
|
|
|
* insist on a comma, get another name, and iterate.
|
|
|
|
*/
|
2010-03-23 17:30:36 -07:00
|
|
|
tt = ts.getToken();
|
2007-03-22 10:30:00 -07:00
|
|
|
if (tt == TOK_EOF)
|
|
|
|
break;
|
|
|
|
if (tt != TOK_COMMA)
|
2011-03-23 14:33:02 -07:00
|
|
|
return OnBadFormal(cx, tt);
|
2010-03-23 17:30:36 -07:00
|
|
|
tt = ts.getToken();
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-03-23 14:33:02 -07:00
|
|
|
JS::Anchor<JSString *> strAnchor(NULL);
|
|
|
|
const jschar *chars;
|
|
|
|
size_t length;
|
|
|
|
|
2011-09-08 21:02:26 -07:00
|
|
|
if (args.length()) {
|
|
|
|
JSString *str = js_ValueToString(cx, args[args.length() - 1]);
|
2007-07-28 09:57:30 -07:00
|
|
|
if (!str)
|
2011-03-23 14:33:02 -07:00
|
|
|
return false;
|
|
|
|
strAnchor.set(str);
|
|
|
|
chars = str->getChars(cx);
|
|
|
|
length = str->length();
|
2007-03-22 10:30:00 -07:00
|
|
|
} else {
|
2011-03-23 14:33:02 -07:00
|
|
|
chars = cx->runtime->emptyString->chars();
|
|
|
|
length = 0;
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
|
|
|
|
2011-08-21 07:23:48 -07:00
|
|
|
/*
|
|
|
|
* NB: (new Function) is not lexically closed by its caller, it's just an
|
|
|
|
* anonymous function in the top-level scope that its constructor inhabits.
|
|
|
|
* Thus 'var x = 42; f = new Function("return x"); print(f())' prints 42,
|
|
|
|
* and so would a call to f from another top-level's script or function.
|
|
|
|
*/
|
|
|
|
JSFunction *fun = js_NewFunction(cx, NULL, NULL, 0, JSFUN_LAMBDA | JSFUN_INTERPRETED,
|
|
|
|
global, cx->runtime->atomState.anonymousAtom);
|
|
|
|
if (!fun)
|
|
|
|
return false;
|
|
|
|
|
2011-09-08 21:02:26 -07:00
|
|
|
JSPrincipals *principals = PrincipalsForCompiledCode(args, cx);
|
2011-10-27 15:03:54 -07:00
|
|
|
bool ok = frontend::CompileFunctionBody(cx, fun, principals, &bindings, chars, length,
|
|
|
|
filename, lineno, cx->findVersion());
|
2011-09-08 21:02:26 -07:00
|
|
|
args.rval().setObject(*fun);
|
2011-04-08 10:52:51 -07:00
|
|
|
return ok;
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
|
|
|
|
2011-03-02 19:57:44 -08:00
|
|
|
bool
|
2011-01-26 18:28:49 -08:00
|
|
|
IsBuiltinFunctionConstructor(JSFunction *fun)
|
|
|
|
{
|
|
|
|
return fun->maybeNative() == Function;
|
|
|
|
}
|
|
|
|
|
2011-02-14 12:04:07 -08:00
|
|
|
const Shape *
|
|
|
|
LookupInterpretedFunctionPrototype(JSContext *cx, JSObject *funobj)
|
|
|
|
{
|
2011-02-15 12:07:23 -08:00
|
|
|
#ifdef DEBUG
|
2011-10-11 15:28:54 -07:00
|
|
|
JSFunction *fun = funobj->toFunction();
|
2011-02-14 12:04:07 -08:00
|
|
|
JS_ASSERT(fun->isInterpreted());
|
|
|
|
JS_ASSERT(!fun->isFunctionPrototype());
|
|
|
|
JS_ASSERT(!funobj->isBoundFunction());
|
2011-02-15 12:07:23 -08:00
|
|
|
#endif
|
2011-02-14 12:04:07 -08:00
|
|
|
|
|
|
|
jsid id = ATOM_TO_JSID(cx->runtime->atomState.classPrototypeAtom);
|
2011-08-16 03:27:34 -07:00
|
|
|
const Shape *shape = funobj->nativeLookup(cx, id);
|
2011-02-14 12:04:07 -08:00
|
|
|
if (!shape) {
|
|
|
|
if (!ResolveInterpretedFunctionPrototype(cx, funobj))
|
2011-04-14 13:45:06 -07:00
|
|
|
return NULL;
|
2011-08-16 03:27:34 -07:00
|
|
|
shape = funobj->nativeLookup(cx, id);
|
2011-02-14 12:04:07 -08:00
|
|
|
}
|
|
|
|
JS_ASSERT(!shape->configurable());
|
|
|
|
JS_ASSERT(shape->isDataDescriptor());
|
|
|
|
JS_ASSERT(shape->hasSlot());
|
|
|
|
JS_ASSERT(!shape->isMethod());
|
|
|
|
return shape;
|
|
|
|
}
|
|
|
|
|
2011-02-23 19:38:27 -08:00
|
|
|
} /* namespace js */
|
2011-01-26 18:28:49 -08:00
|
|
|
|
2008-03-29 03:34:29 -07:00
|
|
|
JSFunction *
|
2010-07-14 23:19:36 -07:00
|
|
|
js_NewFunction(JSContext *cx, JSObject *funobj, Native native, uintN nargs,
|
2011-10-26 13:02:57 -07:00
|
|
|
uintN flags, JSObject *parent, JSAtom *atom, js::gc::AllocKind kind)
|
2007-03-22 10:30:00 -07:00
|
|
|
{
|
2011-11-18 15:20:21 -08:00
|
|
|
JS_ASSERT(kind == JSFunction::FinalizeKind || kind == JSFunction::ExtendedFinalizeKind);
|
|
|
|
JS_ASSERT(sizeof(JSFunction) <= gc::Arena::thingSize(JSFunction::FinalizeKind));
|
|
|
|
JS_ASSERT(sizeof(FunctionExtended) <= gc::Arena::thingSize(JSFunction::ExtendedFinalizeKind));
|
|
|
|
|
2008-03-29 03:34:29 -07:00
|
|
|
JSFunction *fun;
|
2007-03-22 10:30:00 -07:00
|
|
|
|
|
|
|
if (funobj) {
|
2010-03-31 22:13:51 -07:00
|
|
|
JS_ASSERT(funobj->isFunction());
|
2011-10-13 12:10:52 -07:00
|
|
|
JS_ASSERT(funobj->getParent() == parent);
|
2007-03-22 10:30:00 -07:00
|
|
|
} else {
|
2011-11-02 13:34:19 -07:00
|
|
|
funobj = NewObjectWithClassProto(cx, &FunctionClass, NULL, SkipScopeParent(parent), kind);
|
2007-03-22 10:30:00 -07:00
|
|
|
if (!funobj)
|
|
|
|
return NULL;
|
|
|
|
}
|
2011-08-21 07:23:48 -07:00
|
|
|
fun = static_cast<JSFunction *>(funobj);
|
2007-03-22 10:30:00 -07:00
|
|
|
|
|
|
|
/* Initialize all function members. */
|
2010-03-04 20:44:09 -08:00
|
|
|
fun->nargs = uint16(nargs);
|
2011-10-26 13:02:57 -07:00
|
|
|
fun->flags = flags & (JSFUN_FLAGS_MASK | JSFUN_KINDMASK);
|
2009-04-05 21:17:22 -07:00
|
|
|
if ((flags & JSFUN_KINDMASK) >= JSFUN_INTERPRETED) {
|
2008-03-29 03:34:29 -07:00
|
|
|
JS_ASSERT(!native);
|
2011-10-25 16:07:42 -07:00
|
|
|
fun->script().init(NULL);
|
2011-11-08 13:42:27 -08:00
|
|
|
fun->setEnvironment(parent);
|
2008-03-29 03:34:29 -07:00
|
|
|
} else {
|
2009-03-03 22:53:27 -08:00
|
|
|
fun->u.n.clasp = NULL;
|
2009-09-04 13:44:31 -07:00
|
|
|
if (flags & JSFUN_TRCINFO) {
|
2008-10-08 15:08:33 -07:00
|
|
|
#ifdef JS_TRACER
|
2009-09-04 13:44:31 -07:00
|
|
|
JSNativeTraceInfo *trcinfo =
|
|
|
|
JS_FUNC_TO_DATA_PTR(JSNativeTraceInfo *, native);
|
2011-09-20 11:40:24 -07:00
|
|
|
fun->u.n.native = (Native) trcinfo->native;
|
2008-10-08 15:08:33 -07:00
|
|
|
#endif
|
|
|
|
} else {
|
|
|
|
fun->u.n.native = native;
|
|
|
|
}
|
2009-05-05 14:26:06 -07:00
|
|
|
JS_ASSERT(fun->u.n.native);
|
2008-03-29 03:34:29 -07:00
|
|
|
}
|
2011-10-28 08:43:04 -07:00
|
|
|
if (kind == JSFunction::ExtendedFinalizeKind) {
|
|
|
|
fun->flags |= JSFUN_EXTENDED;
|
2011-11-14 09:13:33 -08:00
|
|
|
fun->initializeExtended();
|
2011-10-28 08:43:04 -07:00
|
|
|
}
|
2008-03-29 03:34:29 -07:00
|
|
|
fun->atom = atom;
|
2007-03-22 10:30:00 -07:00
|
|
|
|
2011-10-30 08:27:19 -07:00
|
|
|
if (native && !fun->setSingletonType(cx))
|
|
|
|
return NULL;
|
|
|
|
|
2008-03-29 03:34:29 -07:00
|
|
|
return fun;
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
|
|
|
|
2011-10-11 15:28:54 -07:00
|
|
|
JSFunction * JS_FASTCALL
|
2010-02-19 09:44:23 -08:00
|
|
|
js_CloneFunctionObject(JSContext *cx, JSFunction *fun, JSObject *parent,
|
2011-10-26 13:02:57 -07:00
|
|
|
JSObject *proto, gc::AllocKind kind)
|
2007-11-18 06:10:28 -08:00
|
|
|
{
|
2010-02-19 09:44:23 -08:00
|
|
|
JS_ASSERT(parent);
|
|
|
|
JS_ASSERT(proto);
|
|
|
|
|
2011-11-02 13:34:19 -07:00
|
|
|
JSObject *cloneobj = NewObjectWithClassProto(cx, &FunctionClass, NULL, SkipScopeParent(parent), kind);
|
|
|
|
if (!cloneobj)
|
2011-10-11 15:28:54 -07:00
|
|
|
return NULL;
|
2011-11-02 13:34:19 -07:00
|
|
|
JSFunction *clone = static_cast<JSFunction *>(cloneobj);
|
2011-10-11 15:28:54 -07:00
|
|
|
|
|
|
|
clone->nargs = fun->nargs;
|
2011-10-26 13:02:57 -07:00
|
|
|
clone->flags = fun->flags & ~JSFUN_EXTENDED;
|
2011-10-11 15:28:54 -07:00
|
|
|
clone->u = fun->toFunction()->u;
|
|
|
|
clone->atom = fun->atom;
|
2011-03-17 09:42:56 -07:00
|
|
|
|
2011-10-26 13:02:57 -07:00
|
|
|
if (kind == JSFunction::ExtendedFinalizeKind) {
|
|
|
|
clone->flags |= JSFUN_EXTENDED;
|
2011-11-14 09:13:33 -08:00
|
|
|
clone->initializeExtended();
|
2011-10-26 13:02:57 -07:00
|
|
|
}
|
|
|
|
|
2011-10-13 12:10:52 -07:00
|
|
|
if (clone->isInterpreted())
|
2011-11-08 13:42:27 -08:00
|
|
|
clone->setEnvironment(parent);
|
2011-10-13 12:10:52 -07:00
|
|
|
|
2011-10-11 15:28:54 -07:00
|
|
|
if (cx->compartment == fun->compartment()) {
|
2011-03-17 09:42:56 -07:00
|
|
|
/*
|
2011-06-03 20:48:16 -07:00
|
|
|
* We can use the same type as the original function provided that (a)
|
|
|
|
* its prototype is correct, and (b) its type is not a singleton. The
|
|
|
|
* first case will hold in all compileAndGo code, and the second case
|
|
|
|
* will have been caught by CloneFunctionObject coming from function
|
|
|
|
* definitions or read barriers, so will not get here.
|
2011-03-17 09:42:56 -07:00
|
|
|
*/
|
2011-07-15 10:14:07 -07:00
|
|
|
if (fun->getProto() == proto && !fun->hasSingletonType())
|
2011-07-28 14:17:42 -07:00
|
|
|
clone->setType(fun->type());
|
2010-09-29 23:17:29 -07:00
|
|
|
} else {
|
|
|
|
/*
|
2011-10-11 15:28:54 -07:00
|
|
|
* Across compartments we have to clone the script for interpreted
|
|
|
|
* functions.
|
2010-09-29 23:17:29 -07:00
|
|
|
*/
|
2011-10-11 15:28:54 -07:00
|
|
|
if (clone->isInterpreted()) {
|
|
|
|
JSScript *script = clone->script();
|
2010-09-29 23:17:29 -07:00
|
|
|
JS_ASSERT(script);
|
2011-08-09 01:51:59 -07:00
|
|
|
JS_ASSERT(script->compartment() == fun->compartment());
|
|
|
|
JS_ASSERT(script->compartment() != cx->compartment);
|
2010-11-16 15:30:56 -08:00
|
|
|
|
2011-11-14 09:13:33 -08:00
|
|
|
clone->script().init(NULL);
|
2011-08-02 10:13:03 -07:00
|
|
|
JSScript *cscript = js_CloneScript(cx, script);
|
|
|
|
if (!cscript)
|
2010-11-16 15:30:56 -08:00
|
|
|
return NULL;
|
2011-08-09 13:29:11 -07:00
|
|
|
|
2011-11-14 09:13:33 -08:00
|
|
|
cscript->globalObject = clone->getGlobal();
|
2011-10-19 14:26:08 -07:00
|
|
|
clone->setScript(cscript);
|
2011-11-14 09:13:33 -08:00
|
|
|
if (!cscript->typeSetFunction(cx, clone))
|
2011-03-07 08:25:27 -08:00
|
|
|
return NULL;
|
|
|
|
|
2011-10-11 15:28:54 -07:00
|
|
|
js_CallNewScriptHook(cx, clone->script(), clone);
|
2011-10-27 14:16:02 -07:00
|
|
|
Debugger::onNewScript(cx, clone->script(), NULL);
|
2010-09-29 23:17:29 -07:00
|
|
|
}
|
|
|
|
}
|
2008-04-02 00:46:12 -07:00
|
|
|
return clone;
|
2008-03-29 03:34:29 -07:00
|
|
|
}
|
|
|
|
|
2009-06-03 11:19:20 -07:00
|
|
|
/*
|
|
|
|
* Create a new flat closure, but don't initialize the imported upvar
|
|
|
|
* values. The tracer calls this function and then initializes the upvar
|
|
|
|
* slots on trace.
|
|
|
|
*/
|
2011-10-26 13:02:57 -07:00
|
|
|
JSFunction * JS_FASTCALL
|
2009-06-03 11:19:20 -07:00
|
|
|
js_AllocFlatClosure(JSContext *cx, JSFunction *fun, JSObject *scopeChain)
|
2009-04-05 21:17:22 -07:00
|
|
|
{
|
2010-11-16 15:34:24 -08:00
|
|
|
JS_ASSERT(fun->isFlatClosure());
|
|
|
|
JS_ASSERT(JSScript::isValidOffset(fun->script()->upvarsOffset) ==
|
|
|
|
fun->script()->bindings.hasUpvars());
|
|
|
|
JS_ASSERT_IF(JSScript::isValidOffset(fun->script()->upvarsOffset),
|
|
|
|
fun->script()->upvars()->length == fun->script()->bindings.countUpvars());
|
2009-04-05 21:17:22 -07:00
|
|
|
|
2011-10-26 13:02:57 -07:00
|
|
|
JSFunction *closure = CloneFunctionObject(cx, fun, scopeChain, JSFunction::ExtendedFinalizeKind);
|
2009-07-31 11:34:33 -07:00
|
|
|
if (!closure)
|
2009-04-05 21:17:22 -07:00
|
|
|
return closure;
|
2009-07-31 11:34:33 -07:00
|
|
|
|
2010-11-16 15:34:24 -08:00
|
|
|
uint32 nslots = fun->script()->bindings.countUpvars();
|
2010-06-18 17:43:02 -07:00
|
|
|
if (nslots == 0)
|
2009-07-31 11:34:33 -07:00
|
|
|
return closure;
|
2010-08-29 11:57:08 -07:00
|
|
|
|
2011-11-14 09:13:33 -08:00
|
|
|
HeapValue *data = (HeapValue *) cx->malloc_(nslots * sizeof(HeapValue));
|
2011-10-25 16:07:42 -07:00
|
|
|
if (!data)
|
2009-04-05 21:17:22 -07:00
|
|
|
return NULL;
|
|
|
|
|
2011-11-14 09:13:33 -08:00
|
|
|
closure->setExtendedSlot(JSFunction::FLAT_CLOSURE_UPVARS_SLOT, PrivateValue(data));
|
2009-06-03 11:19:20 -07:00
|
|
|
return closure;
|
|
|
|
}
|
|
|
|
|
2011-10-26 13:02:57 -07:00
|
|
|
JSFunction *
|
2010-10-06 10:41:36 -07:00
|
|
|
js_NewFlatClosure(JSContext *cx, JSFunction *fun, JSOp op, size_t oplen)
|
2009-06-03 11:19:20 -07:00
|
|
|
{
|
2010-02-11 14:56:59 -08:00
|
|
|
/*
|
2010-12-29 23:46:50 -08:00
|
|
|
* Flat closures cannot yet be partial, that is, all upvars must be copied,
|
|
|
|
* or the closure won't be flattened. Therefore they do not need to search
|
|
|
|
* enclosing scope objects via JSOP_NAME, etc.
|
|
|
|
*
|
|
|
|
* FIXME: bug 545759 proposes to enable partial flat closures. Fixing this
|
|
|
|
* bug requires a GetScopeChainFast call here, along with JS_REQUIRES_STACK
|
|
|
|
* annotations on this function's prototype and definition.
|
2010-02-11 14:56:59 -08:00
|
|
|
*/
|
2010-12-29 23:46:50 -08:00
|
|
|
VOUCH_DOES_NOT_REQUIRE_STACK();
|
|
|
|
JSObject *scopeChain = &cx->fp()->scopeChain();
|
2010-02-11 14:56:59 -08:00
|
|
|
|
2011-10-26 13:02:57 -07:00
|
|
|
JSFunction *closure = js_AllocFlatClosure(cx, fun, scopeChain);
|
2010-11-16 15:34:24 -08:00
|
|
|
if (!closure || !fun->script()->bindings.hasUpvars())
|
2009-06-08 12:13:37 -07:00
|
|
|
return closure;
|
2009-06-03 11:19:20 -07:00
|
|
|
|
2011-05-20 11:27:27 -07:00
|
|
|
uintN level = fun->script()->staticLevel;
|
2010-11-16 15:34:24 -08:00
|
|
|
JSUpvarArray *uva = fun->script()->upvars();
|
2009-04-05 21:17:22 -07:00
|
|
|
|
2011-08-17 06:48:14 -07:00
|
|
|
for (uint32 i = 0, n = uva->length; i < n; i++)
|
2011-11-14 09:13:33 -08:00
|
|
|
closure->initFlatClosureUpvar(i, GetUpvar(cx, level, uva->vector[i]));
|
2009-04-05 21:17:22 -07:00
|
|
|
|
|
|
|
return closure;
|
|
|
|
}
|
|
|
|
|
2008-03-29 03:34:29 -07:00
|
|
|
JSFunction *
|
2010-10-28 08:15:53 -07:00
|
|
|
js_DefineFunction(JSContext *cx, JSObject *obj, jsid id, Native native,
|
2011-10-26 13:02:57 -07:00
|
|
|
uintN nargs, uintN attrs, AllocKind kind)
|
2007-03-22 10:30:00 -07:00
|
|
|
{
|
2011-02-09 11:31:40 -08:00
|
|
|
PropertyOp gop;
|
|
|
|
StrictPropertyOp sop;
|
2009-04-05 21:17:22 -07:00
|
|
|
JSFunction *fun;
|
2007-03-22 10:30:00 -07:00
|
|
|
|
2009-04-05 21:17:22 -07:00
|
|
|
if (attrs & JSFUN_STUB_GSOPS) {
|
|
|
|
/*
|
|
|
|
* JSFUN_STUB_GSOPS is a request flag only, not stored in fun->flags or
|
|
|
|
* the defined property's attributes. This allows us to encode another,
|
|
|
|
* internal flag using the same bit, JSFUN_EXPR_CLOSURE -- see jsfun.h
|
|
|
|
* for more on this.
|
|
|
|
*/
|
|
|
|
attrs &= ~JSFUN_STUB_GSOPS;
|
2011-09-20 11:40:24 -07:00
|
|
|
gop = JS_PropertyStub;
|
|
|
|
sop = JS_StrictPropertyStub;
|
2009-04-05 21:17:22 -07:00
|
|
|
} else {
|
2011-02-09 11:31:40 -08:00
|
|
|
gop = NULL;
|
|
|
|
sop = NULL;
|
2009-04-05 21:17:22 -07:00
|
|
|
}
|
2010-11-09 12:09:07 -08:00
|
|
|
|
2010-08-03 12:20:48 -07:00
|
|
|
fun = js_NewFunction(cx, NULL, native, nargs,
|
2010-08-16 12:35:04 -07:00
|
|
|
attrs & (JSFUN_FLAGS_MASK | JSFUN_TRCINFO),
|
2010-11-10 10:59:02 -08:00
|
|
|
obj,
|
2011-10-26 13:02:57 -07:00
|
|
|
JSID_IS_ATOM(id) ? JSID_TO_ATOM(id) : NULL,
|
|
|
|
kind);
|
2007-03-22 10:30:00 -07:00
|
|
|
if (!fun)
|
|
|
|
return NULL;
|
2010-11-10 10:59:02 -08:00
|
|
|
|
2011-10-05 01:00:23 -07:00
|
|
|
if (!obj->defineGeneric(cx, id, ObjectValue(*fun), gop, sop, attrs & ~JSFUN_FLAGS_MASK))
|
2007-03-22 10:30:00 -07:00
|
|
|
return NULL;
|
2010-10-29 08:05:55 -07:00
|
|
|
|
2007-03-22 10:30:00 -07:00
|
|
|
return fun;
|
|
|
|
}
|
|
|
|
|
2011-04-13 09:27:37 -07:00
|
|
|
JS_STATIC_ASSERT((JSV2F_CONSTRUCT & JSV2F_SEARCH_STACK) == 0);
|
2007-03-22 10:30:00 -07:00
|
|
|
|
|
|
|
JSFunction *
|
2010-07-14 23:19:36 -07:00
|
|
|
js_ValueToFunction(JSContext *cx, const Value *vp, uintN flags)
|
2007-03-22 10:30:00 -07:00
|
|
|
{
|
2011-10-11 15:28:54 -07:00
|
|
|
JSFunction *fun;
|
|
|
|
if (!IsFunctionObject(*vp, &fun)) {
|
2010-08-17 09:44:41 -07:00
|
|
|
js_ReportIsNotFunction(cx, vp, flags);
|
2007-03-22 10:30:00 -07:00
|
|
|
return NULL;
|
|
|
|
}
|
2011-10-11 15:28:54 -07:00
|
|
|
return fun;
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
JSObject *
|
2010-07-14 23:19:36 -07:00
|
|
|
js_ValueToCallableObject(JSContext *cx, Value *vp, uintN flags)
|
2007-03-22 10:30:00 -07:00
|
|
|
{
|
2010-07-14 23:19:36 -07:00
|
|
|
if (vp->isObject()) {
|
|
|
|
JSObject *callable = &vp->toObject();
|
|
|
|
if (callable->isCallable())
|
|
|
|
return callable;
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
2010-08-17 09:44:41 -07:00
|
|
|
|
|
|
|
js_ReportIsNotFunction(cx, vp, flags);
|
|
|
|
return NULL;
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2010-07-14 23:19:36 -07:00
|
|
|
js_ReportIsNotFunction(JSContext *cx, const Value *vp, uintN flags)
|
2007-03-22 10:30:00 -07:00
|
|
|
{
|
2010-03-03 18:10:13 -08:00
|
|
|
const char *name = NULL, *source = NULL;
|
2010-03-28 22:05:50 -07:00
|
|
|
AutoValueRooter tvr(cx);
|
2010-05-29 19:04:01 -07:00
|
|
|
uintN error = (flags & JSV2F_CONSTRUCT) ? JSMSG_NOT_CONSTRUCTOR : JSMSG_NOT_FUNCTION;
|
2010-03-03 18:10:13 -08:00
|
|
|
LeaveTrace(cx);
|
2010-07-30 14:49:29 -07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* We try to the print the code that produced vp if vp is a value in the
|
|
|
|
* most recent interpreted stack frame. Note that additional values, not
|
|
|
|
* directly produced by the script, may have been pushed onto the frame's
|
2010-09-02 16:03:11 -07:00
|
|
|
* expression stack (e.g. by pushInvokeArgs) thereby incrementing sp past
|
2011-01-03 09:06:35 -08:00
|
|
|
* the depth simulated by ReconstructPCStack.
|
|
|
|
*
|
|
|
|
* Conversely, values may have been popped from the stack in preparation
|
|
|
|
* for a call (e.g., by SplatApplyArgs). Since we must pass an offset from
|
|
|
|
* the top of the simulated stack to js_ReportValueError3, we do bounds
|
|
|
|
* checking using the minimum of both the simulated and actual stack depth.
|
2010-07-30 14:49:29 -07:00
|
|
|
*/
|
|
|
|
ptrdiff_t spindex = 0;
|
|
|
|
|
2010-03-03 18:10:13 -08:00
|
|
|
FrameRegsIter i(cx);
|
2010-07-30 14:49:29 -07:00
|
|
|
if (!i.done()) {
|
2010-08-09 22:43:33 -07:00
|
|
|
uintN depth = js_ReconstructStackDepth(cx, i.fp()->script(), i.pc());
|
2010-07-30 14:49:29 -07:00
|
|
|
Value *simsp = i.fp()->base() + depth;
|
2011-01-03 09:06:35 -08:00
|
|
|
if (i.fp()->base() <= vp && vp < Min(simsp, i.sp()))
|
2010-07-30 14:49:29 -07:00
|
|
|
spindex = vp - simsp;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!spindex)
|
|
|
|
spindex = ((flags & JSV2F_SEARCH_STACK) ? JSDVG_SEARCH_STACK : JSDVG_IGNORE_STACK);
|
2010-03-03 18:10:13 -08:00
|
|
|
|
|
|
|
js_ReportValueError3(cx, error, spindex, *vp, NULL, name, source);
|
2007-03-22 10:30:00 -07:00
|
|
|
}
|