#ifndef Lookup_h
#define Lookup_h
#include "BatchedTransitionOptimizer.h"
#include "CallFrame.h"
#include "CustomGetterSetter.h"
#include "Identifier.h"
#include "IdentifierInlines.h"
#include "Intrinsic.h"
#include "JSGlobalObject.h"
#include "PropertySlot.h"
#include "PutPropertySlot.h"
#include <wtf/Assertions.h>
namespace JSC {
struct CompactHashIndex {
const int16_t value;
const int16_t next;
};
typedef PropertySlot::GetValueFunc GetFunction;
typedef PutPropertySlot::PutValueFunc PutFunction;
typedef FunctionExecutable* (*BuiltinGenerator)(VM&);
struct HashTableValue {
const char* m_key; unsigned m_attributes; Intrinsic m_intrinsic;
intptr_t m_value1;
intptr_t m_value2;
unsigned attributes() const { return m_attributes; }
Intrinsic intrinsic() const { ASSERT(m_attributes & Function); return m_intrinsic; }
BuiltinGenerator builtinGenerator() const { ASSERT(m_attributes & Builtin); return reinterpret_cast<BuiltinGenerator>(m_value1); }
NativeFunction function() const { ASSERT(m_attributes & Function); return reinterpret_cast<NativeFunction>(m_value1); }
unsigned char functionLength() const { ASSERT(m_attributes & Function); return static_cast<unsigned char>(m_value2); }
GetFunction propertyGetter() const { ASSERT(!(m_attributes & BuiltinOrFunctionOrAccessorOrConstant)); return reinterpret_cast<GetFunction>(m_value1); }
PutFunction propertyPutter() const { ASSERT(!(m_attributes & BuiltinOrFunctionOrAccessorOrConstant)); return reinterpret_cast<PutFunction>(m_value2); }
NativeFunction accessorGetter() const { ASSERT(m_attributes & Accessor); return reinterpret_cast<NativeFunction>(m_value1); }
NativeFunction accessorSetter() const { ASSERT(m_attributes & Accessor); return reinterpret_cast<NativeFunction>(m_value2); }
intptr_t constantInteger() const { ASSERT(m_attributes & ConstantInteger); return m_value1; }
intptr_t lexerValue() const { ASSERT(!m_attributes); return m_value1; }
};
struct HashTable {
mutable int numberOfValues;
int indexMask;
bool hasSetterOrReadonlyProperties;
const HashTableValue* values; mutable const char** keys; const CompactHashIndex* index;
ALWAYS_INLINE HashTable copy() const
{
HashTable result = { numberOfValues, indexMask, hasSetterOrReadonlyProperties, values, 0, index };
return result;
}
ALWAYS_INLINE void initializeIfNeeded() const
{
if (!keys)
createTable();
}
JS_EXPORT_PRIVATE void deleteTable() const;
ALWAYS_INLINE const HashTableValue* entry(PropertyName propertyName) const
{
initializeIfNeeded();
if (propertyName.isSymbol())
return nullptr;
auto uid = propertyName.uid();
if (!uid)
return nullptr;
ASSERT(keys);
int indexEntry = IdentifierRepHash::hash(uid) & indexMask;
int valueIndex = index[indexEntry].value;
if (valueIndex == -1)
return nullptr;
while (true) {
if (WTF::equal(uid, keys[valueIndex]))
return &values[valueIndex];
indexEntry = index[indexEntry].next;
if (indexEntry == -1)
return nullptr;
valueIndex = index[indexEntry].value;
ASSERT(valueIndex != -1);
};
}
class ConstIterator {
public:
ConstIterator(const HashTable* table, int position)
: m_table(table)
, m_position(position)
{
skipInvalidKeys();
}
const HashTableValue* value()
{
return &m_table->values[m_position];
}
const char* key()
{
return m_table->keys[m_position];
}
const HashTableValue* operator->()
{
return value();
}
bool operator!=(const ConstIterator& other)
{
ASSERT(m_table == other.m_table);
return m_position != other.m_position;
}
ConstIterator& operator++()
{
ASSERT(m_position < m_table->numberOfValues);
++m_position;
skipInvalidKeys();
return *this;
}
private:
void skipInvalidKeys()
{
ASSERT(m_position <= m_table->numberOfValues);
while (m_position < m_table->numberOfValues && !m_table->keys[m_position])
++m_position;
ASSERT(m_position <= m_table->numberOfValues);
}
const HashTable* m_table;
int m_position;
};
ConstIterator begin() const
{
initializeIfNeeded();
return ConstIterator(this, 0);
}
ConstIterator end() const
{
initializeIfNeeded();
return ConstIterator(this, numberOfValues);
}
private:
JS_EXPORT_PRIVATE void createTable() const;
};
JS_EXPORT_PRIVATE bool setUpStaticFunctionSlot(ExecState*, const HashTableValue*, JSObject* thisObject, PropertyName, PropertySlot&);
JS_EXPORT_PRIVATE void reifyStaticAccessor(VM&, const HashTableValue&, JSObject& thisObject, PropertyName);
template <class ThisImp, class ParentImp>
inline bool getStaticPropertySlot(ExecState* exec, const HashTable& table, ThisImp* thisObj, PropertyName propertyName, PropertySlot& slot)
{
const HashTableValue* entry = table.entry(propertyName);
if (!entry) return ParentImp::getOwnPropertySlot(thisObj, exec, propertyName, slot);
if (entry->attributes() & BuiltinOrFunctionOrAccessor)
return setUpStaticFunctionSlot(exec, entry, thisObj, propertyName, slot);
if (entry->attributes() & ConstantInteger) {
slot.setValue(thisObj, entry->attributes(), jsNumber(entry->constantInteger()));
return true;
}
slot.setCacheableCustom(thisObj, entry->attributes(), entry->propertyGetter());
return true;
}
template <class ParentImp>
inline bool getStaticFunctionSlot(ExecState* exec, const HashTable& table, JSObject* thisObj, PropertyName propertyName, PropertySlot& slot)
{
if (ParentImp::getOwnPropertySlot(thisObj, exec, propertyName, slot))
return true;
const HashTableValue* entry = table.entry(propertyName);
if (!entry)
return false;
return setUpStaticFunctionSlot(exec, entry, thisObj, propertyName, slot);
}
template <class ThisImp, class ParentImp>
inline bool getStaticValueSlot(ExecState* exec, const HashTable& table, ThisImp* thisObj, PropertyName propertyName, PropertySlot& slot)
{
const HashTableValue* entry = table.entry(propertyName);
if (!entry) return ParentImp::getOwnPropertySlot(thisObj, exec, propertyName, slot);
ASSERT(!(entry->attributes() & BuiltinOrFunctionOrAccessor));
if (entry->attributes() & ConstantInteger) {
slot.setValue(thisObj, entry->attributes(), jsNumber(entry->constantInteger()));
return true;
}
slot.setCacheableCustom(thisObj, entry->attributes(), entry->propertyGetter());
return true;
}
inline void putEntry(ExecState* exec, const HashTableValue* entry, JSObject* base, PropertyName propertyName, JSValue value, PutPropertySlot& slot)
{
if (entry->attributes() & BuiltinOrFunction) {
if (JSObject* thisObject = jsDynamicCast<JSObject*>(slot.thisValue()))
thisObject->putDirect(exec->vm(), propertyName, value);
} else if (entry->attributes() & Accessor) {
if (slot.isStrictMode())
throwTypeError(exec, StrictModeReadonlyPropertyWriteError);
} else if (!(entry->attributes() & ReadOnly)) {
entry->propertyPutter()(exec, base, JSValue::encode(slot.thisValue()), JSValue::encode(value));
slot.setCustomProperty(base, entry->propertyPutter());
} else if (slot.isStrictMode())
throwTypeError(exec, StrictModeReadonlyPropertyWriteError);
}
inline bool lookupPut(ExecState* exec, PropertyName propertyName, JSObject* base, JSValue value, const HashTable& table, PutPropertySlot& slot)
{
const HashTableValue* entry = table.entry(propertyName);
if (!entry)
return false;
putEntry(exec, entry, base, propertyName, value, slot);
return true;
}
template<unsigned numberOfValues>
inline void reifyStaticProperties(VM& vm, const HashTableValue (&values)[numberOfValues], JSObject& thisObj)
{
BatchedTransitionOptimizer transitionOptimizer(vm, &thisObj);
for (auto& value : values) {
if (!value.m_key)
continue;
Identifier propertyName = Identifier::fromString(&vm, reinterpret_cast<const LChar*>(value.m_key), strlen(value.m_key));
if (value.attributes() & Builtin) {
thisObj.putDirectBuiltinFunction(vm, thisObj.globalObject(), propertyName, value.builtinGenerator()(vm), value.attributes());
continue;
}
if (value.attributes() & Function) {
thisObj.putDirectNativeFunction(vm, thisObj.globalObject(), propertyName, value.functionLength(),
value.function(), value.intrinsic(), value.attributes());
continue;
}
if (value.attributes() & ConstantInteger) {
thisObj.putDirect(vm, propertyName, jsNumber(value.constantInteger()), value.attributes());
continue;
}
if (value.attributes() & Accessor) {
reifyStaticAccessor(vm, value, thisObj, propertyName);
continue;
}
CustomGetterSetter* customGetterSetter = CustomGetterSetter::create(vm, value.propertyGetter(), value.propertyPutter());
thisObj.putDirectCustomAccessor(vm, propertyName, customGetterSetter, value.attributes());
}
}
}
#endif // Lookup_h