JSLexicalEnvironment.cpp [plain text]
#include "config.h"
#include "JSLexicalEnvironment.h"
#include "HeapSnapshotBuilder.h"
#include "Interpreter.h"
#include "JSFunction.h"
#include "JSCInlines.h"
using namespace std;
namespace JSC {
const ClassInfo JSLexicalEnvironment::s_info = { "JSLexicalEnvironment", &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSLexicalEnvironment) };
void JSLexicalEnvironment::visitChildren(JSCell* cell, SlotVisitor& visitor)
{
auto* thisObject = jsCast<JSLexicalEnvironment*>(cell);
ASSERT_GC_OBJECT_INHERITS(thisObject, info());
Base::visitChildren(thisObject, visitor);
visitor.appendValuesHidden(thisObject->variables(), thisObject->symbolTable()->scopeSize());
}
void JSLexicalEnvironment::heapSnapshot(JSCell* cell, HeapSnapshotBuilder& builder)
{
auto* thisObject = jsCast<JSLexicalEnvironment*>(cell);
Base::heapSnapshot(cell, builder);
ConcurrentJSLocker locker(thisObject->symbolTable()->m_lock);
SymbolTable::Map::iterator end = thisObject->symbolTable()->end(locker);
for (SymbolTable::Map::iterator it = thisObject->symbolTable()->begin(locker); it != end; ++it) {
SymbolTableEntry::Fast entry = it->value;
ASSERT(!entry.isNull());
ScopeOffset offset = entry.scopeOffset();
if (!thisObject->isValidScopeOffset(offset))
continue;
JSValue toValue = thisObject->variableAt(offset).get();
if (toValue && toValue.isCell())
builder.appendVariableNameEdge(thisObject, toValue.asCell(), it->key.get());
}
}
void JSLexicalEnvironment::getOwnNonIndexPropertyNames(JSObject* object, ExecState* exec, PropertyNameArray& propertyNames, EnumerationMode mode)
{
JSLexicalEnvironment* thisObject = jsCast<JSLexicalEnvironment*>(object);
{
ConcurrentJSLocker locker(thisObject->symbolTable()->m_lock);
SymbolTable::Map::iterator end = thisObject->symbolTable()->end(locker);
for (SymbolTable::Map::iterator it = thisObject->symbolTable()->begin(locker); it != end; ++it) {
if (it->value.getAttributes() & PropertyAttribute::DontEnum && !mode.includeDontEnumProperties())
continue;
if (!thisObject->isValidScopeOffset(it->value.scopeOffset()))
continue;
if (it->key->isSymbol() && !propertyNames.includeSymbolProperties())
continue;
propertyNames.add(Identifier::fromUid(exec, it->key.get()));
}
}
JSObject::getOwnNonIndexPropertyNames(thisObject, exec, propertyNames, mode);
}
bool JSLexicalEnvironment::getOwnPropertySlot(JSObject* object, ExecState* exec, PropertyName propertyName, PropertySlot& slot)
{
JSLexicalEnvironment* thisObject = jsCast<JSLexicalEnvironment*>(object);
if (symbolTableGet(thisObject, propertyName, slot))
return true;
unsigned attributes;
if (JSValue value = thisObject->getDirect(exec->vm(), propertyName, attributes)) {
slot.setValue(thisObject, attributes, value);
return true;
}
ASSERT(!thisObject->hasGetterSetterProperties());
ASSERT(thisObject->getPrototypeDirect(exec->vm()).isNull());
return false;
}
bool JSLexicalEnvironment::put(JSCell* cell, ExecState* exec, PropertyName propertyName, JSValue value, PutPropertySlot& slot)
{
JSLexicalEnvironment* thisObject = jsCast<JSLexicalEnvironment*>(cell);
ASSERT(!Heap::heap(value) || Heap::heap(value) == Heap::heap(thisObject));
bool shouldThrowReadOnlyError = slot.isStrictMode() || thisObject->isLexicalScope();
bool ignoreReadOnlyErrors = false;
bool putResult = false;
if (symbolTablePutInvalidateWatchpointSet(thisObject, exec, propertyName, value, shouldThrowReadOnlyError, ignoreReadOnlyErrors, putResult))
return putResult;
ASSERT(!thisObject->hasGetterSetterProperties());
return thisObject->putOwnDataProperty(exec->vm(), propertyName, value, slot);
}
bool JSLexicalEnvironment::deleteProperty(JSCell* cell, ExecState* exec, PropertyName propertyName)
{
VM& vm = exec->vm();
if (propertyName == vm.propertyNames->arguments)
return false;
return Base::deleteProperty(cell, exec, propertyName);
}
}