Source/JavaScriptCore/runtime/JSFunction.cpp

   1 /*
   2  *  Copyright (C) 1999-2002 Harri Porten (porten@kde.org)
   3  *  Copyright (C) 2001 Peter Kelly (pmk@post.com)
   4  *  Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
   5  *  Copyright (C) 2007 Cameron Zwarich (cwzwarich@uwaterloo.ca)
   6  *  Copyright (C) 2007 Maks Orlovich
   7  *
   8  *  This library is free software; you can redistribute it and/or
   9  *  modify it under the terms of the GNU Library General Public
  10  *  License as published by the Free Software Foundation; either
  11  *  version 2 of the License, or (at your option) any later version.
  12  *
  13  *  This library is distributed in the hope that it will be useful,
  14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  *  Library General Public License for more details.
  17  *
  18  *  You should have received a copy of the GNU Library General Public License
  19  *  along with this library; see the file COPYING.LIB.  If not, write to
  20  *  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  21  *  Boston, MA 02110-1301, USA.
  22  *
  23  */
  24
  25 #include "config.h"
  26 #include "JSFunction.h"
  27
  28 #include "CodeBlock.h"
  29 #include "CommonIdentifiers.h"
  30 #include "CallFrame.h"
  31 #include "ExceptionHelpers.h"
  32 #include "FunctionPrototype.h"
  33 #include "JSGlobalObject.h"
  34 #include "JSNotAnObject.h"
  35 #include "Interpreter.h"
  36 #include "ObjectPrototype.h"
  37 #include "Parser.h"
  38 #include "PropertyNameArray.h"
  39 #include "ScopeChainMark.h"
  40
  41 using namespace WTF;
  42 using namespace Unicode;
  43
  44 namespace JSC {
  45 EncodedJSValue JSC_HOST_CALL callHostFunctionAsConstructor(ExecState* exec)
  46 {
  47     return throwVMError(exec, createNotAConstructorError(exec, exec->callee()));
  48 }
  49
  50 ASSERT_CLASS_FITS_IN_CELL(JSFunction);
  51
  52 const ClassInfo JSFunction::s_info = { "Function", &Base::s_info, 0, 0 };
  53
  54 bool JSFunction::isHostFunctionNonInline() const
  55 {
  56     return isHostFunction();
  57 }
  58
  59 JSFunction::JSFunction(VPtrStealingHackType)
  60     : Base(VPtrStealingHack)
  61 {
  62 }
  63
  64 JSFunction::JSFunction(ExecState* exec, JSGlobalObject* globalObject, Structure* structure, int length, const Identifier& name, NativeExecutable* thunk)
  65     : Base(globalObject, structure)
  66     , m_executable(exec->globalData(), this, thunk)
  67     , m_scopeChain(exec->globalData(), this, globalObject->globalScopeChain())
  68 {
  69     ASSERT(inherits(&s_info));
  70     putDirect(exec->globalData(), exec->globalData().propertyNames->name, jsString(exec, name.isNull() ? "" : name.ustring()), DontDelete | ReadOnly | DontEnum);
  71     putDirect(exec->globalData(), exec->propertyNames().length, jsNumber(length), DontDelete | ReadOnly | DontEnum);
  72 }
  73
  74 JSFunction::JSFunction(ExecState* exec, JSGlobalObject* globalObject, Structure* structure, int length, const Identifier& name, NativeFunction func)
  75     : Base(globalObject, structure)
  76     , m_scopeChain(exec->globalData(), this, globalObject->globalScopeChain())
  77 {
  78     ASSERT(inherits(&s_info));
  79     // We separate out intialisation from setting the executable
  80     // as getHostFunction may perform a GC allocation, so we have to be able to
  81     // mark ourselves safely
  82     m_executable.set(exec->globalData(), this, exec->globalData().getHostFunction(func));
  83     putDirect(exec->globalData(), exec->globalData().propertyNames->name, jsString(exec, name.isNull() ? "" : name.ustring()), DontDelete | ReadOnly | DontEnum);
  84     putDirect(exec->globalData(), exec->propertyNames().length, jsNumber(length), DontDelete | ReadOnly | DontEnum);
  85 }
  86
  87 JSFunction::JSFunction(ExecState* exec, FunctionExecutable* executable, ScopeChainNode* scopeChainNode)
  88     : Base(scopeChainNode->globalObject.get(), scopeChainNode->globalObject->functionStructure())
  89     , m_executable(exec->globalData(), this, executable)
  90     , m_scopeChain(exec->globalData(), this, scopeChainNode)
  91 {
  92     ASSERT(inherits(&s_info));
  93     const Identifier& name = static_cast<FunctionExecutable*>(m_executable.get())->name();
  94     putDirect(exec->globalData(), exec->globalData().propertyNames->name, jsString(exec, name.isNull() ? "" : name.ustring()), DontDelete | ReadOnly | DontEnum);
  95 }
  96
  97 JSFunction::~JSFunction()
  98 {
  99     ASSERT(vptr() == JSGlobalData::jsFunctionVPtr);
 100 }
 101
 102 static const char* StrictModeCallerAccessError = "Cannot access caller property of a strict mode function";
 103 static const char* StrictModeArgumentsAccessError = "Cannot access arguments property of a strict mode function";
 104
 105 static void createDescriptorForThrowingProperty(ExecState* exec, PropertyDescriptor& descriptor, const char* message)
 106 {
 107     JSValue thrower = createTypeErrorFunction(exec, message);
 108     descriptor.setAccessorDescriptor(thrower, thrower, DontEnum | DontDelete | Getter | Setter);
 109 }
 110
 111 const UString& JSFunction::name(ExecState* exec)
 112 {
 113     return asString(getDirect(exec->globalData(), exec->globalData().propertyNames->name))->tryGetValue();
 114 }
 115
 116 const UString JSFunction::displayName(ExecState* exec)
 117 {
 118     JSValue displayName = getDirect(exec->globalData(), exec->globalData().propertyNames->displayName);
 119
 120     if (displayName && isJSString(&exec->globalData(), displayName))
 121         return asString(displayName)->tryGetValue();
 122
 123     return UString();
 124 }
 125
 126 const UString JSFunction::calculatedDisplayName(ExecState* exec)
 127 {
 128     const UString explicitName = displayName(exec);
 129
 130     if (!explicitName.isEmpty())
 131         return explicitName;
 132
 133     return name(exec);
 134 }
 135
 136 void JSFunction::markChildren(MarkStack& markStack)
 137 {
 138     Base::markChildren(markStack);
 139
 140     markStack.append(&m_scopeChain);
 141     if (m_executable) {
 142         // Delightful race condition: m_executable may not have been initialised
 143         // if this is a host function, as the executable isn't necessarily created
 144         // until after the function has been allocated.
 145         markStack.append(&m_executable);
 146     }
 147 }
 148
 149 CallType JSFunction::getCallData(CallData& callData)
 150 {
 151     if (isHostFunction()) {
 152         callData.native.function = nativeFunction();
 153         return CallTypeHost;
 154     }
 155     callData.js.functionExecutable = jsExecutable();
 156     callData.js.scopeChain = scope();
 157     return CallTypeJS;
 158 }
 159
 160 JSValue JSFunction::argumentsGetter(ExecState* exec, JSValue slotBase, const Identifier&)
 161 {
 162     JSFunction* thisObj = asFunction(slotBase);
 163     ASSERT(!thisObj->isHostFunction());
 164     return exec->interpreter()->retrieveArguments(exec, thisObj);
 165 }
 166
 167 JSValue JSFunction::callerGetter(ExecState* exec, JSValue slotBase, const Identifier&)
 168 {
 169     JSFunction* thisObj = asFunction(slotBase);
 170     ASSERT(!thisObj->isHostFunction());
 171     return exec->interpreter()->retrieveCaller(exec, thisObj);
 172 }
 173
 174 JSValue JSFunction::lengthGetter(ExecState*, JSValue slotBase, const Identifier&)
 175 {
 176     JSFunction* thisObj = asFunction(slotBase);
 177     ASSERT(!thisObj->isHostFunction());
 178     return jsNumber(thisObj->jsExecutable()->parameterCount());
 179 }
 180
 181 bool JSFunction::getOwnPropertySlot(ExecState* exec, const Identifier& propertyName, PropertySlot& slot)
 182 {
 183     if (isHostFunction())
 184         return Base::getOwnPropertySlot(exec, propertyName, slot);
 185
 186     if (propertyName == exec->propertyNames().prototype) {
 187         WriteBarrierBase<Unknown>* location = getDirectLocation(exec->globalData(), propertyName);
 188
 189         if (!location) {
 190             JSObject* prototype = constructEmptyObject(exec, scope()->globalObject->emptyObjectStructure());
 191             prototype->putDirect(exec->globalData(), exec->propertyNames().constructor, this, DontEnum);
 192             putDirect(exec->globalData(), exec->propertyNames().prototype, prototype, DontDelete | DontEnum);
 193             location = getDirectLocation(exec->globalData(), propertyName);
 194         }
 195
 196         slot.setValue(this, location->get(), offsetForLocation(location));
 197     }
 198
 199     if (propertyName == exec->propertyNames().arguments) {
 200         if (jsExecutable()->isStrictMode()) {
 201             throwTypeError(exec, "Can't access arguments object of a strict mode function");
 202             slot.setValue(jsNull());
 203             return true;
 204         }
 205
 206         slot.setCacheableCustom(this, argumentsGetter);
 207         return true;
 208     }
 209
 210     if (propertyName == exec->propertyNames().length) {
 211         slot.setCacheableCustom(this, lengthGetter);
 212         return true;
 213     }
 214
 215     if (propertyName == exec->propertyNames().caller) {
 216         if (jsExecutable()->isStrictMode()) {
 217             throwTypeError(exec, StrictModeCallerAccessError);
 218             slot.setValue(jsNull());
 219             return true;
 220         }
 221         slot.setCacheableCustom(this, callerGetter);
 222         return true;
 223     }
 224
 225     return Base::getOwnPropertySlot(exec, propertyName, slot);
 226 }
 227
 228 bool JSFunction::getOwnPropertyDescriptor(ExecState* exec, const Identifier& propertyName, PropertyDescriptor& descriptor)
 229 {
 230     if (isHostFunction())
 231         return Base::getOwnPropertyDescriptor(exec, propertyName, descriptor);
 232
 233     if (propertyName == exec->propertyNames().prototype) {
 234         PropertySlot slot;
 235         getOwnPropertySlot(exec, propertyName, slot);
 236         return Base::getOwnPropertyDescriptor(exec, propertyName, descriptor);
 237     }
 238
 239     if (propertyName == exec->propertyNames().arguments) {
 240         if (jsExecutable()->isStrictMode())
 241             createDescriptorForThrowingProperty(exec, descriptor, StrictModeArgumentsAccessError);
 242         else
 243             descriptor.setDescriptor(exec->interpreter()->retrieveArguments(exec, this), ReadOnly | DontEnum | DontDelete);
 244         return true;
 245     }
 246
 247     if (propertyName == exec->propertyNames().length) {
 248         descriptor.setDescriptor(jsNumber(jsExecutable()->parameterCount()), ReadOnly | DontEnum | DontDelete);
 249         return true;
 250     }
 251
 252     if (propertyName == exec->propertyNames().caller) {
 253         if (jsExecutable()->isStrictMode())
 254             createDescriptorForThrowingProperty(exec, descriptor, StrictModeCallerAccessError);
 255         else
 256             descriptor.setDescriptor(exec->interpreter()->retrieveCaller(exec, this), ReadOnly | DontEnum | DontDelete);
 257         return true;
 258     }
 259
 260     return Base::getOwnPropertyDescriptor(exec, propertyName, descriptor);
 261 }
 262
 263 void JSFunction::getOwnPropertyNames(ExecState* exec, PropertyNameArray& propertyNames, EnumerationMode mode)
 264 {
 265     if (!isHostFunction() && (mode == IncludeDontEnumProperties)) {
 266         // Make sure prototype has been reified.
 267         PropertySlot slot;
 268         getOwnPropertySlot(exec, exec->propertyNames().prototype, slot);
 269
 270         propertyNames.add(exec->propertyNames().arguments);
 271         propertyNames.add(exec->propertyNames().callee);
 272         propertyNames.add(exec->propertyNames().caller);
 273         propertyNames.add(exec->propertyNames().length);
 274     }
 275     Base::getOwnPropertyNames(exec, propertyNames, mode);
 276 }
 277
 278 void JSFunction::put(ExecState* exec, const Identifier& propertyName, JSValue value, PutPropertySlot& slot)
 279 {
 280     if (isHostFunction()) {
 281         Base::put(exec, propertyName, value, slot);
 282         return;
 283     }
 284     if (propertyName == exec->propertyNames().prototype) {
 285         // Make sure prototype has been reified, such that it can only be overwritten
 286         // following the rules set out in ECMA-262 8.12.9.
 287         PropertySlot slot;
 288         getOwnPropertySlot(exec, propertyName, slot);
 289     }
 290     if (jsExecutable()->isStrictMode()) {
 291         if (propertyName == exec->propertyNames().arguments) {
 292             throwTypeError(exec, StrictModeArgumentsAccessError);
 293             return;
 294         }
 295         if (propertyName == exec->propertyNames().caller) {
 296             throwTypeError(exec, StrictModeCallerAccessError);
 297             return;
 298         }
 299     }
 300     if (propertyName == exec->propertyNames().arguments || propertyName == exec->propertyNames().length)
 301         return;
 302     Base::put(exec, propertyName, value, slot);
 303 }
 304
 305 bool JSFunction::deleteProperty(ExecState* exec, const Identifier& propertyName)
 306 {
 307     if (isHostFunction())
 308         return Base::deleteProperty(exec, propertyName);
 309     if (propertyName == exec->propertyNames().arguments || propertyName == exec->propertyNames().length)
 310         return false;
 311     return Base::deleteProperty(exec, propertyName);
 312 }
 313
 314 // ECMA 13.2.2 [[Construct]]
 315 ConstructType JSFunction::getConstructData(ConstructData& constructData)
 316 {
 317     if (isHostFunction())
 318         return ConstructTypeNone;
 319     constructData.js.functionExecutable = jsExecutable();
 320     constructData.js.scopeChain = scope();
 321     return ConstructTypeJS;
 322 }
 323
 324 } // namespace JSC