JSSymbolTableObject.h [plain text]
#ifndef JSSymbolTableObject_h
#define JSSymbolTableObject_h
#include "JSScope.h"
#include "PropertyDescriptor.h"
#include "SymbolTable.h"
#include "VariableWriteFireDetail.h"
namespace JSC {
class JSSymbolTableObject;
class JSSymbolTableObject : public JSScope {
public:
typedef JSScope Base;
static const unsigned StructureFlags = Base::StructureFlags | IsEnvironmentRecord | OverridesGetPropertyNames;
SymbolTable* symbolTable() const { return m_symbolTable.get(); }
JS_EXPORT_PRIVATE static bool deleteProperty(JSCell*, ExecState*, PropertyName);
JS_EXPORT_PRIVATE static void getOwnNonIndexPropertyNames(JSObject*, ExecState*, PropertyNameArray&, EnumerationMode);
static ptrdiff_t offsetOfSymbolTable() { return OBJECT_OFFSETOF(JSSymbolTableObject, m_symbolTable); }
protected:
JSSymbolTableObject(VM& vm, Structure* structure, JSScope* scope)
: Base(vm, structure, scope)
{
}
JSSymbolTableObject(VM& vm, Structure* structure, JSScope* scope, SymbolTable* symbolTable)
: Base(vm, structure, scope)
{
ASSERT(symbolTable);
setSymbolTable(vm, symbolTable);
}
void setSymbolTable(VM& vm, SymbolTable* symbolTable)
{
ASSERT(!m_symbolTable);
symbolTable->singletonScope()->notifyWrite(vm, this, "Allocated a scope");
m_symbolTable.set(vm, this, symbolTable);
}
static void visitChildren(JSCell*, SlotVisitor&);
private:
WriteBarrier<SymbolTable> m_symbolTable;
};
template<typename SymbolTableObjectType>
inline bool symbolTableGet(
SymbolTableObjectType* object, PropertyName propertyName, PropertySlot& slot)
{
SymbolTable& symbolTable = *object->symbolTable();
ConcurrentJITLocker locker(symbolTable.m_lock);
SymbolTable::Map::iterator iter = symbolTable.find(locker, propertyName.uid());
if (iter == symbolTable.end(locker))
return false;
SymbolTableEntry::Fast entry = iter->value;
ASSERT(!entry.isNull());
slot.setValue(object, entry.getAttributes() | DontDelete, object->variableAt(entry.scopeOffset()).get());
return true;
}
template<typename SymbolTableObjectType>
inline bool symbolTableGet(
SymbolTableObjectType* object, PropertyName propertyName, PropertyDescriptor& descriptor)
{
SymbolTable& symbolTable = *object->symbolTable();
ConcurrentJITLocker locker(symbolTable.m_lock);
SymbolTable::Map::iterator iter = symbolTable.find(locker, propertyName.uid());
if (iter == symbolTable.end(locker))
return false;
SymbolTableEntry::Fast entry = iter->value;
ASSERT(!entry.isNull());
descriptor.setDescriptor(
object->variableAt(entry.scopeOffset()).get(), entry.getAttributes() | DontDelete);
return true;
}
template<typename SymbolTableObjectType>
inline bool symbolTableGet(
SymbolTableObjectType* object, PropertyName propertyName, PropertySlot& slot,
bool& slotIsWriteable)
{
SymbolTable& symbolTable = *object->symbolTable();
ConcurrentJITLocker locker(symbolTable.m_lock);
SymbolTable::Map::iterator iter = symbolTable.find(locker, propertyName.uid());
if (iter == symbolTable.end(locker))
return false;
SymbolTableEntry::Fast entry = iter->value;
ASSERT(!entry.isNull());
slot.setValue(object, entry.getAttributes() | DontDelete, object->variableAt(entry.scopeOffset()).get());
slotIsWriteable = !entry.isReadOnly();
return true;
}
template<typename SymbolTableObjectType>
inline bool symbolTablePut(
SymbolTableObjectType* object, ExecState* exec, PropertyName propertyName, JSValue value,
bool shouldThrow)
{
VM& vm = exec->vm();
ASSERT(!Heap::heap(value) || Heap::heap(value) == Heap::heap(object));
WriteBarrierBase<Unknown>* reg;
WatchpointSet* set;
{
SymbolTable& symbolTable = *object->symbolTable();
GCSafeConcurrentJITLocker locker(symbolTable.m_lock, exec->vm().heap);
SymbolTable::Map::iterator iter = symbolTable.find(locker, propertyName.uid());
if (iter == symbolTable.end(locker))
return false;
bool wasFat;
SymbolTableEntry::Fast fastEntry = iter->value.getFast(wasFat);
ASSERT(!fastEntry.isNull());
if (fastEntry.isReadOnly()) {
if (shouldThrow)
throwTypeError(exec, StrictModeReadonlyPropertyWriteError);
return true;
}
set = iter->value.watchpointSet();
reg = &object->variableAt(fastEntry.scopeOffset());
}
reg->set(vm, object, value);
if (set)
VariableWriteFireDetail::touch(set, object, propertyName);
return true;
}
template<typename SymbolTableObjectType>
inline bool symbolTablePutWithAttributes(
SymbolTableObjectType* object, VM& vm, PropertyName propertyName,
JSValue value, unsigned attributes)
{
ASSERT(!Heap::heap(value) || Heap::heap(value) == Heap::heap(object));
WriteBarrierBase<Unknown>* reg;
WatchpointSet* set;
{
SymbolTable& symbolTable = *object->symbolTable();
ConcurrentJITLocker locker(symbolTable.m_lock);
SymbolTable::Map::iterator iter = symbolTable.find(locker, propertyName.uid());
if (iter == symbolTable.end(locker))
return false;
SymbolTableEntry& entry = iter->value;
ASSERT(!entry.isNull());
set = entry.watchpointSet();
entry.setAttributes(attributes);
reg = &object->variableAt(entry.scopeOffset());
}
reg->set(vm, object, value);
if (set)
VariableWriteFireDetail::touch(set, object, propertyName);
return true;
}
}
#endif // JSSymbolTableObject_h