runtime/JSGlobalObject.h

   1 /*
   2  *  Copyright (C) 2007 Eric Seidel <eric@webkit.org>
   3  *  Copyright (C) 2007, 2008 Apple Inc. All rights reserved.
   4  *
   5  *  This library is free software; you can redistribute it and/or
   6  *  modify it under the terms of the GNU Library General Public
   7  *  License as published by the Free Software Foundation; either
   8  *  version 2 of the License, or (at your option) any later version.
   9  *
  10  *  This library is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  *  Library General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU Library General Public License
  16  *  along with this library; see the file COPYING.LIB.  If not, write to
  17  *  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  18  *  Boston, MA 02110-1301, USA.
  19  *
  20  */
  21
  22 #ifndef JSGlobalObject_h
  23 #define JSGlobalObject_h
  24
  25 #include "JSGlobalData.h"
  26 #include "JSVariableObject.h"
  27 #include "NumberPrototype.h"
  28 #include "StringPrototype.h"
  29 #include <wtf/HashSet.h>
  30 #include <wtf/OwnPtr.h>
  31
  32 namespace JSC {
  33
  34     class ArrayPrototype;
  35     class BooleanPrototype;
  36     class DatePrototype;
  37     class Debugger;
  38     class ErrorConstructor;
  39     class FunctionPrototype;
  40     class GlobalEvalFunction;
  41     class NativeErrorConstructor;
  42     class ProgramCodeBlock;
  43     class RegExpConstructor;
  44     class RegExpPrototype;
  45     class RegisterFile;
  46
  47     struct ActivationStackNode;
  48     struct HashTable;
  49
  50     typedef Vector<ExecState*, 16> ExecStateStack;
  51
  52     class JSGlobalObject : public JSVariableObject {
  53     protected:
  54         using JSVariableObject::JSVariableObjectData;
  55
  56         struct JSGlobalObjectData : public JSVariableObjectData {
  57             JSGlobalObjectData()
  58                 : JSVariableObjectData(&symbolTable, 0)
  59                 , registerArraySize(0)
  60                 , globalScopeChain(NoScopeChain())
  61                 , regExpConstructor(0)
  62                 , errorConstructor(0)
  63                 , evalErrorConstructor(0)
  64                 , rangeErrorConstructor(0)
  65                 , referenceErrorConstructor(0)
  66                 , syntaxErrorConstructor(0)
  67                 , typeErrorConstructor(0)
  68                 , URIErrorConstructor(0)
  69                 , evalFunction(0)
  70                 , objectPrototype(0)
  71                 , functionPrototype(0)
  72                 , arrayPrototype(0)
  73                 , booleanPrototype(0)
  74                 , stringPrototype(0)
  75                 , numberPrototype(0)
  76                 , datePrototype(0)
  77                 , regExpPrototype(0)
  78             {
  79             }
  80
  81             virtual ~JSGlobalObjectData()
  82             {
  83             }
  84
  85             size_t registerArraySize;
  86
  87             JSGlobalObject* next;
  88             JSGlobalObject* prev;
  89
  90             Debugger* debugger;
  91
  92             ScopeChain globalScopeChain;
  93             Register globalCallFrame[RegisterFile::CallFrameHeaderSize];
  94
  95             int recursion;
  96
  97             RegExpConstructor* regExpConstructor;
  98             ErrorConstructor* errorConstructor;
  99             NativeErrorConstructor* evalErrorConstructor;
 100             NativeErrorConstructor* rangeErrorConstructor;
 101             NativeErrorConstructor* referenceErrorConstructor;
 102             NativeErrorConstructor* syntaxErrorConstructor;
 103             NativeErrorConstructor* typeErrorConstructor;
 104             NativeErrorConstructor* URIErrorConstructor;
 105
 106             GlobalEvalFunction* evalFunction;
 107
 108             ObjectPrototype* objectPrototype;
 109             FunctionPrototype* functionPrototype;
 110             ArrayPrototype* arrayPrototype;
 111             BooleanPrototype* booleanPrototype;
 112             StringPrototype* stringPrototype;
 113             NumberPrototype* numberPrototype;
 114             DatePrototype* datePrototype;
 115             RegExpPrototype* regExpPrototype;
 116
 117             RefPtr<Structure> argumentsStructure;
 118             RefPtr<Structure> arrayStructure;
 119             RefPtr<Structure> booleanObjectStructure;
 120             RefPtr<Structure> callbackConstructorStructure;
 121             RefPtr<Structure> callbackFunctionStructure;
 122             RefPtr<Structure> callbackObjectStructure;
 123             RefPtr<Structure> dateStructure;
 124             RefPtr<Structure> emptyObjectStructure;
 125             RefPtr<Structure> errorStructure;
 126             RefPtr<Structure> functionStructure;
 127             RefPtr<Structure> numberObjectStructure;
 128             RefPtr<Structure> prototypeFunctionStructure;
 129             RefPtr<Structure> regExpMatchesArrayStructure;
 130             RefPtr<Structure> regExpStructure;
 131             RefPtr<Structure> stringObjectStructure;
 132
 133             SymbolTable symbolTable;
 134             unsigned profileGroup;
 135
 136             RefPtr<JSGlobalData> globalData;
 137
 138             HashSet<ProgramCodeBlock*> codeBlocks;
 139         };
 140
 141     public:
 142         void* operator new(size_t, JSGlobalData*);
 143
 144         explicit JSGlobalObject()
 145             : JSVariableObject(JSGlobalObject::createStructure(jsNull()), new JSGlobalObjectData)
 146         {
 147             init(this);
 148         }
 149
 150     protected:
 151         JSGlobalObject(PassRefPtr<Structure> structure, JSGlobalObjectData* data, JSObject* thisValue)
 152             : JSVariableObject(structure, data)
 153         {
 154             init(thisValue);
 155         }
 156
 157     public:
 158         virtual ~JSGlobalObject();
 159
 160         virtual void mark();
 161
 162         virtual bool getOwnPropertySlot(ExecState*, const Identifier&, PropertySlot&);
 163         virtual bool getOwnPropertySlot(ExecState*, const Identifier&, PropertySlot&, bool& slotIsWriteable);
 164         virtual void put(ExecState*, const Identifier&, JSValuePtr, PutPropertySlot&);
 165         virtual void putWithAttributes(ExecState*, const Identifier& propertyName, JSValuePtr value, unsigned attributes);
 166
 167         virtual void defineGetter(ExecState*, const Identifier& propertyName, JSObject* getterFunc);
 168         virtual void defineSetter(ExecState*, const Identifier& propertyName, JSObject* setterFunc);
 169
 170         // Linked list of all global objects that use the same JSGlobalData.
 171         JSGlobalObject*& head() { return d()->globalData->head; }
 172         JSGlobalObject* next() { return d()->next; }
 173
 174         // The following accessors return pristine values, even if a script
 175         // replaces the global object's associated property.
 176
 177         RegExpConstructor* regExpConstructor() const { return d()->regExpConstructor; }
 178
 179         ErrorConstructor* errorConstructor() const { return d()->errorConstructor; }
 180         NativeErrorConstructor* evalErrorConstructor() const { return d()->evalErrorConstructor; }
 181         NativeErrorConstructor* rangeErrorConstructor() const { return d()->rangeErrorConstructor; }
 182         NativeErrorConstructor* referenceErrorConstructor() const { return d()->referenceErrorConstructor; }
 183         NativeErrorConstructor* syntaxErrorConstructor() const { return d()->syntaxErrorConstructor; }
 184         NativeErrorConstructor* typeErrorConstructor() const { return d()->typeErrorConstructor; }
 185         NativeErrorConstructor* URIErrorConstructor() const { return d()->URIErrorConstructor; }
 186
 187         GlobalEvalFunction* evalFunction() const { return d()->evalFunction; }
 188
 189         ObjectPrototype* objectPrototype() const { return d()->objectPrototype; }
 190         FunctionPrototype* functionPrototype() const { return d()->functionPrototype; }
 191         ArrayPrototype* arrayPrototype() const { return d()->arrayPrototype; }
 192         BooleanPrototype* booleanPrototype() const { return d()->booleanPrototype; }
 193         StringPrototype* stringPrototype() const { return d()->stringPrototype; }
 194         NumberPrototype* numberPrototype() const { return d()->numberPrototype; }
 195         DatePrototype* datePrototype() const { return d()->datePrototype; }
 196         RegExpPrototype* regExpPrototype() const { return d()->regExpPrototype; }
 197
 198         Structure* argumentsStructure() const { return d()->argumentsStructure.get(); }
 199         Structure* arrayStructure() const { return d()->arrayStructure.get(); }
 200         Structure* booleanObjectStructure() const { return d()->booleanObjectStructure.get(); }
 201         Structure* callbackConstructorStructure() const { return d()->callbackConstructorStructure.get(); }
 202         Structure* callbackFunctionStructure() const { return d()->callbackFunctionStructure.get(); }
 203         Structure* callbackObjectStructure() const { return d()->callbackObjectStructure.get(); }
 204         Structure* dateStructure() const { return d()->dateStructure.get(); }
 205         Structure* emptyObjectStructure() const { return d()->emptyObjectStructure.get(); }
 206         Structure* errorStructure() const { return d()->errorStructure.get(); }
 207         Structure* functionStructure() const { return d()->functionStructure.get(); }
 208         Structure* numberObjectStructure() const { return d()->numberObjectStructure.get(); }
 209         Structure* prototypeFunctionStructure() const { return d()->prototypeFunctionStructure.get(); }
 210         Structure* regExpMatchesArrayStructure() const { return d()->regExpMatchesArrayStructure.get(); }
 211         Structure* regExpStructure() const { return d()->regExpStructure.get(); }
 212         Structure* stringObjectStructure() const { return d()->stringObjectStructure.get(); }
 213
 214         void setProfileGroup(unsigned value) { d()->profileGroup = value; }
 215         unsigned profileGroup() const { return d()->profileGroup; }
 216
 217         void setTimeoutTime(unsigned timeoutTime);
 218         void startTimeoutCheck();
 219         void stopTimeoutCheck();
 220
 221         Debugger* debugger() const { return d()->debugger; }
 222         void setDebugger(Debugger* debugger) { d()->debugger = debugger; }
 223
 224         virtual bool supportsProfiling() const { return false; }
 225
 226         int recursion() { return d()->recursion; }
 227         void incRecursion() { ++d()->recursion; }
 228         void decRecursion() { --d()->recursion; }
 229
 230         ScopeChain& globalScopeChain() { return d()->globalScopeChain; }
 231
 232         virtual bool isGlobalObject() const { return true; }
 233
 234         virtual ExecState* globalExec();
 235
 236         virtual bool shouldInterruptScriptBeforeTimeout() const { return false; }
 237         virtual bool shouldInterruptScript() const { return true; }
 238
 239         virtual bool allowsAccessFrom(const JSGlobalObject*) const { return true; }
 240
 241         virtual bool isDynamicScope() const;
 242
 243         HashSet<ProgramCodeBlock*>& codeBlocks() { return d()->codeBlocks; }
 244
 245         void copyGlobalsFrom(RegisterFile&);
 246         void copyGlobalsTo(RegisterFile&);
 247
 248         void resetPrototype(JSValuePtr prototype);
 249
 250         JSGlobalData* globalData() { return d()->globalData.get(); }
 251         JSGlobalObjectData* d() const { return static_cast<JSGlobalObjectData*>(JSVariableObject::d); }
 252
 253         static PassRefPtr<Structure> createStructure(JSValuePtr prototype)
 254         {
 255             return Structure::create(prototype, TypeInfo(ObjectType));
 256         }
 257
 258     protected:
 259         struct GlobalPropertyInfo {
 260             GlobalPropertyInfo(const Identifier& i, JSValuePtr v, unsigned a)
 261                 : identifier(i)
 262                 , value(v)
 263                 , attributes(a)
 264             {
 265             }
 266
 267             const Identifier identifier;
 268             JSValuePtr value;
 269             unsigned attributes;
 270         };
 271         void addStaticGlobals(GlobalPropertyInfo*, int count);
 272
 273     private:
 274         // FIXME: Fold reset into init.
 275         void init(JSObject* thisValue);
 276         void reset(JSValuePtr prototype);
 277
 278         void setRegisters(Register* registers, Register* registerArray, size_t count);
 279
 280         void* operator new(size_t); // can only be allocated with JSGlobalData
 281     };
 282
 283     JSGlobalObject* asGlobalObject(JSValuePtr);
 284
 285     inline JSGlobalObject* asGlobalObject(JSValuePtr value)
 286     {
 287         ASSERT(asObject(value)->isGlobalObject());
 288         return static_cast<JSGlobalObject*>(asObject(value));
 289     }
 290
 291     inline void JSGlobalObject::setRegisters(Register* registers, Register* registerArray, size_t count)
 292     {
 293         JSVariableObject::setRegisters(registers, registerArray);
 294         d()->registerArraySize = count;
 295     }
 296
 297     inline void JSGlobalObject::addStaticGlobals(GlobalPropertyInfo* globals, int count)
 298     {
 299         size_t oldSize = d()->registerArraySize;
 300         size_t newSize = oldSize + count;
 301         Register* registerArray = new Register[newSize];
 302         if (d()->registerArray)
 303             memcpy(registerArray + count, d()->registerArray.get(), oldSize * sizeof(Register));
 304         setRegisters(registerArray + newSize, registerArray, newSize);
 305
 306         for (int i = 0, index = -static_cast<int>(oldSize) - 1; i < count; ++i, --index) {
 307             GlobalPropertyInfo& global = globals[i];
 308             ASSERT(global.attributes & DontDelete);
 309             SymbolTableEntry newEntry(index, global.attributes);
 310             symbolTable().add(global.identifier.ustring().rep(), newEntry);
 311             registerAt(index) = global.value;
 312         }
 313     }
 314
 315     inline bool JSGlobalObject::getOwnPropertySlot(ExecState* exec, const Identifier& propertyName, PropertySlot& slot)
 316     {
 317         if (JSVariableObject::getOwnPropertySlot(exec, propertyName, slot))
 318             return true;
 319         return symbolTableGet(propertyName, slot);
 320     }
 321
 322     inline bool JSGlobalObject::getOwnPropertySlot(ExecState* exec, const Identifier& propertyName, PropertySlot& slot, bool& slotIsWriteable)
 323     {
 324         if (JSVariableObject::getOwnPropertySlotForWrite(exec, propertyName, slot, slotIsWriteable))
 325             return true;
 326         return symbolTableGet(propertyName, slot, slotIsWriteable);
 327     }
 328
 329     inline JSGlobalObject* ScopeChainNode::globalObject() const
 330     {
 331         const ScopeChainNode* n = this;
 332         while (n->next)
 333             n = n->next;
 334         return asGlobalObject(n->object);
 335     }
 336
 337     inline JSValuePtr Structure::prototypeForLookup(ExecState* exec) const
 338     {
 339         if (typeInfo().type() == ObjectType)
 340             return m_prototype;
 341
 342         if (typeInfo().type() == StringType)
 343             return exec->lexicalGlobalObject()->stringPrototype();
 344
 345         ASSERT(typeInfo().type() == NumberType);
 346         return exec->lexicalGlobalObject()->numberPrototype();
 347     }
 348
 349     inline StructureChain* Structure::prototypeChain(ExecState* exec) const
 350     {
 351         // We cache our prototype chain so our clients can share it.
 352         if (!isValid(exec, m_cachedPrototypeChain.get())) {
 353             JSValuePtr prototype = prototypeForLookup(exec);
 354             m_cachedPrototypeChain = StructureChain::create(prototype.isNull() ? 0 : asObject(prototype)->structure());
 355         }
 356         return m_cachedPrototypeChain.get();
 357     }
 358
 359     inline bool Structure::isValid(ExecState* exec, StructureChain* cachedPrototypeChain) const
 360     {
 361         if (!cachedPrototypeChain)
 362             return false;
 363
 364         JSValuePtr prototype = prototypeForLookup(exec);
 365         RefPtr<Structure>* cachedStructure = cachedPrototypeChain->head();
 366         while(*cachedStructure && !prototype.isNull()) {
 367             if (asObject(prototype)->structure() != *cachedStructure)
 368                 return false;
 369             ++cachedStructure;
 370             prototype = asObject(prototype)->prototype();
 371         }
 372         return prototype.isNull() && !*cachedStructure;
 373     }
 374
 375     inline JSGlobalObject* ExecState::dynamicGlobalObject()
 376     {
 377         if (this == lexicalGlobalObject()->globalExec())
 378             return lexicalGlobalObject();
 379
 380         // For any ExecState that's not a globalExec, the
 381         // dynamic global object must be set since code is running
 382         ASSERT(globalData().dynamicGlobalObject);
 383         return globalData().dynamicGlobalObject;
 384     }
 385
 386     class DynamicGlobalObjectScope : Noncopyable {
 387     public:
 388         DynamicGlobalObjectScope(CallFrame* callFrame, JSGlobalObject* dynamicGlobalObject)
 389             : m_dynamicGlobalObjectSlot(callFrame->globalData().dynamicGlobalObject)
 390             , m_savedDynamicGlobalObject(m_dynamicGlobalObjectSlot)
 391         {
 392             m_dynamicGlobalObjectSlot = dynamicGlobalObject;
 393         }
 394
 395         ~DynamicGlobalObjectScope()
 396         {
 397             m_dynamicGlobalObjectSlot = m_savedDynamicGlobalObject;
 398         }
 399
 400     private:
 401         JSGlobalObject*& m_dynamicGlobalObjectSlot;
 402         JSGlobalObject* m_savedDynamicGlobalObject;
 403     };
 404
 405 } // namespace JSC
 406
 407 #endif // JSGlobalObject_h