f690fc11878484ca197dbca3bd6caf12f40e9e15
[WebKit.git] / JavaScriptCore / kjs / JSObject.h
1 /*
2  *  Copyright (C) 1999-2001 Harri Porten (porten@kde.org)
3  *  Copyright (C) 2001 Peter Kelly (pmk@post.com)
4  *  Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
5  *
6  *  This library is free software; you can redistribute it and/or
7  *  modify it under the terms of the GNU Library General Public
8  *  License as published by the Free Software Foundation; either
9  *  version 2 of the License, or (at your option) any later version.
10  *
11  *  This library is distributed in the hope that it will be useful,
12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  *  Library General Public License for more details.
15  *
16  *  You should have received a copy of the GNU Library General Public License
17  *  along with this library; see the file COPYING.LIB.  If not, write to
18  *  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
19  *  Boston, MA 02110-1301, USA.
20  *
21  */
22
23 #ifndef JSObject_h
24 #define JSObject_h
25
26 #include "ArgList.h"
27 #include "ClassInfo.h"
28 #include "CommonIdentifiers.h"
29 #include "ExecState.h"
30 #include "JSNumberCell.h"
31 #include "PropertyMap.h"
32 #include "PropertySlot.h"
33 #include "PutPropertySlot.h"
34 #include "ScopeChain.h"
35 #include "StructureID.h"
36
37 namespace JSC {
38
39     class InternalFunction;
40     class PropertyNameArray;
41     class StructureID;
42     struct HashEntry;
43     struct HashTable;
44
45     // ECMA 262-3 8.6.1
46     // Property attributes
47     enum Attribute {
48         None         = 0,
49         ReadOnly     = 1 << 1,  // property can be only read, not written
50         DontEnum     = 1 << 2,  // property doesn't appear in (for .. in ..)
51         DontDelete   = 1 << 3,  // property can't be deleted
52         Function     = 1 << 4,  // property is a function - only used by static hashtables
53     };
54
55     class JSObject : public JSCell {
56         friend class BatchedTransitionOptimizer;
57         friend class CTI;
58
59     public:
60         explicit JSObject(PassRefPtr<StructureID>);
61
62         virtual void mark();
63
64         // The inline virtual destructor cannot be the first virtual function declared
65         // in the class as it results in the vtable being generated as a weak symbol
66         virtual ~JSObject();
67
68         bool inherits(const ClassInfo* classInfo) const { return JSCell::isObject(classInfo); }
69
70         JSValue* prototype() const;
71         void setPrototype(JSValue* prototype);
72         
73         void setStructureID(PassRefPtr<StructureID>);
74         StructureID* inheritorID();
75
76         PropertyStorage& propertyStorage() { return m_propertyStorage; }
77
78         virtual UString className() const;
79
80         JSValue* get(ExecState*, const Identifier& propertyName) const;
81         JSValue* get(ExecState*, unsigned propertyName) const;
82
83         bool getPropertySlot(ExecState*, const Identifier& propertyName, PropertySlot&);
84         bool getPropertySlot(ExecState*, unsigned propertyName, PropertySlot&);
85
86         virtual bool getOwnPropertySlot(ExecState*, const Identifier& propertyName, PropertySlot&);
87         virtual bool getOwnPropertySlot(ExecState*, unsigned propertyName, PropertySlot&);
88
89         virtual void put(ExecState*, const Identifier& propertyName, JSValue* value, PutPropertySlot&);
90         virtual void put(ExecState*, unsigned propertyName, JSValue* value);
91
92         virtual void putWithAttributes(ExecState*, const Identifier& propertyName, JSValue* value, unsigned attributes);
93         virtual void putWithAttributes(ExecState*, unsigned propertyName, JSValue* value, unsigned attributes);
94
95         bool propertyIsEnumerable(ExecState*, const Identifier& propertyName) const;
96
97         bool hasProperty(ExecState*, const Identifier& propertyName) const;
98         bool hasProperty(ExecState*, unsigned propertyName) const;
99         bool hasOwnProperty(ExecState*, const Identifier& propertyName) const;
100
101         virtual bool deleteProperty(ExecState*, const Identifier& propertyName);
102         virtual bool deleteProperty(ExecState*, unsigned propertyName);
103
104         virtual JSValue* defaultValue(ExecState*, PreferredPrimitiveType) const;
105
106         virtual bool hasInstance(ExecState*, JSValue*, JSValue* prototypeProperty);
107
108         virtual void getPropertyNames(ExecState*, PropertyNameArray&);
109
110         virtual JSValue* toPrimitive(ExecState*, PreferredPrimitiveType = NoPreference) const;
111         virtual bool getPrimitiveNumber(ExecState*, double& number, JSValue*& value);
112         virtual bool toBoolean(ExecState*) const;
113         virtual double toNumber(ExecState*) const;
114         virtual UString toString(ExecState*) const;
115         virtual JSObject* toObject(ExecState*) const;
116
117         virtual JSObject* toThisObject(ExecState*) const;
118         virtual JSGlobalObject* toGlobalObject(ExecState*) const;
119
120         virtual bool getPropertyAttributes(ExecState*, const Identifier& propertyName, unsigned& attributes) const;
121
122         // This get function only looks at the property map.
123         JSValue* getDirect(const Identifier& propertyName) const
124         {
125             size_t offset = m_structureID->propertyMap().get(propertyName);
126             return offset != WTF::notFound ? m_propertyStorage[offset] : 0;
127         }
128
129         JSValue** getDirectLocation(const Identifier& propertyName)
130         {
131             size_t offset = m_structureID->propertyMap().get(propertyName);
132             return offset != WTF::notFound ? locationForOffset(offset) : 0;
133         }
134
135         JSValue** getDirectLocation(const Identifier& propertyName, unsigned& attributes)
136         {
137             size_t offset = m_structureID->propertyMap().get(propertyName, attributes);
138             return offset != WTF::notFound ? locationForOffset(offset) : 0;
139         }
140
141         size_t offsetForLocation(JSValue** location)
142         {
143             return location - m_propertyStorage;
144         }
145
146         JSValue** locationForOffset(size_t offset)
147         {
148             return &m_propertyStorage[offset];
149         }
150
151         void transitionTo(StructureID*);
152
153         void removeDirect(const Identifier& propertyName);
154         bool hasCustomProperties() { return !m_structureID->propertyMap().isEmpty(); }
155         bool hasGetterSetterProperties() { return m_structureID->hasGetterSetterProperties(); }
156
157         void putDirect(const Identifier& propertyName, JSValue* value, unsigned attr = 0);
158         void putDirect(const Identifier& propertyName, JSValue* value, unsigned attr, bool checkReadOnly, PutPropertySlot& slot);
159         void putDirectFunction(ExecState* exec, InternalFunction* function, unsigned attr = 0);
160         void putDirectWithoutTransition(const Identifier& propertyName, JSValue* value, unsigned attr);
161         void putDirectFunctionWithoutTransition(ExecState* exec, InternalFunction* function, unsigned attr);
162
163         // Fast access to known property offsets.
164         JSValue* getDirectOffset(size_t offset) { return m_propertyStorage[offset]; }
165         void putDirectOffset(size_t offset, JSValue* value) { m_propertyStorage[offset] = value; }
166
167         void fillGetterPropertySlot(PropertySlot&, JSValue** location);
168
169         virtual void defineGetter(ExecState*, const Identifier& propertyName, JSObject* getterFunction);
170         virtual void defineSetter(ExecState*, const Identifier& propertyName, JSObject* setterFunction);
171         virtual JSValue* lookupGetter(ExecState*, const Identifier& propertyName);
172         virtual JSValue* lookupSetter(ExecState*, const Identifier& propertyName);
173
174         virtual bool isGlobalObject() const { return false; }
175         virtual bool isVariableObject() const { return false; }
176         virtual bool isWatchdogException() const { return false; }
177         virtual bool isNotAnObjectErrorStub() const { return false; }
178
179         void allocatePropertyStorage(size_t oldSize, size_t newSize);
180         void allocatePropertyStorageInline(size_t oldSize, size_t newSize);
181         bool usingInlineStorage() const { return m_propertyStorage == m_inlineStorage; }
182
183         static const size_t inlineStorageCapacity = 2;
184         static const size_t nonInlineBaseStorageCapacity = 16;
185
186         static PassRefPtr<StructureID> createStructureID(JSValue* proto) { return StructureID::create(proto, TypeInfo(ObjectType)); }
187
188     protected:
189         bool getOwnPropertySlotForWrite(ExecState*, const Identifier&, PropertySlot&, bool& slotIsWriteable);
190
191     private:
192         const HashEntry* findPropertyHashEntry(ExecState*, const Identifier& propertyName) const;
193         StructureID* createInheritorID();
194
195         RefPtr<StructureID> m_inheritorID;
196
197         PropertyStorage m_propertyStorage;        
198         JSValue* m_inlineStorage[inlineStorageCapacity];
199     };
200
201   JSObject* constructEmptyObject(ExecState*);
202
203 inline JSObject::JSObject(PassRefPtr<StructureID> structureID)
204     : JSCell(structureID.releaseRef()) // ~JSObject balances this ref()
205     , m_propertyStorage(m_inlineStorage)
206 {
207     ASSERT(m_structureID);
208     ASSERT(m_structureID->propertyStorageCapacity() == inlineStorageCapacity);
209     ASSERT(m_structureID->propertyMap().isEmpty());
210     ASSERT(prototype()->isNull() || Heap::heap(this) == Heap::heap(prototype()));
211 }
212
213 inline JSObject::~JSObject()
214 {
215     ASSERT(m_structureID);
216     if (m_propertyStorage != m_inlineStorage)
217         delete [] m_propertyStorage;
218     m_structureID->deref();
219 }
220
221 inline JSValue* JSObject::prototype() const
222 {
223     return m_structureID->storedPrototype();
224 }
225
226 inline void JSObject::setPrototype(JSValue* prototype)
227 {
228     ASSERT(prototype);
229     RefPtr<StructureID> newStructureID = StructureID::changePrototypeTransition(m_structureID, prototype);
230     setStructureID(newStructureID.release());
231 }
232
233 inline void JSObject::setStructureID(PassRefPtr<StructureID> structureID)
234 {
235     m_structureID->deref();
236     m_structureID = structureID.releaseRef(); // ~JSObject balances this ref()
237 }
238
239 inline StructureID* JSObject::inheritorID()
240 {
241     if (m_inheritorID)
242         return m_inheritorID.get();
243     return createInheritorID();
244 }
245
246 inline bool JSCell::isObject(const ClassInfo* info) const
247 {
248     for (const ClassInfo* ci = classInfo(); ci; ci = ci->parentClass) {
249         if (ci == info)
250             return true;
251     }
252     return false;
253 }
254
255 // this method is here to be after the inline declaration of JSCell::isObject
256 inline bool JSValue::isObject(const ClassInfo* classInfo) const
257 {
258     return !JSImmediate::isImmediate(this) && asCell()->isObject(classInfo);
259 }
260
261 inline JSValue* JSObject::get(ExecState* exec, const Identifier& propertyName) const
262 {
263     PropertySlot slot(const_cast<JSObject*>(this));
264     if (const_cast<JSObject*>(this)->getPropertySlot(exec, propertyName, slot))
265         return slot.getValue(exec, propertyName);
266     
267     return jsUndefined();
268 }
269
270 inline JSValue* JSObject::get(ExecState* exec, unsigned propertyName) const
271 {
272     PropertySlot slot(const_cast<JSObject*>(this));
273     if (const_cast<JSObject*>(this)->getPropertySlot(exec, propertyName, slot))
274         return slot.getValue(exec, propertyName);
275
276     return jsUndefined();
277 }
278
279 // It may seem crazy to inline a function this large but it makes a big difference
280 // since this is function very hot in variable lookup
281 inline bool JSObject::getPropertySlot(ExecState* exec, const Identifier& propertyName, PropertySlot& slot)
282 {
283     JSObject* object = this;
284     while (true) {
285         if (object->getOwnPropertySlot(exec, propertyName, slot))
286             return true;
287
288         JSValue* prototype = object->prototype();
289         if (!prototype->isObject())
290             return false;
291
292         object = static_cast<JSObject*>(prototype);
293     }
294 }
295
296 inline bool JSObject::getPropertySlot(ExecState* exec, unsigned propertyName, PropertySlot& slot)
297 {
298     JSObject* object = this;
299
300     while (true) {
301         if (object->getOwnPropertySlot(exec, propertyName, slot))
302             return true;
303
304         JSValue* prototype = object->prototype();
305         if (!prototype->isObject())
306             break;
307
308         object = static_cast<JSObject*>(prototype);
309     }
310
311     return false;
312 }
313
314 // It may seem crazy to inline a function this large, especially a virtual function,
315 // but it makes a big difference to property lookup that derived classes can inline their
316 // base class call to this.
317 ALWAYS_INLINE bool JSObject::getOwnPropertySlotForWrite(ExecState* exec, const Identifier& propertyName, PropertySlot& slot, bool& slotIsWriteable)
318 {
319     unsigned attributes;
320     if (JSValue** location = getDirectLocation(propertyName, attributes)) {
321         if (m_structureID->hasGetterSetterProperties() && location[0]->isGetterSetter()) {
322             slotIsWriteable = false;
323             fillGetterPropertySlot(slot, location);
324         } else {
325             slotIsWriteable = !(attributes & ReadOnly);
326             slot.setValueSlot(this, location, offsetForLocation(location));
327         }
328         return true;
329     }
330
331     // non-standard Netscape extension
332     if (propertyName == exec->propertyNames().underscoreProto) {
333         slot.setValue(prototype());
334         slotIsWriteable = false;
335         return true;
336     }
337
338     return false;
339 }
340
341 // It may seem crazy to inline a function this large, especially a virtual function,
342 // but it makes a big difference to property lookup that derived classes can inline their
343 // base class call to this.
344 ALWAYS_INLINE bool JSObject::getOwnPropertySlot(ExecState* exec, const Identifier& propertyName, PropertySlot& slot)
345 {
346     if (JSValue** location = getDirectLocation(propertyName)) {
347         if (m_structureID->hasGetterSetterProperties() && location[0]->isGetterSetter())
348             fillGetterPropertySlot(slot, location);
349         else
350             slot.setValueSlot(this, location, offsetForLocation(location));
351         return true;
352     }
353
354     // non-standard Netscape extension
355     if (propertyName == exec->propertyNames().underscoreProto) {
356         slot.setValue(prototype());
357         return true;
358     }
359
360     return false;
361 }
362
363 inline void JSObject::putDirect(const Identifier& propertyName, JSValue* value, unsigned attr)
364 {
365     PutPropertySlot slot;
366     putDirect(propertyName, value, attr, false, slot);
367 }
368
369 inline void JSObject::putDirect(const Identifier& propertyName, JSValue* value, unsigned attributes, bool checkReadOnly, PutPropertySlot& slot)
370 {
371     ASSERT(!Heap::heap(value) || Heap::heap(value) == Heap::heap(this));
372
373     if (m_structureID->isDictionary()) {
374         unsigned currentAttributes;
375         size_t offset = m_structureID->propertyMap().get(propertyName, currentAttributes);
376         if (offset != WTF::notFound) {
377             if (checkReadOnly && currentAttributes & ReadOnly)
378                 return;
379             m_propertyStorage[offset] = value;
380             slot.setExistingProperty(this, offset);
381             return;
382         }
383
384         size_t currentCapacity = m_structureID->propertyStorageCapacity();
385         offset = m_structureID->propertyMap().put(propertyName, attributes);
386         if (m_structureID->propertyMap().storageSize() > m_structureID->propertyStorageCapacity()) {
387             m_structureID->growPropertyStorageCapacity();
388             allocatePropertyStorage(currentCapacity, m_structureID->propertyStorageCapacity());
389         }
390
391         m_propertyStorage[offset] = value;
392         slot.setNewProperty(this, offset);
393         m_structureID->clearEnumerationCache();
394         return;
395     }
396
397     unsigned currentAttributes;
398     size_t offset = m_structureID->propertyMap().get(propertyName, currentAttributes);
399     if (offset != WTF::notFound) {
400         if (checkReadOnly && currentAttributes & ReadOnly)
401             return;
402         m_propertyStorage[offset] = value;
403         slot.setExistingProperty(this, offset);
404         return;
405     }
406
407     size_t currentCapacity = m_structureID->propertyStorageCapacity();
408     RefPtr<StructureID> structureID = StructureID::addPropertyTransition(m_structureID, propertyName, attributes, offset);
409     if (currentCapacity != structureID->propertyStorageCapacity())
410         allocatePropertyStorage(currentCapacity, structureID->propertyStorageCapacity());
411
412     ASSERT(offset < structureID->propertyStorageCapacity());
413     m_propertyStorage[offset] = value;
414     slot.setNewProperty(this, offset);
415     slot.setWasTransition(true);
416     setStructureID(structureID.release());
417 }
418
419 inline void JSObject::putDirectWithoutTransition(const Identifier& propertyName, JSValue* value, unsigned attributes)
420 {
421     size_t currentCapacity = m_structureID->propertyStorageCapacity();
422     size_t offset = m_structureID->addPropertyWithoutTransition(propertyName, attributes);
423     if (currentCapacity != m_structureID->propertyStorageCapacity())
424         allocatePropertyStorage(currentCapacity, m_structureID->propertyStorageCapacity());
425     m_propertyStorage[offset] = value;
426 }
427
428 inline void JSObject::transitionTo(StructureID* newStructureID)
429 {
430     if (m_structureID->propertyStorageCapacity() != newStructureID->propertyStorageCapacity())
431         allocatePropertyStorage(m_structureID->propertyStorageCapacity(), newStructureID->propertyStorageCapacity());
432     setStructureID(newStructureID);
433 }
434
435 inline JSValue* JSObject::toPrimitive(ExecState* exec, PreferredPrimitiveType preferredType) const
436 {
437     return defaultValue(exec, preferredType);
438 }
439
440 inline JSValue* JSValue::get(ExecState* exec, const Identifier& propertyName) const
441 {
442     PropertySlot slot(const_cast<JSValue*>(this));
443     return get(exec, propertyName, slot);
444 }
445
446 inline JSValue* JSValue::get(ExecState* exec, const Identifier& propertyName, PropertySlot& slot) const
447 {
448     if (UNLIKELY(JSImmediate::isImmediate(this))) {
449         JSObject* prototype = JSImmediate::prototype(this, exec);
450         if (!prototype->getPropertySlot(exec, propertyName, slot))
451             return jsUndefined();
452         return slot.getValue(exec, propertyName);
453     }
454     JSCell* cell = static_cast<JSCell*>(const_cast<JSValue*>(this));
455     while (true) {
456         if (cell->getOwnPropertySlot(exec, propertyName, slot))
457             return slot.getValue(exec, propertyName);
458         ASSERT(cell->isObject());
459         JSValue* prototype = static_cast<JSObject*>(cell)->prototype();
460         if (!prototype->isObject())
461             return jsUndefined();
462         cell = static_cast<JSCell*>(prototype);
463     }
464 }
465
466 inline JSValue* JSValue::get(ExecState* exec, unsigned propertyName) const
467 {
468     PropertySlot slot(const_cast<JSValue*>(this));
469     return get(exec, propertyName, slot);
470 }
471
472 inline JSValue* JSValue::get(ExecState* exec, unsigned propertyName, PropertySlot& slot) const
473 {
474     if (UNLIKELY(JSImmediate::isImmediate(this))) {
475         JSObject* prototype = JSImmediate::prototype(this, exec);
476         if (!prototype->getPropertySlot(exec, propertyName, slot))
477             return jsUndefined();
478         return slot.getValue(exec, propertyName);
479     }
480     JSCell* cell = const_cast<JSCell*>(asCell());
481     while (true) {
482         if (cell->getOwnPropertySlot(exec, propertyName, slot))
483             return slot.getValue(exec, propertyName);
484         ASSERT(cell->isObject());
485         JSValue* prototype = static_cast<JSObject*>(cell)->prototype();
486         if (!prototype->isObject())
487             return jsUndefined();
488         cell = static_cast<JSCell*>(prototype);
489     }
490 }
491
492 inline void JSValue::put(ExecState* exec, const Identifier& propertyName, JSValue* value, PutPropertySlot& slot)
493 {
494     if (UNLIKELY(JSImmediate::isImmediate(this))) {
495         JSImmediate::toObject(this, exec)->put(exec, propertyName, value, slot);
496         return;
497     }
498     asCell()->put(exec, propertyName, value, slot);
499 }
500
501 inline void JSValue::put(ExecState* exec, unsigned propertyName, JSValue* value)
502 {
503     if (UNLIKELY(JSImmediate::isImmediate(this))) {
504         JSImmediate::toObject(this, exec)->put(exec, propertyName, value);
505         return;
506     }
507     asCell()->put(exec, propertyName, value);
508 }
509
510 ALWAYS_INLINE void JSObject::allocatePropertyStorageInline(size_t oldSize, size_t newSize)
511 {
512     ASSERT(newSize > oldSize);
513
514     JSValue** oldPropertStorage = m_propertyStorage;
515     m_propertyStorage = new JSValue*[newSize];
516
517     for (unsigned i = 0; i < oldSize; ++i)
518         m_propertyStorage[i] = oldPropertStorage[i];
519
520     if (oldPropertStorage != m_inlineStorage)
521         delete [] oldPropertStorage;
522 }
523
524 } // namespace JSC
525
526 #endif // JSObject_h