342 lines
14 KiB
C++
342 lines
14 KiB
C++
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
|
|
* vim: set ts=8 sts=4 et sw=4 tw=99:
|
|
* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
#ifndef builtin_MapObject_h
|
|
#define builtin_MapObject_h
|
|
|
|
#include "jsobj.h"
|
|
|
|
#include "builtin/SelfHostingDefines.h"
|
|
#include "vm/GlobalObject.h"
|
|
#include "vm/NativeObject.h"
|
|
#include "vm/PIC.h"
|
|
#include "vm/Runtime.h"
|
|
|
|
namespace js {
|
|
|
|
/*
|
|
* Comparing two ropes for equality can fail. The js::HashTable template
|
|
* requires infallible hash() and match() operations. Therefore we require
|
|
* all values to be converted to hashable form before being used as a key
|
|
* in a Map or Set object.
|
|
*
|
|
* All values except ropes are hashable as-is.
|
|
*/
|
|
class HashableValue
|
|
{
|
|
PreBarrieredValue value;
|
|
|
|
public:
|
|
struct Hasher {
|
|
typedef HashableValue Lookup;
|
|
static HashNumber hash(const Lookup& v, const mozilla::HashCodeScrambler& hcs) {
|
|
return v.hash(hcs);
|
|
}
|
|
static bool match(const HashableValue& k, const Lookup& l) { return k == l; }
|
|
static bool isEmpty(const HashableValue& v) { return v.value.isMagic(JS_HASH_KEY_EMPTY); }
|
|
static void makeEmpty(HashableValue* vp) { vp->value = MagicValue(JS_HASH_KEY_EMPTY); }
|
|
};
|
|
|
|
HashableValue() : value(UndefinedValue()) {}
|
|
|
|
MOZ_MUST_USE bool setValue(JSContext* cx, HandleValue v);
|
|
HashNumber hash(const mozilla::HashCodeScrambler& hcs) const;
|
|
bool operator==(const HashableValue& other) const;
|
|
HashableValue mark(JSTracer* trc) const;
|
|
Value get() const { return value.get(); }
|
|
|
|
void trace(JSTracer* trc) {
|
|
TraceEdge(trc, &value, "HashableValue");
|
|
}
|
|
};
|
|
|
|
template <>
|
|
class RootedBase<HashableValue> {
|
|
public:
|
|
MOZ_MUST_USE bool setValue(JSContext* cx, HandleValue v) {
|
|
return static_cast<JS::Rooted<HashableValue>*>(this)->get().setValue(cx, v);
|
|
}
|
|
Value value() const {
|
|
return static_cast<const JS::Rooted<HashableValue>*>(this)->get().get();
|
|
}
|
|
};
|
|
|
|
template <class Key, class Value, class OrderedHashPolicy, class AllocPolicy>
|
|
class OrderedHashMap;
|
|
|
|
template <class T, class OrderedHashPolicy, class AllocPolicy>
|
|
class OrderedHashSet;
|
|
|
|
typedef OrderedHashMap<HashableValue,
|
|
HeapPtr<Value>,
|
|
HashableValue::Hasher,
|
|
RuntimeAllocPolicy> ValueMap;
|
|
|
|
typedef OrderedHashSet<HashableValue,
|
|
HashableValue::Hasher,
|
|
RuntimeAllocPolicy> ValueSet;
|
|
|
|
template <typename ObjectT>
|
|
class OrderedHashTableRef;
|
|
|
|
struct UnbarrieredHashPolicy;
|
|
|
|
class MapObject : public NativeObject {
|
|
public:
|
|
enum IteratorKind { Keys, Values, Entries };
|
|
static_assert(Keys == ITEM_KIND_KEY,
|
|
"IteratorKind Keys must match self-hosting define for item kind key.");
|
|
static_assert(Values == ITEM_KIND_VALUE,
|
|
"IteratorKind Values must match self-hosting define for item kind value.");
|
|
static_assert(Entries == ITEM_KIND_KEY_AND_VALUE,
|
|
"IteratorKind Entries must match self-hosting define for item kind "
|
|
"key-and-value.");
|
|
|
|
static JSObject* initClass(JSContext* cx, JSObject* obj);
|
|
static const Class class_;
|
|
|
|
enum { NurseryKeysSlot, SlotCount };
|
|
|
|
static MOZ_MUST_USE bool getKeysAndValuesInterleaved(JSContext* cx, HandleObject obj,
|
|
JS::MutableHandle<GCVector<JS::Value>> entries);
|
|
static MOZ_MUST_USE bool entries(JSContext* cx, unsigned argc, Value* vp);
|
|
static MOZ_MUST_USE bool has(JSContext* cx, unsigned argc, Value* vp);
|
|
static MapObject* create(JSContext* cx, HandleObject proto = nullptr);
|
|
|
|
// Publicly exposed Map calls for JSAPI access (webidl maplike/setlike
|
|
// interfaces, etc.)
|
|
static uint32_t size(JSContext *cx, HandleObject obj);
|
|
static MOZ_MUST_USE bool get(JSContext *cx, HandleObject obj, HandleValue key,
|
|
MutableHandleValue rval);
|
|
static MOZ_MUST_USE bool has(JSContext *cx, HandleObject obj, HandleValue key, bool* rval);
|
|
static MOZ_MUST_USE bool delete_(JSContext *cx, HandleObject obj, HandleValue key, bool* rval);
|
|
|
|
// Set call for public JSAPI exposure. Does not actually return map object
|
|
// as stated in spec, expects caller to return a value. for instance, with
|
|
// webidl maplike/setlike, should return interface object.
|
|
static MOZ_MUST_USE bool set(JSContext *cx, HandleObject obj, HandleValue key, HandleValue val);
|
|
static MOZ_MUST_USE bool clear(JSContext *cx, HandleObject obj);
|
|
static MOZ_MUST_USE bool iterator(JSContext *cx, IteratorKind kind, HandleObject obj,
|
|
MutableHandleValue iter);
|
|
|
|
using UnbarrieredTable = OrderedHashMap<Value, Value, UnbarrieredHashPolicy, RuntimeAllocPolicy>;
|
|
friend class OrderedHashTableRef<MapObject>;
|
|
|
|
private:
|
|
static const ClassOps classOps_;
|
|
|
|
static const JSPropertySpec properties[];
|
|
static const JSFunctionSpec methods[];
|
|
static const JSPropertySpec staticProperties[];
|
|
ValueMap* getData() { return static_cast<ValueMap*>(getPrivate()); }
|
|
static ValueMap& extract(HandleObject o);
|
|
static ValueMap& extract(const CallArgs& args);
|
|
static void mark(JSTracer* trc, JSObject* obj);
|
|
static void finalize(FreeOp* fop, JSObject* obj);
|
|
static MOZ_MUST_USE bool construct(JSContext* cx, unsigned argc, Value* vp);
|
|
|
|
static bool is(HandleValue v);
|
|
static bool is(HandleObject o);
|
|
|
|
static MOZ_MUST_USE bool iterator_impl(JSContext* cx, const CallArgs& args, IteratorKind kind);
|
|
|
|
static MOZ_MUST_USE bool size_impl(JSContext* cx, const CallArgs& args);
|
|
static MOZ_MUST_USE bool size(JSContext* cx, unsigned argc, Value* vp);
|
|
static MOZ_MUST_USE bool get_impl(JSContext* cx, const CallArgs& args);
|
|
static MOZ_MUST_USE bool get(JSContext* cx, unsigned argc, Value* vp);
|
|
static MOZ_MUST_USE bool has_impl(JSContext* cx, const CallArgs& args);
|
|
static MOZ_MUST_USE bool set_impl(JSContext* cx, const CallArgs& args);
|
|
static MOZ_MUST_USE bool set(JSContext* cx, unsigned argc, Value* vp);
|
|
static MOZ_MUST_USE bool delete_impl(JSContext* cx, const CallArgs& args);
|
|
static MOZ_MUST_USE bool delete_(JSContext* cx, unsigned argc, Value* vp);
|
|
static MOZ_MUST_USE bool keys_impl(JSContext* cx, const CallArgs& args);
|
|
static MOZ_MUST_USE bool keys(JSContext* cx, unsigned argc, Value* vp);
|
|
static MOZ_MUST_USE bool values_impl(JSContext* cx, const CallArgs& args);
|
|
static MOZ_MUST_USE bool values(JSContext* cx, unsigned argc, Value* vp);
|
|
static MOZ_MUST_USE bool entries_impl(JSContext* cx, const CallArgs& args);
|
|
static MOZ_MUST_USE bool clear_impl(JSContext* cx, const CallArgs& args);
|
|
static MOZ_MUST_USE bool clear(JSContext* cx, unsigned argc, Value* vp);
|
|
};
|
|
|
|
class MapIteratorObject : public NativeObject
|
|
{
|
|
public:
|
|
static const Class class_;
|
|
|
|
enum { TargetSlot, RangeSlot, KindSlot, SlotCount };
|
|
|
|
static_assert(TargetSlot == ITERATOR_SLOT_TARGET,
|
|
"TargetSlot must match self-hosting define for iterated object slot.");
|
|
static_assert(RangeSlot == ITERATOR_SLOT_RANGE,
|
|
"RangeSlot must match self-hosting define for range or index slot.");
|
|
static_assert(KindSlot == ITERATOR_SLOT_ITEM_KIND,
|
|
"KindSlot must match self-hosting define for item kind slot.");
|
|
|
|
static const JSFunctionSpec methods[];
|
|
static MapIteratorObject* create(JSContext* cx, HandleObject mapobj, ValueMap* data,
|
|
MapObject::IteratorKind kind);
|
|
static void finalize(FreeOp* fop, JSObject* obj);
|
|
|
|
static MOZ_MUST_USE bool next(Handle<MapIteratorObject*> mapIterator,
|
|
HandleArrayObject resultPairObj, JSContext* cx);
|
|
|
|
static JSObject* createResultPair(JSContext* cx);
|
|
|
|
private:
|
|
inline MapObject::IteratorKind kind() const;
|
|
};
|
|
|
|
class SetObject : public NativeObject {
|
|
public:
|
|
enum IteratorKind { Keys, Values, Entries };
|
|
|
|
static_assert(Keys == ITEM_KIND_KEY,
|
|
"IteratorKind Keys must match self-hosting define for item kind key.");
|
|
static_assert(Values == ITEM_KIND_VALUE,
|
|
"IteratorKind Values must match self-hosting define for item kind value.");
|
|
static_assert(Entries == ITEM_KIND_KEY_AND_VALUE,
|
|
"IteratorKind Entries must match self-hosting define for item kind "
|
|
"key-and-value.");
|
|
|
|
static JSObject* initClass(JSContext* cx, JSObject* obj);
|
|
static const Class class_;
|
|
|
|
enum { NurseryKeysSlot, SlotCount };
|
|
|
|
static MOZ_MUST_USE bool keys(JSContext *cx, HandleObject obj,
|
|
JS::MutableHandle<GCVector<JS::Value>> keys);
|
|
static MOZ_MUST_USE bool values(JSContext *cx, unsigned argc, Value *vp);
|
|
static MOZ_MUST_USE bool add(JSContext *cx, HandleObject obj, HandleValue key);
|
|
static MOZ_MUST_USE bool has(JSContext *cx, unsigned argc, Value *vp);
|
|
|
|
// Publicly exposed Set calls for JSAPI access (webidl maplike/setlike
|
|
// interfaces, etc.)
|
|
static SetObject* create(JSContext *cx, HandleObject proto = nullptr);
|
|
static uint32_t size(JSContext *cx, HandleObject obj);
|
|
static MOZ_MUST_USE bool has(JSContext *cx, HandleObject obj, HandleValue key, bool* rval);
|
|
static MOZ_MUST_USE bool clear(JSContext *cx, HandleObject obj);
|
|
static MOZ_MUST_USE bool iterator(JSContext *cx, IteratorKind kind, HandleObject obj,
|
|
MutableHandleValue iter);
|
|
static MOZ_MUST_USE bool delete_(JSContext *cx, HandleObject obj, HandleValue key, bool *rval);
|
|
|
|
using UnbarrieredTable = OrderedHashSet<Value, UnbarrieredHashPolicy, RuntimeAllocPolicy>;
|
|
friend class OrderedHashTableRef<SetObject>;
|
|
|
|
private:
|
|
static const ClassOps classOps_;
|
|
|
|
static const JSPropertySpec properties[];
|
|
static const JSFunctionSpec methods[];
|
|
static const JSPropertySpec staticProperties[];
|
|
|
|
ValueSet* getData() { return static_cast<ValueSet*>(getPrivate()); }
|
|
static ValueSet& extract(HandleObject o);
|
|
static ValueSet& extract(const CallArgs& args);
|
|
static void mark(JSTracer* trc, JSObject* obj);
|
|
static void finalize(FreeOp* fop, JSObject* obj);
|
|
static bool construct(JSContext* cx, unsigned argc, Value* vp);
|
|
|
|
static bool is(HandleValue v);
|
|
static bool is(HandleObject o);
|
|
|
|
static bool isBuiltinAdd(HandleValue add, JSContext* cx);
|
|
|
|
static MOZ_MUST_USE bool iterator_impl(JSContext* cx, const CallArgs& args, IteratorKind kind);
|
|
|
|
static MOZ_MUST_USE bool size_impl(JSContext* cx, const CallArgs& args);
|
|
static MOZ_MUST_USE bool size(JSContext* cx, unsigned argc, Value* vp);
|
|
static MOZ_MUST_USE bool has_impl(JSContext* cx, const CallArgs& args);
|
|
static MOZ_MUST_USE bool add_impl(JSContext* cx, const CallArgs& args);
|
|
static MOZ_MUST_USE bool add(JSContext* cx, unsigned argc, Value* vp);
|
|
static MOZ_MUST_USE bool delete_impl(JSContext* cx, const CallArgs& args);
|
|
static MOZ_MUST_USE bool delete_(JSContext* cx, unsigned argc, Value* vp);
|
|
static MOZ_MUST_USE bool values_impl(JSContext* cx, const CallArgs& args);
|
|
static MOZ_MUST_USE bool entries_impl(JSContext* cx, const CallArgs& args);
|
|
static MOZ_MUST_USE bool entries(JSContext* cx, unsigned argc, Value* vp);
|
|
static MOZ_MUST_USE bool clear_impl(JSContext* cx, const CallArgs& args);
|
|
static MOZ_MUST_USE bool clear(JSContext* cx, unsigned argc, Value* vp);
|
|
};
|
|
|
|
class SetIteratorObject : public NativeObject
|
|
{
|
|
public:
|
|
static const Class class_;
|
|
|
|
enum { TargetSlot, RangeSlot, KindSlot, SlotCount };
|
|
|
|
static_assert(TargetSlot == ITERATOR_SLOT_TARGET,
|
|
"TargetSlot must match self-hosting define for iterated object slot.");
|
|
static_assert(RangeSlot == ITERATOR_SLOT_RANGE,
|
|
"RangeSlot must match self-hosting define for range or index slot.");
|
|
static_assert(KindSlot == ITERATOR_SLOT_ITEM_KIND,
|
|
"KindSlot must match self-hosting define for item kind slot.");
|
|
|
|
static const JSFunctionSpec methods[];
|
|
static SetIteratorObject* create(JSContext* cx, HandleObject setobj, ValueSet* data,
|
|
SetObject::IteratorKind kind);
|
|
static void finalize(FreeOp* fop, JSObject* obj);
|
|
|
|
static MOZ_MUST_USE bool next(Handle<SetIteratorObject*> setIterator,
|
|
HandleArrayObject resultObj, JSContext* cx);
|
|
|
|
static JSObject* createResult(JSContext* cx);
|
|
|
|
private:
|
|
inline SetObject::IteratorKind kind() const;
|
|
};
|
|
|
|
using SetInitGetPrototypeOp = NativeObject* (*)(JSContext*, Handle<GlobalObject*>);
|
|
using SetInitIsBuiltinOp = bool (*)(HandleValue, JSContext*);
|
|
|
|
template <SetInitGetPrototypeOp getPrototypeOp, SetInitIsBuiltinOp isBuiltinOp>
|
|
static MOZ_MUST_USE bool
|
|
IsOptimizableInitForSet(JSContext* cx, HandleObject setObject, HandleValue iterable, bool* optimized)
|
|
{
|
|
MOZ_ASSERT(!*optimized);
|
|
|
|
if (!iterable.isObject())
|
|
return true;
|
|
|
|
RootedObject array(cx, &iterable.toObject());
|
|
if (!IsPackedArray(array))
|
|
return true;
|
|
|
|
// Get the canonical prototype object.
|
|
RootedNativeObject setProto(cx, getPrototypeOp(cx, cx->global()));
|
|
if (!setProto)
|
|
return false;
|
|
|
|
// Ensures setObject's prototype is the canonical prototype.
|
|
if (setObject->staticPrototype() != setProto)
|
|
return true;
|
|
|
|
// Look up the 'add' value on the prototype object.
|
|
Shape* addShape = setProto->lookup(cx, cx->names().add);
|
|
if (!addShape || !addShape->hasSlot())
|
|
return true;
|
|
|
|
// Get the referred value, ensure it holds the canonical add function.
|
|
RootedValue add(cx, setProto->getSlot(addShape->slot()));
|
|
if (!isBuiltinOp(add, cx))
|
|
return true;
|
|
|
|
ForOfPIC::Chain* stubChain = ForOfPIC::getOrCreate(cx);
|
|
if (!stubChain)
|
|
return false;
|
|
|
|
return stubChain->tryOptimizeArray(cx, array.as<ArrayObject>(), optimized);
|
|
}
|
|
|
|
extern JSObject*
|
|
InitMapClass(JSContext* cx, HandleObject obj);
|
|
|
|
extern JSObject*
|
|
InitSetClass(JSContext* cx, HandleObject obj);
|
|
|
|
} /* namespace js */
|
|
|
|
#endif /* builtin_MapObject_h */
|